diff --git a/codes/cpp/chapter_backtracking/n_queens.cpp b/codes/cpp/chapter_backtracking/n_queens.cpp new file mode 100644 index 000000000..f89fac96e --- /dev/null +++ b/codes/cpp/chapter_backtracking/n_queens.cpp @@ -0,0 +1,65 @@ +/** + * File: n_queens.cpp + * Created Time: 2023-05-04 + * Author: Krahets (krahets@163.com) + */ + +#include "../utils/common.hpp" + +/* 回溯算法：N 皇后 */ +void backtrack(int row, int n, vector> &state, vector>> &res, vector &cols, + vector &diags1, vector &diags2) { + // 当放置完所有行时，记录解 + if (row == n) { + res.push_back(state); + return; + } + // 遍历所有列 + for (int col = 0; col < n; col++) { + // 计算该格子对应的主对角线和副对角线 + int diag1 = row - col + n - 1; + int diag2 = row + col; + // 剪枝：不允许该格子所在 (列 或 主对角线 或 副对角线) 包含皇后 + if (!(cols[col] || diags1[diag1] || diags2[diag2])) { + // 尝试：将皇后放置在该格子 + state[row][col] = "Q"; + cols[col] = diags1[diag1] = diags2[diag2] = true; + // 放置下一行 + backtrack(row + 1, n, state, res, cols, diags1, diags2); + // 回退：将该格子恢复为空位 + state[row][col] = "#"; + cols[col] = diags1[diag1] = diags2[diag2] = false; + } + } +} + +/* 求解 N 皇后 */ +vector>> nQueens(int n) { + // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位 + vector> state(n, vector(n, "#")); + vector cols(n, false); // 记录列是否有皇后 + vector diags1(2 * n - 1, false); // 记录主对角线是否有皇后 + vector diags2(2 * n - 1, false); // 记录副对角线是否有皇后 + vector>> res; + + backtrack(0, n, state, res, cols, diags1, diags2); + + return res; +} + +/* Driver Code */ +int main() { + int n = 4; + vector>> res = nQueens(n); + + cout << "输入棋盘长宽为 " << n << endl; + cout << "皇后放置方案共有 " << res.size() << " 种" << endl; + for (const vector> &state : res) { + cout << "--------------------" << endl; + for (const vector &row : state) { + printVector(row); + } + } + + return 0; +} diff --git a/codes/java/chapter_backtracking/n_queens.java b/codes/java/chapter_backtracking/n_queens.java new file mode 100644 index 000000000..b9a7e7702 --- /dev/null +++ b/codes/java/chapter_backtracking/n_queens.java @@ -0,0 +1,77 @@ +/** + * File: n_queens.java + * Created Time: 2023-05-04 + * Author: Krahets (krahets@163.com) + */ + +package chapter_backtracking; + +import java.util.*; + +public class n_queens { + /* 求解 N 皇后 */ + public static List>> nQueens(int n) { + // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位 + List> state = new ArrayList<>(); + for (int i = 0; i < n; i++) { + List row = new ArrayList<>(); + for (int j = 0; j < n; j++) { + row.add("#"); + } + state.add(row); + } + boolean[] cols = new boolean[n]; // 记录列是否有皇后 + boolean[] diags1 = new boolean[2 * n - 1]; // 记录主对角线是否有皇后 + boolean[] diags2 = new boolean[2 * n - 1]; // 记录副对角线是否有皇后 + List>> res = new ArrayList<>(); + + backtrack(0, n, state, res, cols, diags1, diags2); + + return res; + } + + /* 回溯算法：N 皇后 */ + public static void backtrack(int row, int n, List> state, List>> res, + boolean[] cols, boolean[] diags1, boolean[] diags2) { + // 当放置完所有行时，记录解 + if (row == n) { + List> copyState = new ArrayList<>(); + for (List sRow : state) { + copyState.add(new ArrayList<>(sRow)); + } + res.add(copyState); + return; + } + // 遍历所有列 + for (int col = 0; col < n; col++) { + // 计算该格子对应的主对角线和副对角线 + int diag1 = row - col + n - 1; + int diag2 = row + col; + // 剪枝：不允许该格子所在 (列 或 主对角线 或 副对角线) 包含皇后 + if (!(cols[col] || diags1[diag1] || diags2[diag2])) { + // 尝试：将皇后放置在该格子 + state.get(row).set(col, "Q"); + cols[col] = diags1[diag1] = diags2[diag2] = true; + // 放置下一行 + backtrack(row + 1, n, state, res, cols, diags1, diags2); + // 回退：将该格子恢复为空位 + state.get(row).set(col, "#"); + cols[col] = diags1[diag1] = diags2[diag2] = false; + } + } + } + + public static void main(String[] args) { + int n = 4; + List>> res = nQueens(n); + + System.out.println("输入棋盘长宽为 " + n); + System.out.println("皇后放置方案共有 " + res.size() + " 种"); + for (List> state : res) { + System.out.println("--------------------"); + for (List row : state) { + System.out.println(row); + } + } + } +} diff --git a/codes/python/chapter_backtracking/n_queens.py b/codes/python/chapter_backtracking/n_queens.py new file mode 100644 index 000000000..14a607915 --- /dev/null +++ b/codes/python/chapter_backtracking/n_queens.py @@ -0,0 +1,62 @@ +""" +File: n_queens.py +Created Time: 2023-04-26 +Author: Krahets (krahets@163.com) +""" + + +def backtrack( + row: int, + n: int, + state: list[list[str]], + res: list[list[list[str]]], + cols: list[bool], + diags1: list[bool], + diags2: list[bool], +): + """回溯算法：N 皇后""" + # 当放置完所有行时，记录解 + if row == n: + res.append([list(row) for row in state]) + return + # 遍历所有列 + for col in range(n): + # 计算该格子对应的主对角线和副对角线 + diag1 = row - col + n - 1 + diag2 = row + col + # 剪枝：不允许该格子所在 (列 或 主对角线 或 副对角线) 包含皇后 + if not (cols[col] or diags1[diag1] or diags2[diag2]): + # 尝试：将皇后放置在该格子 + state[row][col] = "Q" + cols[col] = diags1[diag1] = diags2[diag2] = True + # 放置下一行 + backtrack(row + 1, n, state, res, cols, diags1, diags2) + # 回退：将该格子恢复为空位 + state[row][col] = "#" + cols[col] = diags1[diag1] = diags2[diag2] = False + + +def n_queens(n: int) -> list[list[list[str]]]: + """求解 N 皇后""" + # 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位 + state = [["#" for _ in range(n)] for _ in range(n)] + cols = [False] * n # 记录列是否有皇后 + diags1 = [False] * (2 * n - 1) # 记录主对角线是否有皇后 + diags2 = [False] * (2 * n - 1) # 记录副对角线是否有皇后 + res = [] + backtrack(0, n, state, res, cols, diags1, diags2) + + return res + + +"""Driver Code""" +if __name__ == "__main__": + n = 4 + res = n_queens(n) + + print(f"输入棋盘长宽为 {n}") + print(f"皇后放置方案共有 {len(res)} 种") + for state in res: + print("--------------------") + for row in state: + print(row) diff --git a/docs/chapter_backtracking/n_queens_problem.assets/n_queens_cols_diagonals.png b/docs/chapter_backtracking/n_queens_problem.assets/n_queens_cols_diagonals.png new file mode 100644 index 000000000..114762f53 Binary files /dev/null and b/docs/chapter_backtracking/n_queens_problem.assets/n_queens_cols_diagonals.png differ diff --git a/docs/chapter_backtracking/n_queens_problem.assets/n_queens_constraints.png b/docs/chapter_backtracking/n_queens_problem.assets/n_queens_constraints.png new file mode 100644 index 000000000..530a82985 Binary files /dev/null and b/docs/chapter_backtracking/n_queens_problem.assets/n_queens_constraints.png differ diff --git a/docs/chapter_backtracking/n_queens_problem.assets/n_queens_placing.png b/docs/chapter_backtracking/n_queens_problem.assets/n_queens_placing.png new file mode 100644 index 000000000..b5354ea72 Binary files /dev/null and b/docs/chapter_backtracking/n_queens_problem.assets/n_queens_placing.png differ diff --git a/docs/chapter_backtracking/n_queens_problem.assets/solution_4_queens.png b/docs/chapter_backtracking/n_queens_problem.assets/solution_4_queens.png new file mode 100644 index 000000000..2781075b2 Binary files /dev/null and b/docs/chapter_backtracking/n_queens_problem.assets/solution_4_queens.png differ diff --git a/docs/chapter_backtracking/n_queens_problem.md b/docs/chapter_backtracking/n_queens_problem.md new file mode 100644 index 000000000..4fca7367f --- /dev/null +++ b/docs/chapter_backtracking/n_queens_problem.md @@ -0,0 +1,115 @@ +# N 皇后问题 + +!!! question "根据国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。给定 $n$ 个皇后和一个 $n \times n$ 大小的棋盘，寻找使得所有皇后之间无法相互攻击的摆放方案。" + +如下图所示，当 $n = 4$ 时，共可以找到两个解。从回溯算法的角度看，$n \times n$ 大小的棋盘共有 $n^2$ 个格子，给出了所有的选择 `choices` 。在逐个放置皇后的过程中，棋盘状态在不断地变化，每个时刻的棋盘就是状态 `state` 。 + +![4 皇后问题的解](n_queens_problem.assets/solution_4_queens.png) + +本题共有三个约束条件：**多个皇后不能在同一行、同一列和同一对角线**。值得注意的是，对角线分为主对角线 `\` 和副对角线 `/` 两种。 + +![n 皇后问题的约束条件](n_queens_problem.assets/n_queens_constraints.png) + +皇后的数量和棋盘的行数都为 $n$ ，因此我们容易得到第一个推论：**棋盘每行都允许且只允许放置一个皇后**。这意味着，我们可以采取逐行放置策略：从第一行开始，在每行放置一个皇后，直至最后一行结束。**此策略起到了剪枝的作用**，它避免了同一行出现多个皇后的所有搜索分支。 + +下图展示了 $4$ 皇后问题的逐行放置过程。受篇幅限制，下图仅展开了第一行的一个搜索分支。在搜索过程中，我们将不满足列约束和对角线约束的方案都剪枝了。 + +![逐行放置策略](n_queens_problem.assets/n_queens_placing.png) + +为了实现根据列约束剪枝，我们可以利用一个长度为 $n$ 的布尔型数组 `cols` 记录每一列是否有皇后。在每次决定放置前，我们通过 `cols` 将已有皇后的列剪枝，并在回溯中动态更新 `cols` 的状态。 + +那么，如何处理对角线约束呢？设棋盘中某个格子的行列索引为 `(row, col)` ，观察矩阵的某条主对角线，**我们发现该对角线上所有格子的行索引减列索引相等**，即 `row - col` 为恒定值。换句话说，若两个格子满足 `row1 - col1 == row2 - col2` ，则这两个格子一定处在一条主对角线上。 + +利用该性质，我们可以借助一个数组 `diag1` 来记录每条主对角线上是否有皇后。注意，$n$ 维方阵 `row - col` 的范围是 $[-n + 1, n - 1]$ ，因此共有 $2n - 1$ 条主对角线。 + +![处理列约束和对角线约束](n_queens_problem.assets/n_queens_cols_diagonals.png) + +同理，**次对角线上的所有格子的 `row + col` 是恒定值**。我们可以使用同样的方法，借助数组 `diag2` 来处理次对角线约束。 + +根据以上分析，我们便可以写出 $n$ 皇后的解题代码。 + +=== "Java" + + ```java title="n_queens.java" + [class]{n_queens}-[func]{backtrack} + + [class]{n_queens}-[func]{nQueens} + ``` + +=== "C++" + + ```cpp title="n_queens.cpp" + [class]{}-[func]{backtrack} + + [class]{}-[func]{nQueens} + ``` + +=== "Python" + + ```python title="n_queens.py" + [class]{}-[func]{backtrack} + + [class]{}-[func]{n_queens} + ``` + +=== "Go" + + ```go title="n_queens.go" + [class]{}-[func]{backtrack} + + [class]{}-[func]{nQueens} + ``` + +=== "JavaScript" + + ```javascript title="n_queens.js" + [class]{}-[func]{backtrack} + + [class]{}-[func]{nQueens} + ``` + +=== "TypeScript" + + ```typescript title="n_queens.ts" + [class]{}-[func]{backtrack} + + [class]{}-[func]{nQueens} + ``` + +=== "C" + + ```c title="n_queens.c" + [class]{}-[func]{backtrack} + + [class]{}-[func]{nQueens} + ``` + +=== "C#" + + ```csharp title="n_queens.cs" + [class]{n_queens}-[func]{backtrack} + + [class]{n_queens}-[func]{nQueens} + ``` + +=== "Swift" + + ```swift title="n_queens.swift" + [class]{}-[func]{backtrack} + + [class]{}-[func]{nQueens} + ``` + +=== "Zig" + + ```zig title="n_queens.zig" + [class]{}-[func]{backtrack} + + [class]{}-[func]{nQueens} + ``` + +## 复杂度分析 + +逐行放置 $n$ 次，考虑列约束，则从第一行到最后一行分别有 $n, n-1, \cdots, 2, 1$ 个选择，**因此时间复杂度为 $O(n!)$** 。实际上，根据对角线约束的剪枝也能够大幅地缩小搜索空间，因而搜索效率往往优于以上时间复杂度。 + +`state` 使用 $O(n^2)$ 空间，`cols` , `diags1` , `diags2` 皆使用 $O(n)$ 空间。最大递归深度为 $n$ ，使用 $O(n)$ 栈帧空间。因此，**空间复杂度为 $O(n^2)$** 。 diff --git a/docs/chapter_backtracking/permutations_problem.md b/docs/chapter_backtracking/permutations_problem.md index 7d240412a..f1a759da2 100644 --- a/docs/chapter_backtracking/permutations_problem.md +++ b/docs/chapter_backtracking/permutations_problem.md @@ -218,3 +218,9 @@ 下图展示了两个剪枝条件的生效范围。注意，树中的每个节点代表一个选择，从根节点到叶节点的路径上的各个节点构成一个排列。 ![两种剪枝条件的作用范围](permutations_problem.assets/permutations_ii_pruning_summary.png) + +## 复杂度分析 + +假设元素两两之间互不相同，则 $n$ 个元素共有 $n!$ 种排列（阶乘）；在记录结果时，需要复制长度为 $n$ 的列表，使用 $O(n)$ 时间。因此，**时间复杂度为 $O(n!n)$** 。 + +最大递归深度为 $n$ ，使用 $O(n)$ 栈帧空间。`selected` 使用 $O(n)$ 空间。同一时刻最多共有 $n$ 个 `duplicated` ，使用 $O(n^2)$ 空间。因此，**全排列 I 的空间复杂度为 $O(n)$ ，全排列 II 的空间复杂度为 $O(n^2)$** 。 diff --git a/mkdocs.yml b/mkdocs.yml index ec5339145..785b0102b 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -190,6 +190,7 @@ nav: - 13.     回溯算法: - 13.1.   回溯算法（New）: chapter_backtracking/backtracking_algorithm.md - 13.2.   全排列问题（New）: chapter_backtracking/permutations_problem.md + - 13.3.   n 皇后问题（New）: chapter_backtracking/n_queens_problem.md - 14.     附录: - 14.1.   编程环境安装: chapter_appendix/installation.md - 14.2.   一起参与创作: chapter_appendix/contribution.md