Sudoku solver - code review - March 25, 2018

SudokuSolve_codereview_March25_2018.cs

using System;

class Solution
{
    public static bool SudokuSolve(char[,] board)
    {
      return SudokuSolve(board, 0, 0);
    }
  
    public static bool SudokuSolve(char[,] board, int i, int j)
    {
      // find empty cell
      // if we reached end of matrix and no empty cell => true
      var m = board.GetLength(0);
      var n = board.GerLength(1);
      
      var emptyRow = -1;
      var emptyColumn = -1;
      
      // find next avaiable dot - (i, j) - too much - recursive -> call next iteration
      for (int row=i; row<m; row++)
      {
        for(int column=0; column<n; column++) // you should
        {
          if(row == i && column < j)
            continue; 
            
          if (board[row,column] == '.')
          {
            emptyRow = row;
            emptyColumn = column;
            break;
          }
        }
        if (emptyRow != -1)
        {
          break;
        }
      }
      
      if (emptyRow == -1)
      {
        return true;
      }      
      
      // find valid digits for it
      // no valid digits => false
      var set = new HashSet<int>();
      for (int k=1; k<=9; k++)
      {
        set.Add(k);
      }
      
      for (int k=0; k<n; k++)
      {
        if (set.Contains(board[emptyRow, k])) // no need to check
        {
          set.Remove(board[emptyRow, k]);
        }
      }
      
      for (int k=0; k<m; k++)
      {
        if (set.Contains(board[k, emptyColumn]))
        {
          set.Remove(board[k, emptyColumn]);
        }
      }   
      
      var squareRow = (emptyRow / 3)*3;
      var squareColumn = (emptyColumn / 3)*3;
      for (int k=squareRow; k<squareRow+3; k++)
      {
        for (int s=squareColumn; s<squareColumn+3; s++)
        {
          if (set.Contains(board[k, s]))
          {
            set.Remove(board[k, s]);
          }
        }
      }
      
      if (!set.Any())
      {
        return false;
      }
      
      // loop over valid digits and backtrack
      // 5 3 _  _     _ 
      //              - fail -> .
      //        next iteration
      foreach (var num in set)
      {
        board[emptyRow,emptyColumn] = '0' + num;
        var nextColumn = (emptyColumn+1)%n;
        var nextRow = nextColumn == 0 ? emptyRow + 1 : emptyRow;
        var result = SudokuSolve(board, nextRow, nextColumn);      
        if (result)
        {
          return true;
        }
        board[emptyRow,emptyColumn] = '.';
        //backtracking ...
      }
      return false;
    }
    
    static void Main(string[] args)
    {
    }
}