build

2026-08-12 03:40:58 +00:00 · 2023-08-22 13:50:12 +08:00
parent 0c9bf14e20
commit 92a0853ab8
64 changed files with 478 additions and 479 deletions
@@ -12,7 +12,7 @@ comments: true

    给定一个二叉树，搜索并记录所有值为 $7$ 的节点，请返回节点列表。

-对于此题，我们前序遍历这颗树，并判断当前节点的值是否为 $7$ ，若是则将该节点的值加入到结果列表 `res` 之中。相关过程实现如下图和以下代码所示。
+对于此题，我们前序遍历这颗树，并判断当前节点的值是否为 $7$ ，若是则将该节点的值加入到结果列表 `res` 之中。相关过程实现如图 13-1 和以下代码所示。

 === "Java"

@@ -197,7 +197,7 @@ comments: true

 ![在前序遍历中搜索节点](backtracking_algorithm.assets/preorder_find_nodes.png)

-<p align="center"> 图：在前序遍历中搜索节点 </p>
+<p align="center"> 图 13-1 &nbsp; 在前序遍历中搜索节点 </p>

 ## 13.1.1 &nbsp; 尝试与回退

@@ -466,7 +466,7 @@ comments: true

 在每次“尝试”中，我们通过将当前节点添加进 `path` 来记录路径；而在“回退”前，我们需要将该节点从 `path` 中弹出，**以恢复本次尝试之前的状态**。

-观察下图所示的过程，**我们可以将尝试和回退理解为“前进”与“撤销”**，两个操作是互为逆向的。
+观察图 13-2 所示的过程，**我们可以将尝试和回退理解为“前进”与“撤销”**，两个操作是互为逆向的。

 === "<1>"
    ![尝试与回退](backtracking_algorithm.assets/preorder_find_paths_step1.png)
@@ -501,7 +501,7 @@ comments: true
 === "<11>"
    ![preorder_find_paths_step11](backtracking_algorithm.assets/preorder_find_paths_step11.png)

-<p align="center"> 图：尝试与回退 </p>
+<p align="center"> 图 13-2 &nbsp; 尝试与回退 </p>

 ## 13.1.2 &nbsp; 剪枝

@@ -795,11 +795,11 @@ comments: true
    }
    ```

-剪枝是一个非常形象的名词。如下图所示，在搜索过程中，**我们“剪掉”了不满足约束条件的搜索分支**，避免许多无意义的尝试，从而提高了搜索效率。
+剪枝是一个非常形象的名词。如图 13-3 所示，在搜索过程中，**我们“剪掉”了不满足约束条件的搜索分支**，避免许多无意义的尝试，从而提高了搜索效率。

 ![根据约束条件剪枝](backtracking_algorithm.assets/preorder_find_constrained_paths.png)

-<p align="center"> 图：根据约束条件剪枝 </p>
+<p align="center"> 图 13-3 &nbsp; 根据约束条件剪枝 </p>

 ## 13.1.3 &nbsp; 框架代码

@@ -1655,11 +1655,11 @@ comments: true
    }
    ```

-根据题意，我们在找到值为 7 的节点后应该继续搜索，**因此需要将记录解之后的 `return` 语句删除**。下图对比了保留或删除 `return` 语句的搜索过程。
+根据题意，我们在找到值为 7 的节点后应该继续搜索，**因此需要将记录解之后的 `return` 语句删除**。图 13-4 对比了保留或删除 `return` 语句的搜索过程。

 ![保留与删除 return 的搜索过程对比](backtracking_algorithm.assets/backtrack_remove_return_or_not.png)

-<p align="center"> 图：保留与删除 return 的搜索过程对比 </p>
+<p align="center"> 图 13-4 &nbsp; 保留与删除 return 的搜索过程对比 </p>

 相比基于前序遍历的代码实现，基于回溯算法框架的代码实现虽然显得啰嗦，但通用性更好。实际上，**许多回溯问题都可以在该框架下解决**。我们只需根据具体问题来定义 `state` 和 `choices` ，并实现框架中的各个方法即可。

