added DhNextCellChooser

README.md

     - '0': Empty sudoku
     - filename: load from the specified file
 - Next cell chooser: The way to select next cell to fill. Possible values:
+    - 'mrv-dh': Use the Minimum remaining values strategy then Degree heuristic strategy if multiple cells match
     - 'mrv' (default): Use the Minimum remaining values strategy
     - 'dh': Use the Degree heuristic strategy
     - 'basic': Select the first blank value, from up to down and left to right

uqac-ia-sudoku-csp/Board.cs

         {
             return GetNeighboors(x, y).Where(pair => GetNumber(x, y) == null);
         }
+
+        public IEnumerable<KeyValuePair<int, int>> GetEmptyCells()
+        {
+            var list = new List<KeyValuePair<int, int>>();
+            for (var y = 0; y < Size; ++y)
+            {
+                for (var x = 0; x < Size; ++x)
+                {
+                    if (GetNumber(x, y) == null)
+                    {
+                        list.Add(new KeyValuePair<int, int>(x, y));
+                    }
+                }
+            }
+            return list;
+        }
     }
 }

uqac-ia-sudoku-csp/Program.cs

             board.Print(Console.Out);
 
             INextCellChooser nextCellChooser = null;
-            if (valueChooser == "mrv")
+            if (valueChooser == "mrv-dh")
             {
-                nextCellChooser = new MrvNextCellChooser();
+                nextCellChooser = new MrvNextCellChooser(new DhNextCellChooser());
+            }
+            else if (valueChooser == "mrv")
+            {
+                nextCellChooser = new MrvNextCellChooser(null);
             }
             else if (valueChooser == "dh")
             {

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

 using System.Collections.Generic;
+using System.Linq;
 using uqac_ia_sudoku_csp.Interfaces;
 
 namespace uqac_ia_sudoku_csp.Solver.NextValueChoosers
     {
         public void SelectVariable(Board board, out int x, out int y, IList<IConstraint> constraints)
         {
-            throw new System.NotImplementedException();
+            var dict = new Dictionary<KeyValuePair<int, int>, int>();
+            for (var yy = 0; yy < board.Size; ++yy)
+            {
+                for (var xx = 0; xx < board.Size; ++xx)
+                {
+                    if (board.GetNumber(xx, yy) == null)
+                    {
+                        var k = new KeyValuePair<int, int>(xx, yy);
+                        if (!dict.ContainsKey(k))
+                        {
+                            dict.Add(k, 0);
+                        }
+                        ++dict[k];
+                    }
+                }
+            }
+            if (!dict.Any())
+            {
+                x = -1;
+                y = -1;
+            }
+            else
+            {
+                var k = dict.OrderByDescending(pair => pair.Value).First().Key;
+                x = k.Key;
+                y = k.Value;
+            }
         }
     }
 }

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

 {
     public class MrvNextCellChooser : INextCellChooser
     {
+        private readonly INextCellChooser _nextCellChooser;
+
+        public MrvNextCellChooser(INextCellChooser nextCellChooser)
+        {
+            _nextCellChooser = nextCellChooser;
+        }
+
         public void SelectVariable(Board board, out int x, out int y, IList<IConstraint> constraints)
         {
             var avail = 1;
-            while (avail <= board.Size)
+            var vars = new List<KeyValuePair<int, int>>();
+            while (avail <= board.Size && vars.Count == 0)
             {
                 for (var xx = 0; xx < board.Size; ++xx)
                 {
                             var remaining = GetRemainingValue(board, xx, yy, constraints);
                             if (remaining == avail)
                             {
-                                x = xx;
-                                y = yy;
-                                return;
+                                vars.Add(new KeyValuePair<int, int>(xx, yy));
                             }
                         }
                     }
                 }
                 ++avail;
             }
-            x = -1;
-            y = -1;
+            if (vars.Count == 0)
+            {
+                x = -1;
+                y = -1;
+            }
+            else if (vars.Count == 1 || _nextCellChooser == null)
+            {
+                x = vars[0].Key;
+                y = vars[0].Value;
+            }
+            else
+            {
+                _nextCellChooser.SelectVariable(board, out x, out y, constraints);
+            }
         }
 
         protected int GetRemainingValue(Board board, int x, int y, IList<IConstraint> constraints)