Leetcode 51: N-Queens

le is the problem of placing n queens on an n×n chessboard such that no two queens attack each other.

Given an integer n, return all distinct solutions to the n-queens puzzle.

Each solution contains a distinct board configuration of the n-queens' placement, where 'Q' and '.' both indicate a queen and an empty space respectively.

For example,
There exist two distinct solutions to the 4-queens puzzle:

[
 [".Q..",  // Solution 1
  "...Q",
  "Q...",
  "..Q."],

 ["..Q.",  // Solution 2
  "Q...",
  "...Q",
  ".Q.."]
]

public class Solution {
    public IList<IList<string>> SolveNQueens(int n) {
        var result = new List<IList<string>>();
        
        if (n < 1) return result;
        
        var board = new int[n, n];
        
        CanSolve(board, n, 0, result);
        
        return result;
    }
    
    private bool CanSolve(int[,] board, int n, int row, IList<IList<string>> results)
    {
        if (row >= n) 
        {
            var result = new List<string>();
            for (int i = 0; i < n; i++)
            {
                var sb = new StringBuilder();
                for (int j = 0; j < n; j++)
                {
                    sb.Append(board[i, j] == 0 ? '.' : 'Q');            
                }
                
                result.Add(sb.ToString());
            }
            
            results.Add(result);
            
            return true;
        }
        
        bool canSolve = false;
        
        for (int j = 0; j < n; j++)
        {
            if (IsValidPosition(board, n, row, j))
            {
                board[row, j] = 1;
                if (CanSolve(board, n, row + 1, results))
                {
                    canSolve = true;
                }
                board[row, j] = 0;                
            }
        }
        
        return canSolve;
    }
    
    private bool IsValidPosition(int[,] board, int n, int row, int col)
    {
        // check whether we can put a queen at board[row, j]
        // 1. whether it has alreay a queen on this column
        for (int i = 0; i < row; i++)
        {
            if (board[i, col] == 1) return false;
        }
        
        // check backward diagonal
        int r = row - 1, c = col - 1;
        while (r >= 0 && c >= 0)
        {
            if (board[r, c] == 1) return false;
            r--;
            c--;
        }
        
        // check forward diagonal
        r = row - 1;
        c = col + 1;
        while (r >= 0 && c < n)
        {
            if (board[r, c] == 1) return false;
            r--;
            c++;
        }
        
        return true;
    }
}