@@ -8,17 +8,17 @@ comments: true

    根据国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。给定 $n$ 个皇后和一个 $n \times n$ 大小的棋盘，寻找使得所有皇后之间无法相互攻击的摆放方案。

-如下图所示，当 $n = 4$ 时，共可以找到两个解。从回溯算法的角度看，$n \times n$ 大小的棋盘共有 $n^2$ 个格子，给出了所有的选择 `choices` 。在逐个放置皇后的过程中，棋盘状态在不断地变化，每个时刻的棋盘就是状态 `state` 。
+如图 13-15 所示，当 $n = 4$ 时，共可以找到两个解。从回溯算法的角度看，$n \times n$ 大小的棋盘共有 $n^2$ 个格子，给出了所有的选择 `choices` 。在逐个放置皇后的过程中，棋盘状态在不断地变化，每个时刻的棋盘就是状态 `state` 。

 ![4 皇后问题的解](n_queens_problem.assets/solution_4_queens.png)

-<p align="center"> 图：4 皇后问题的解 </p>
+<p align="center"> 图 13-15 &nbsp; 4 皇后问题的解 </p>

-下图展示了本题的三个约束条件：**多个皇后不能在同一行、同一列、同一对角线**。值得注意的是，对角线分为主对角线 `\` 和次对角线 `/` 两种。
+图 13-16 展示了本题的三个约束条件：**多个皇后不能在同一行、同一列、同一对角线**。值得注意的是，对角线分为主对角线 `\` 和次对角线 `/` 两种。

 ![n 皇后问题的约束条件](n_queens_problem.assets/n_queens_constraints.png)

-<p align="center"> 图：n 皇后问题的约束条件 </p>
+<p align="center"> 图 13-16 &nbsp; n 皇后问题的约束条件 </p>

 ### 1. &nbsp; 逐行放置策略

@@ -26,11 +26,11 @@ comments: true

 也就是说，我们可以采取逐行放置策略：从第一行开始，在每行放置一个皇后，直至最后一行结束。

-如下图所示，为 $4$ 皇后问题的逐行放置过程。受画幅限制，下图仅展开了第一行的其中一个搜索分支，并且将不满足列约束和对角线约束的方案都进行了剪枝。
+如图 13-17 所示，为 $4$ 皇后问题的逐行放置过程。受画幅限制，图 13-17 仅展开了第一行的其中一个搜索分支，并且将不满足列约束和对角线约束的方案都进行了剪枝。

 ![逐行放置策略](n_queens_problem.assets/n_queens_placing.png)

-<p align="center"> 图：逐行放置策略 </p>
+<p align="center"> 图 13-17 &nbsp; 逐行放置策略 </p>

 本质上看，**逐行放置策略起到了剪枝的作用**，它避免了同一行出现多个皇后的所有搜索分支。

@@ -40,13 +40,13 @@ comments: true

 那么，如何处理对角线约束呢？设棋盘中某个格子的行列索引为 $(row, col)$ ，选定矩阵中的某条主对角线，我们发现该对角线上所有格子的行索引减列索引都相等，**即对角线上所有格子的 $row - col$ 为恒定值**。

-也就是说，如果两个格子满足 $row_1 - col_1 = row_2 - col_2$ ，则它们一定处在同一条主对角线上。利用该规律，我们可以借助下图所示的数组 `diag1` ，记录每条主对角线上是否有皇后。
+也就是说，如果两个格子满足 $row_1 - col_1 = row_2 - col_2$ ，则它们一定处在同一条主对角线上。利用该规律，我们可以借助图 13-18 所示的数组 `diag1` ，记录每条主对角线上是否有皇后。

 同理，**次对角线上的所有格子的 $row + col$ 是恒定值**。我们同样也可以借助数组 `diag2` 来处理次对角线约束。

 ![处理列约束和对角线约束](n_queens_problem.assets/n_queens_cols_diagonals.png)

-<p align="center"> 图：处理列约束和对角线约束 </p>
+<p align="center"> 图 13-18 &nbsp; 处理列约束和对角线约束 </p>

 ### 3. &nbsp; 代码实现

@@ -6,9 +6,9 @@ comments: true

 全排列问题是回溯算法的一个典型应用。它的定义是在给定一个集合（如一个数组或字符串）的情况下，找出这个集合中元素的所有可能的排列。

-下表列举了几个示例数据，包括输入数组和对应的所有排列。
+表 13-1 列举了几个示例数据，包括输入数组和对应的所有排列。

-<p align="center"> 表：数组与链表的效率对比 </p>
+<p align="center"> 表 13-1 &nbsp; 数组与链表的效率对比 </p>

 <div class="center-table" markdown>

@@ -30,11 +30,11 @@ comments: true

 从回溯代码的角度看，候选集合 `choices` 是输入数组中的所有元素，状态 `state` 是直至目前已被选择的元素。请注意，每个元素只允许被选择一次，**因此 `state` 中的所有元素都应该是唯一的**。

-如下图所示，我们可以将搜索过程展开成一个递归树，树中的每个节点代表当前状态 `state` 。从根节点开始，经过三轮选择后到达叶节点，每个叶节点都对应一个排列。
+如图 13-5 所示，我们可以将搜索过程展开成一个递归树，树中的每个节点代表当前状态 `state` 。从根节点开始，经过三轮选择后到达叶节点，每个叶节点都对应一个排列。

 ![全排列的递归树](permutations_problem.assets/permutations_i.png)

-<p align="center"> 图：全排列的递归树 </p>
+<p align="center"> 图 13-5 &nbsp; 全排列的递归树 </p>

 ### 1. &nbsp; 重复选择剪枝

@@ -43,13 +43,13 @@ comments: true
 - 在做出选择 `choice[i]` 后，我们就将 `selected[i]` 赋值为 $\text{True}$ ，代表它已被选择。
 - 遍历选择列表 `choices` 时，跳过所有已被选择过的节点，即剪枝。

-如下图所示，假设我们第一轮选择 1 ，第二轮选择 3 ，第三轮选择 2 ，则需要在第二轮剪掉元素 1 的分支，在第三轮剪掉元素 1, 3 的分支。
+如图 13-6 所示，假设我们第一轮选择 1 ，第二轮选择 3 ，第三轮选择 2 ，则需要在第二轮剪掉元素 1 的分支，在第三轮剪掉元素 1, 3 的分支。

 ![全排列剪枝示例](permutations_problem.assets/permutations_i_pruning.png)

-<p align="center"> 图：全排列剪枝示例 </p>
+<p align="center"> 图 13-6 &nbsp; 全排列剪枝示例 </p>

-观察上图发现，该剪枝操作将搜索空间大小从 $O(n^n)$ 降低至 $O(n!)$ 。
+观察图 13-6 发现，该剪枝操作将搜索空间大小从 $O(n^n)$ 降低至 $O(n!)$ 。

 ### 2. &nbsp; 代码实现

@@ -481,17 +481,17 @@ comments: true

 假设输入数组为 $[1, 1, 2]$ 。为了方便区分两个重复元素 $1$ ，我们将第二个 $1$ 记为 $\hat{1}$ 。

-如下图所示，上述方法生成的排列有一半都是重复的。
+如图 13-7 所示，上述方法生成的排列有一半都是重复的。

 ![重复排列](permutations_problem.assets/permutations_ii.png)

-<p align="center"> 图：重复排列 </p>
+<p align="center"> 图 13-7 &nbsp; 重复排列 </p>

 那么如何去除重复的排列呢？最直接地，考虑借助一个哈希表，直接对排列结果进行去重。然而这样做不够优雅，**因为生成重复排列的搜索分支是没有必要的，应当被提前识别并剪枝**，这样可以进一步提升算法效率。

 ### 1. &nbsp; 相等元素剪枝

-观察下图，在第一轮中，选择 $1$ 或选择 $\hat{1}$ 是等价的，在这两个选择之下生成的所有排列都是重复的。因此应该把 $\hat{1}$ 剪枝掉。
+观察图 13-8 ，在第一轮中，选择 $1$ 或选择 $\hat{1}$ 是等价的，在这两个选择之下生成的所有排列都是重复的。因此应该把 $\hat{1}$ 剪枝掉。

 同理，在第一轮选择 $2$ 之后，第二轮选择中的 $1$ 和 $\hat{1}$ 也会产生重复分支，因此也应将第二轮的 $\hat{1}$ 剪枝。

@@ -499,7 +499,7 @@ comments: true

 ![重复排列剪枝](permutations_problem.assets/permutations_ii_pruning.png)

-<p align="center"> 图：重复排列剪枝 </p>
+<p align="center"> 图 13-8 &nbsp; 重复排列剪枝 </p>

 ### 2. &nbsp; 代码实现

@@ -912,8 +912,8 @@ comments: true
 - **重复选择剪枝**：整个搜索过程中只有一个 `selected` 。它记录的是当前状态中包含哪些元素，作用是避免某个元素在 `state` 中重复出现。
 - **相等元素剪枝**：每轮选择（即每个开启的 `backtrack` 函数）都包含一个 `duplicated` 。它记录的是在遍历中哪些元素已被选择过，作用是保证相等元素只被选择一次。

-下图展示了两个剪枝条件的生效范围。注意，树中的每个节点代表一个选择，从根节点到叶节点的路径上的各个节点构成一个排列。
+图 13-9 展示了两个剪枝条件的生效范围。注意，树中的每个节点代表一个选择，从根节点到叶节点的路径上的各个节点构成一个排列。

 ![两种剪枝条件的作用范围](permutations_problem.assets/permutations_ii_pruning_summary.png)

-<p align="center"> 图：两种剪枝条件的作用范围 </p>
+<p align="center"> 图 13-9 &nbsp; 两种剪枝条件的作用范围 </p>
@@ -434,11 +434,11 @@ comments: true

 向以上代码输入数组 $[3, 4, 5]$ 和目标元素 $9$ ，输出结果为 $[3, 3, 3], [4, 5], [5, 4]$ 。**虽然成功找出了所有和为 $9$ 的子集，但其中存在重复的子集 $[4, 5]$ 和 $[5, 4]$** 。

-这是因为搜索过程是区分选择顺序的，然而子集不区分选择顺序。如下图所示，先选 $4$ 后选 $5$ 与先选 $5$ 后选 $4$ 是两个不同的分支，但两者对应同一个子集。
+这是因为搜索过程是区分选择顺序的，然而子集不区分选择顺序。如图 13-10 所示，先选 $4$ 后选 $5$ 与先选 $5$ 后选 $4$ 是两个不同的分支，但两者对应同一个子集。

 ![子集搜索与越界剪枝](subset_sum_problem.assets/subset_sum_i_naive.png)

-<p align="center"> 图：子集搜索与越界剪枝 </p>
+<p align="center"> 图 13-10 &nbsp; 子集搜索与越界剪枝 </p>

 为了去除重复子集，**一种直接的思路是对结果列表进行去重**。但这个方法效率很低，因为：

@@ -447,12 +447,12 @@ comments: true

 ### 2. &nbsp; 重复子集剪枝

-**我们考虑在搜索过程中通过剪枝进行去重**。观察下图，重复子集是在以不同顺序选择数组元素时产生的，具体来看：
+**我们考虑在搜索过程中通过剪枝进行去重**。观察图 13-11 ，重复子集是在以不同顺序选择数组元素时产生的，具体来看：

 1. 第一轮和第二轮分别选择 $3$ , $4$ ，会生成包含这两个元素的所有子集，记为 $[3, 4, \dots]$ 。
 2. 若第一轮选择 $4$ ，**则第二轮应该跳过 $3$** ，因为该选择产生的子集 $[4, 3, \dots]$ 和 `1.` 中生成的子集完全重复。

-如下图所示，每一层的选择都是从左到右被逐个尝试的，因此越靠右剪枝越多。
+如图 13-11 所示，每一层的选择都是从左到右被逐个尝试的，因此越靠右剪枝越多。

 1. 前两轮选择 $3$ , $5$ ，生成子集 $[3, 5, \dots]$ 。
 2. 前两轮选择 $4$ , $5$ ，生成子集 $[4, 5, \dots]$ 。
@@ -460,7 +460,7 @@ comments: true

 ![不同选择顺序导致的重复子集](subset_sum_problem.assets/subset_sum_i_pruning.png)

-<p align="center"> 图：不同选择顺序导致的重复子集 </p>
+<p align="center"> 图 13-11 &nbsp; 不同选择顺序导致的重复子集 </p>

 总结来看，给定输入数组 $[x_1, x_2, \dots, x_n]$ ，设搜索过程中的选择序列为 $[x_{i_1}, x_{i_2}, \dots , x_{i_m}]$ ，则该选择序列需要满足 $i_1 \leq i_2 \leq \dots \leq i_m$ ，**不满足该条件的选择序列都会造成重复，应当剪枝**。

@@ -912,11 +912,11 @@ comments: true
    }
    ```

