【经典算法题】N皇后

【经典算法题】N皇后

Leetcode 0051 N皇后

题目描述：Leetcode 0051 N皇后

分析

• 本题的考点：递归回溯。

• 递归过程中我们依次枚举每行，然后看这一行中皇后可以放置在哪个位置。

• 对于当前枚举的某行u，如果判断该行中的第i列是否可以放置一个皇后呢？可以使用三个数组col、dg、udg表示列、左上到右下斜线、右上到左下斜线中是否放置了皇后。坐标转化关系如下：

代码

• C++

class Solution {
public:
    int n;
    vector<bool> col, dg, udg;
    vector<vector<string>> ans;
    vector<string> path;

    vector<vector<string>> solveNQueens(int _n) {
        n = _n;
        col = vector<bool>(n);
        dg = udg = vector<bool>(n * 2 - 1);
        path = vector<string>(n, string(n, '.'));

        dfs(0);
        return ans;
    }

    void dfs(int u) {
        if (u == n) {
            ans.push_back(path);
            return;
        }

        for (int i = 0; i < n; i ++ ) {
            if (!col[i] && !dg[u - i + n - 1] && !udg[u + i]) {
                col[i] = dg[u - i + n - 1] = udg[u + i] = true;
                path[u][i] = 'Q';
                dfs(u + 1);
                path[u][i] = '.';
                col[i] = dg[u - i + n - 1] = udg[u + i] = false;
            }
        }
    }
};

• Java

class Solution {

    int n;
    boolean[] col, dg, udg;
    List<List<String>> ans = new ArrayList<>();
    char[][] path;

    public List<List<String>> solveNQueens(int _n) {

        n = _n;
        col = new boolean[n];
        dg = new boolean[n * 2 - 1]; udg = new boolean[n * 2 - 1];
        path = new char[n][n];
        for (int i = 0; i < n; i++) Arrays.fill(path[i], '.');

        dfs(0);
        return ans; 
    }

    // 当前考察第u行
    private void dfs(int u) {
        if (u == n) {
            List<String> t = new ArrayList<>();
            for (int i = 0; i < n; i++) t.add(new String(path[i]));
            ans.add(t);
            return;
        }

        for (int i = 0; i < n; i++) 
            if (!col[i] && !dg[u - i + n - 1] && !udg[u + i]) {
                col[i] = dg[u - i + n - 1] = udg[u + i] = true;
                path[u][i] = 'Q';
                dfs(u + 1);
                path[u][i] = '.';
                col[i] = dg[u - i + n - 1] = udg[u + i] = false;
            }
    }
}

• Python

class Solution:
    def solveNQueens(self, n: int) -> List[List[str]]:
        col = [False for _ in range(n)]
        dg = [False for _ in range(2 * n + 1)]
        udg = [False for _ in range(2 * n + 1)]

        ans = []
        path = [['.' for _ in range(n)] for _ in range(n)]
        self.dfs(0, n, col, dg, udg, path, ans)
        return ans
    
    def dfs(self, u, n, col, dg, udg, path, ans):
        if u == n:
            t = []
            for i in range(n):
                t.append("".join(path[i]))
            ans.append(t)
            return
        for i in range(n):
            if not col[i] and not dg[u - i + n - 1] and not udg[u + i]:
                col[i] = dg[u - i + n - 1] = udg[u + i] = True
                path[u][i] = 'Q'
                self.dfs(u + 1, n, col, dg, udg, path, ans)
                path[u][i] = '.'
                col[i] = dg[u - i + n - 1] = udg[u + i] = False

时空复杂度分析

• 时间复杂度：指数级别的。

• 空间复杂度：和递归深度有关。

Leetcode 0052 N皇后II

题目描述：Leetcode 0052 N皇后II

分析

• 本题的考点：递归回溯。

• 递归过程中我们依次枚举每行，然后看这一行中皇后可以放置在哪个位置。并在过程中记录方案数。

• 对于当前枚举的某行u，如果判断该行中的第i列是否可以放置一个皇后呢？可以使用三个数组col、dg、udg表示列、左上到右下斜线、右上到左下斜线中是否放置了皇后。坐标转化关系如下：

代码

• C++

class Solution {
public:
    int n;
    vector<bool> col, dg, udg;

    int totalNQueens(int _n) {
        n = _n;
        col = vector<bool>(n);
        dg = udg = vector<bool>(n * 2 - 1);

        return dfs(0);
    }
	
    // 返回方案数
    int dfs(int u) {
        if (u == n) return 1;
		
        int res = 0;
        for (int i = 0; i < n; i ++ ) {
            if (!col[i] && !dg[u - i + n - 1] && !udg[u + i]) {
                col[i] = dg[u - i + n - 1] = udg[u + i] = true;
                res += dfs(u + 1);
                col[i] = dg[u - i + n - 1] = udg[u + i] = false;
            }
        }
        return res;
    }
};

• Java

class Solution {

    int n;
    boolean[] col, dg, udg;

    public int totalNQueens(int _n) {

        n = _n;
        col = new boolean[n];
        dg = new boolean[n * 2 - 1]; udg = new boolean[n * 2 - 1];

        return dfs(0);
    }

    // 返回方案数
    private int dfs(int u) {
        if (u == n) return 1;

        int res = 0;
        for (int i = 0; i < n; i++) 
            if (!col[i] && !dg[u - i + n - 1] && !udg[u + i]) {
                col[i] = dg[u - i + n - 1] = udg[u + i] = true;
                res += dfs(u + 1);
                col[i] = dg[u - i + n - 1] = udg[u + i] = false;
            }
        return res;
    }
}

• Python

class Solution:
    def totalNQueens(self, n: int) -> int:
        col = [False for _ in range(n)]
        dg = [False for _ in range(2 * n - 1)]
        udg = [False for _ in range(2 * n - 1)]

        return self.dfs(0, n, col, dg, udg)

    def dfs(self, u, n, col, dg, udg):
        if u == n:
            return 1
        res = 0
        for i in range(n):
            if not col[i] and not dg[u - i + n - 1] and not udg[u + i]:
                col[i] = dg[u - i + n - 1] = udg[u + i] = True
                res += self.dfs(u + 1, n, col, dg, udg)
                col[i] = dg[u - i + n - 1] = udg[u + i] = False
        return res

时空复杂度分析

• 时间复杂度：指数级别的。

• 空间复杂度：和递归深度有关。