LeetCode - 解题笔记 - 52 - N-Queens II

N-Queens II

Solution 1

这个题就是上一个题的输出变体，不需要生成所有的结果了，只需要计算有多少种不同的结果，只需要讲前一题的代码改动一下就可以了（因为搜索逻辑是不变的，只是优化上会有调整，但是个人认为已经用上比较理想的优化方式了）。

• 时间复杂度：$O(n!)$，其中$n$为放置的皇后个数，对应棋盘的尺寸。
• 空间复杂度：$O(n)$，其中$n$为放置的皇后个数，对应棋盘的尺寸。

class Solution {
public:
    int totalNQueens(int n) {
        int ans = 0;
        vector<int> posRow = vector<int>(n, -1); // 每行皇后的位置
        vector<bool> stateCol = vector<bool>(n, false); // 每列对应的位置
        vector<bool> stateUp = vector<bool>(n * 2, false); // 左下到右上对角
        vector<bool> stateDown = vector<bool>(n * 2, false); // 左上到右下对角
        this->dfs(0, n, ans, posRow, stateCol, stateUp, stateDown);
        
        return ans;
    }
    
private:
    void dfs(int row, int n, int &ans, vector<int> &posRow, vector<bool> &stateCol, vector<bool> &stateUp, vector<bool> &stateDown) {
        if (row == n) {
            ans++;
            return;
        }

        for (int i = 0; i < n; ++i) {
            if (stateCol[i] || stateUp[n + row + i] || stateDown[n + row - i]) { continue; }

            posRow[row] = i;

            stateCol[i] = true; // 对应列不能放
            stateUp[n + row + i] = true; // 左下到右上对角不能放
            stateDown[n + row - i] = true; // 左上到右下对角不能放

            this->dfs(row + 1, n, ans, posRow, stateCol, stateUp, stateDown);

            stateDown[n + row - i] = false;
            stateUp[n + row + i] = false;
            stateCol[i] = false;
          
            posRow[row] = -1;
        }
    }
};

Solution 2

Solution 1的Python实现

class Solution:
    def totalNQueens(self, n: int) -> int:
        
        def dfs(row: int) -> None:
            if row == n:
                nonlocal ans
                ans += 1
                return
                
            for i in range(n):
                # print(len(stateUp), n + row + i, len(stateDown), n + row - i)
                if stateCol[i] or stateUp[row + i] or stateDown[n + row - i]: continue
                    
                posRow[row] = i
                
                stateCol[i] = True
                stateUp[row + i] = True
                stateDown[n + row - i] = True
                
                dfs(row + 1)
                
                stateDown[n + row - i] = False;
                stateUp[row + i] = False;
                stateCol[i] = False;
                
                posRow[row] = -1
        
        ans = 0

        posRow = [-1] * n
        stateCol = [False] * n
        stateUp = [False] * (2 * n)
        stateDown = [False] * (2 * n)
        
        dfs(0)
        
        return ans