-如下图所示，为将数组 $[3, 4, 5]$ 和目标元素 $9$ 输入到以上代码后的整体回溯过程。
+如图 13-12 所示，为将数组 $[3, 4, 5]$ 和目标元素 $9$ 输入到以上代码后的整体回溯过程。

 ![子集和 I 回溯过程](subset_sum_problem.assets/subset_sum_i.png)

-<p align="center"> 图：子集和 I 回溯过程 </p>
+<p align="center"> 图 13-12 &nbsp; 子集和 I 回溯过程 </p>

 ## 13.3.2 &nbsp; 考虑重复元素的情况

@@ -926,11 +926,11 @@ comments: true

 相比于上题，**本题的输入数组可能包含重复元素**，这引入了新的问题。例如，给定数组 $[4, \hat{4}, 5]$ 和目标元素 $9$ ，则现有代码的输出结果为 $[4, 5], [\hat{4}, 5]$ ，出现了重复子集。

-**造成这种重复的原因是相等元素在某轮中被多次选择**。在下图中，第一轮共有三个选择，其中两个都为 $4$ ，会产生两个重复的搜索分支，从而输出重复子集；同理，第二轮的两个 $4$ 也会产生重复子集。
+**造成这种重复的原因是相等元素在某轮中被多次选择**。在图 13-13 中，第一轮共有三个选择，其中两个都为 $4$ ，会产生两个重复的搜索分支，从而输出重复子集；同理，第二轮的两个 $4$ 也会产生重复子集。

 ![相等元素导致的重复子集](subset_sum_problem.assets/subset_sum_ii_repeat.png)

-<p align="center"> 图：相等元素导致的重复子集 </p>
+<p align="center"> 图 13-13 &nbsp; 相等元素导致的重复子集 </p>

 ### 1. &nbsp; 相等元素剪枝

@@ -1434,8 +1434,8 @@ comments: true
    }
    ```

-下图展示了数组 $[4, 4, 5]$ 和目标元素 $9$ 的回溯过程，共包含四种剪枝操作。请你将图示与代码注释相结合，理解整个搜索过程，以及每种剪枝操作是如何工作的。
+图 13-14 展示了数组 $[4, 4, 5]$ 和目标元素 $9$ 的回溯过程，共包含四种剪枝操作。请你将图示与代码注释相结合，理解整个搜索过程，以及每种剪枝操作是如何工作的。

 ![子集和 II 回溯过程](subset_sum_problem.assets/subset_sum_ii.png)

-<p align="center"> 图：子集和 II 回溯过程 </p>
+<p align="center"> 图 13-14 &nbsp; 子集和 II 回溯过程 </p>