LeetCode 51. N-Queens

原题链接在此：https://leetcode.com/problems/n-queens/

题目：

The n-queens puzzle 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.."]
]

题解：

DFS+recursion. 用递归处理子问题，当某一个子问题出错时就回溯到上一层。这类问题的时间复杂度都是指数量级的。

在子问题中，列出一种例子，判断当前情况是否合法，如果不合法就回到上一层，如果合法就DFS到下一层，当填满后就保存此正确结果。然后去掉最后添加的数，列举其他方法。但本题中不需要去掉就是因为此题是用一个一维数组代表棋盘，每个index代表行, value 代表列.

[2,0,1,3] 代表[0,2],[1,0],[2,1],[3,3]上有皇后。

Time Complexity: NP问题都是exponential的. Space: O(n), 新建了row. Recursion 用了n层stack.

AC Java:

public class Solution {
    public List<List<String>> solveNQueens(int n) {
        List<List<String>> res = new ArrayList<List<String>>();
        if(n<=0){
            return res;
        }
        helper(n, 0, new int[n], res);
        return res;
    }
    private void helper(int n, int cur, int [] row, List<List<String>> res){
        //cur stands for current position of row
        //这里表示这一条已经加到头了
        if(cur == n){
            List<String> item = new ArrayList<String>();
            for(int i = 0; i<row.length; i++){
                StringBuilder sb = new StringBuilder();
                for(int j = 0; j<row.length; j++){
                    if(row[i] != j){
                        sb.append('.');
                    }else{
                        sb.append('Q');
                    }
                }
                item.add(sb.toString());
            }
            res.add(item);
            return;
        }
        
        //没到头时就从0到n挨个试着加入row
        for(int i = 0; i<n; i++){
            row[cur] = i;
            //检查到目前的cur位置时, row是否合法
            if(isValid(cur, row)){
                helper(n, cur+1, row, res);
            }
        }
    }
    
    private boolean isValid(int cur, int [] row){
        for(int i = 0; i<cur; i++){
            if(row[i] == row[cur] || Math.abs(row[cur] - row[i]) == cur-i){
                return false;
            }
        }
        return true;
    }
}

AC Python:

class Solution:
    def solveNQueens(self, n: int) -> List[List[str]]:
        res = []
        if n <= 0:
            return res
        board = [0] * n
        self.dfs(n, board, 0, res)
        return res
    
    def dfs(self, n: int, board: List[int], ind: int, res: List[List[str]]) -> None:
        if ind == n:
            res.append(self.construct(board))
            return
        
        for i in range(n):
            board[ind] = i
            if self.isValid(ind, board):
                self.dfs(n, board, ind + 1, res)
        
    def construct(self, board: List[int]) -> List[str]:
        res = []
        for i in range(len(board)):
            item = ["."] * len(board)
            item[board[i]] = "Q"
            res.append("".join(item))
        
        return res
    
    def isValid(self, cur: int, board: List[int]) -> bool:
        for i in range(0, cur):
            if board[i] == board[cur] or abs(board[cur] - board[i]) == cur - i:
                return False
            
        return True

跟上N-Queens II.