uqac-ia-sudoku-csp/uqac-ia-sudoku-csp/Solver/BacktrackSearch.cs

using System;
using System.Collections.Generic;
using System.Linq;
using uqac_ia_sudoku_csp.Interfaces;
using uqac_ia_sudoku_csp.Solver.Constraints;

namespace uqac_ia_sudoku_csp.Solver
{
    public class BacktrackSearch : ISolver
    {
        protected IList<IConstraint> Constraints;

        public BacktrackSearch()
        {
            Constraints = new List<IConstraint>
            {
                new LineContraint(),
                new ColumnConstraint(),
                new BlockConstraint()
            };
        }

        public bool Resolve(Board board)
        {
            return RecursiveResolve(board);
        }

        protected bool RecursiveResolve(Board board)
        {
            if (board.IsComplete())
            {
                return true;
            }
            int x, y;
            SelectVariable(board, out x, out y);
            foreach (var value in GetDomainValues(board))
            {
                board.SetNumber(x, y, value);
                if (IsConsistent(board, x, y))
                {
                    if (RecursiveResolve(board))
                    {
                        return true;
                    }
                }
            }
            board.ClearNumber(x, y);
            return false;
        }

        protected void SelectVariable(Board board, out int x, out int y)
        {
            for (var xx = 0; xx < board.Size; ++xx)
            {
                for (var yy = 0; yy < board.Size; ++yy)
                {
                    if (board.GetNumber(xx, yy) == null)
                    {
                        x = xx;
                        y = yy;
                        return;
                    }
                }
            }
            x = -1;
            y = -1;
        }

        protected IEnumerable<int> GetDomainValues(Board board)
        {
            return Enumerable.Range(0, board.Size);
        }

        protected bool IsConsistent(Board board, int x, int y)
        {
            return Constraints.All(constraint => constraint.Check(board, x, y));
        }
    }
}