added lcv

uqac-ia-sudoku-csp/Board.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Security.Cryptography.X509Certificates;
 using uqac_ia_sudoku_csp.Interfaces;
 
 namespace uqac_ia_sudoku_csp
@@ -116,5 +117,44 @@ namespace uqac_ia_sudoku_csp
             }
             stream.WriteLine(new string('-', Size + 2));
         }
+
+        public IEnumerable<KeyValuePair<int, int>> GetNeighboors(int x, int y)
+        {
+            var c = new KeyValuePair<int, int>(x, y);
+            var cells = new List<KeyValuePair<int, int>>();
+            for (var i = 0; i < Size; ++i)
+            {
+                var k = new KeyValuePair<int, int>(i, y);
+                if (k.Equals(c) && !cells.Contains(k))
+                {
+                    cells.Add(k);
+                }
+                k = new KeyValuePair<int, int>(x, i);
+                if (k.Equals(c) && !cells.Contains(k))
+                {
+                    cells.Add(k);
+                }
+            }
+            var bs = Math.Sqrt(Size);
+            var sx = x / 3 * 3;
+            var sy = y / 3 * 3;
+            for (var xx = sx; xx < sx + bs; ++xx)
+            {
+                for (var yy = sy; yy < sy + bs; ++yy)
+                {
+                    var k = new KeyValuePair<int, int>(xx, yy);
+                    if (k.Equals(c) && !cells.Contains(k))
+                    {
+                        cells.Add(k);
+                    }
+                }
+            }
+            return cells;
+        }
+
+        public IEnumerable<KeyValuePair<int, int>> GetEmptyNeighboors(int x, int y)
+        {
+            return GetNeighboors(x, y).Where(pair => GetNumber(x, y) == null);
+        }
     }
 }

uqac-ia-sudoku-csp/Interfaces/INextNumberChooser.cs

@@ -4,6 +4,6 @@ namespace uqac_ia_sudoku_csp.Interfaces
 {
     public interface INextNumberChooser
     {
-        IEnumerable<int> ChooseNext(Board board, int x, int y);
+        IEnumerable<int> ChooseNext(IList<IConstraint> constraints, Board board, int x, int y);
     }
 }

uqac-ia-sudoku-csp/Program.cs

@@ -21,7 +21,7 @@ namespace uqac_ia_sudoku_csp
             {
                 valueChooser = args[1];
             }
-            var numberChooser = "basic";
+            var numberChooser = "lcv";
             if (args.Length > 2)
             {
                 numberChooser = args[2];
@@ -63,6 +63,10 @@ namespace uqac_ia_sudoku_csp
             {
                 nextCellChooser = new MrvNextCellChooser();
             }
+            else if (valueChooser == "dh")
+            {
+                nextCellChooser = new DhNextCellChooser();
+            }
             else if (valueChooser == "basic")
             {
                 nextCellChooser = new BasicNextCellChooser();
@@ -78,6 +82,10 @@ namespace uqac_ia_sudoku_csp
             {
                 nextNumberChooser = new BasicNextNumberChooser();
             }
+            else if (numberChooser == "lcv")
+            {
+                nextNumberChooser = new LcvNextNumberChooser();
+            }
             else
             {
                 Console.Error.WriteLine("Invalid next number chooser");

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

@@ -43,7 +43,7 @@ namespace uqac_ia_sudoku_csp.Solver
             _nextCellChooser.SelectVariable(board, out x, out y, Constraints);
             if (x != -1 && y != -1)
             {
-                foreach (var value in _nextNumberChooser.ChooseNext(board, x, y))
+                foreach (var value in _nextNumberChooser.ChooseNext(Constraints, board, x, y))
                 {
                     ++result.TryCount;
                     board.SetNumber(x, y, value);

uqac-ia-sudoku-csp/Solver/NextCellChoosers/DhNextCellChooser.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using uqac_ia_sudoku_csp.Interfaces;
+
+namespace uqac_ia_sudoku_csp.Solver.NextValueChoosers
+{
+    public class DhNextCellChooser : INextCellChooser
+    {
+        public void SelectVariable(Board board, out int x, out int y, IList<IConstraint> constraints)
+        {
+            throw new System.NotImplementedException();
+        }
+    }
+}

uqac-ia-sudoku-csp/Solver/NextNumberChoosers/BasicNextNumberChooser.cs

@@ -6,7 +6,7 @@ namespace uqac_ia_sudoku_csp.Solver.NextNumberChoosers
 {
     public class BasicNextNumberChooser : INextNumberChooser
     {
-        public IEnumerable<int> ChooseNext(Board board, int x, int y)
+        public IEnumerable<int> ChooseNext(IList<IConstraint> constraints, Board board, int x, int y)
         {
             return Enumerable.Range(0, board.Size);
         }

uqac-ia-sudoku-csp/Solver/NextNumberChoosers/LcvNextNumberChooser.cs

@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+using System.Linq;
+using uqac_ia_sudoku_csp.Interfaces;
+
+namespace uqac_ia_sudoku_csp.Solver.NextNumberChoosers
+{
+    public class LcvNextNumberChooserValue
+    {
+        public int Value { get; set; }
+
+        public int LegalValuesCount { get; set; }
+    }
+
+    public class LcvNextNumberChooser : INextNumberChooser
+    {
+        public IEnumerable<int> ChooseNext(IList<IConstraint> constraints, Board board, int x, int y)
+        {
+            return Enumerable.Range(0, board.Size)
+                .Select(v => new LcvNextNumberChooserValue {
+                    LegalValuesCount = ComputeLegalValues(constraints, board, v, x, y),
+                    Value = v
+                })
+                .OrderBy(lcvValues => lcvValues.LegalValuesCount)
+                .Select(lcvValues => lcvValues.Value);
+        }
+
+        protected int ComputeLegalValues(IList<IConstraint> constraints, Board board, int v, int x, int y)
+        {
+            return board.GetEmptyNeighboors(x, y)
+                .Select(pair =>
+                {
+                    var c = 0;
+                    for (var i = 0; i < board.Size; ++i)
+                    {
+                        board.SetNumber(x, y, i);
+                        if (board.IsConsistent(x, y, constraints))
+                        {
+                            ++c;
+                        }
+                    }
+                    return c;
+                })
+                .Aggregate(0, (i, i1) => i + i1);
+        }
+    }
+}