deploy

2026-07-13 23:56:07 +00:00 · 2023-08-22 13:50:24 +08:00
parent 77b90cd19b
commit b70b7c9e75
67 changed files with 580 additions and 580 deletions
@@ -3474,7 +3474,7 @@
 <p class="admonition-title">例题一</p>
 <p>给定一个二叉树，搜索并记录所有值为 <span class="arithmatex">\(7\)</span> 的节点，请返回节点列表。</p>
 </div>
-<p>对于此题，我们前序遍历这颗树，并判断当前节点的值是否为 <span class="arithmatex">\(7\)</span> ，若是则将该节点的值加入到结果列表 <code>res</code> 之中。相关过程实现如下图和以下代码所示。</p>
+<p>对于此题，我们前序遍历这颗树，并判断当前节点的值是否为 <span class="arithmatex">\(7\)</span> ，若是则将该节点的值加入到结果列表 <code>res</code> 之中。相关过程实现如图 13-1 和以下代码所示。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="1:12"><input checked="checked" id="__tabbed_1_1" name="__tabbed_1" type="radio" /><input id="__tabbed_1_2" name="__tabbed_1" type="radio" /><input id="__tabbed_1_3" name="__tabbed_1" type="radio" /><input id="__tabbed_1_4" name="__tabbed_1" type="radio" /><input id="__tabbed_1_5" name="__tabbed_1" type="radio" /><input id="__tabbed_1_6" name="__tabbed_1" type="radio" /><input id="__tabbed_1_7" name="__tabbed_1" type="radio" /><input id="__tabbed_1_8" name="__tabbed_1" type="radio" /><input id="__tabbed_1_9" name="__tabbed_1" type="radio" /><input id="__tabbed_1_10" name="__tabbed_1" type="radio" /><input id="__tabbed_1_11" name="__tabbed_1" type="radio" /><input id="__tabbed_1_12" name="__tabbed_1" type="radio" /><div class="tabbed-labels"><label for="__tabbed_1_1">Java</label><label for="__tabbed_1_2">C++</label><label for="__tabbed_1_3">Python</label><label for="__tabbed_1_4">Go</label><label for="__tabbed_1_5">JS</label><label for="__tabbed_1_6">TS</label><label for="__tabbed_1_7">C</label><label for="__tabbed_1_8">C#</label><label for="__tabbed_1_9">Swift</label><label for="__tabbed_1_10">Zig</label><label for="__tabbed_1_11">Dart</label><label for="__tabbed_1_12">Rust</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -3637,7 +3637,7 @@
 </div>
 </div>
 <p><img alt="在前序遍历中搜索节点" src="../backtracking_algorithm.assets/preorder_find_nodes.png" /></p>
-<p align="center"> 图：在前序遍历中搜索节点 </p>
+<p align="center"> 图 13-1 &nbsp; 在前序遍历中搜索节点 </p>

 <h2 id="1311">13.1.1 &nbsp; 尝试与回退<a class="headerlink" href="#1311" title="Permanent link">&para;</a></h2>
 <p><strong>之所以称之为回溯算法，是因为该算法在搜索解空间时会采用“尝试”与“回退”的策略</strong>。当算法在搜索过程中遇到某个状态无法继续前进或无法得到满足条件的解时，它会撤销上一步的选择，退回到之前的状态，并尝试其他可能的选择。</p>
@@ -3880,7 +3880,7 @@
 </div>
 </div>
 <p>在每次“尝试”中，我们通过将当前节点添加进 <code>path</code> 来记录路径；而在“回退”前，我们需要将该节点从 <code>path</code> 中弹出，<strong>以恢复本次尝试之前的状态</strong>。</p>
-<p>观察下图所示的过程，<strong>我们可以将尝试和回退理解为“前进”与“撤销”</strong>，两个操作是互为逆向的。</p>
+<p>观察图 13-2 所示的过程，<strong>我们可以将尝试和回退理解为“前进”与“撤销”</strong>，两个操作是互为逆向的。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="3:11"><input checked="checked" id="__tabbed_3_1" name="__tabbed_3" type="radio" /><input id="__tabbed_3_2" name="__tabbed_3" type="radio" /><input id="__tabbed_3_3" name="__tabbed_3" type="radio" /><input id="__tabbed_3_4" name="__tabbed_3" type="radio" /><input id="__tabbed_3_5" name="__tabbed_3" type="radio" /><input id="__tabbed_3_6" name="__tabbed_3" type="radio" /><input id="__tabbed_3_7" name="__tabbed_3" type="radio" /><input id="__tabbed_3_8" name="__tabbed_3" type="radio" /><input id="__tabbed_3_9" name="__tabbed_3" type="radio" /><input id="__tabbed_3_10" name="__tabbed_3" type="radio" /><input id="__tabbed_3_11" name="__tabbed_3" type="radio" /><div class="tabbed-labels"><label for="__tabbed_3_1">&lt;1&gt;</label><label for="__tabbed_3_2">&lt;2&gt;</label><label for="__tabbed_3_3">&lt;3&gt;</label><label for="__tabbed_3_4">&lt;4&gt;</label><label for="__tabbed_3_5">&lt;5&gt;</label><label for="__tabbed_3_6">&lt;6&gt;</label><label for="__tabbed_3_7">&lt;7&gt;</label><label for="__tabbed_3_8">&lt;8&gt;</label><label for="__tabbed_3_9">&lt;9&gt;</label><label for="__tabbed_3_10">&lt;10&gt;</label><label for="__tabbed_3_11">&lt;11&gt;</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -3918,7 +3918,7 @@
 </div>
 </div>
 </div>
-<p align="center"> 图：尝试与回退 </p>
+<p align="center"> 图 13-2 &nbsp; 尝试与回退 </p>

 <h2 id="1312">13.1.2 &nbsp; 剪枝<a class="headerlink" href="#1312" title="Permanent link">&para;</a></h2>
 <p>复杂的回溯问题通常包含一个或多个约束条件，<strong>约束条件通常可用于“剪枝”</strong>。</p>
@@ -4189,9 +4189,9 @@
 </div>
 </div>
 </div>
-<p>剪枝是一个非常形象的名词。如下图所示，在搜索过程中，<strong>我们“剪掉”了不满足约束条件的搜索分支</strong>，避免许多无意义的尝试，从而提高了搜索效率。</p>
+<p>剪枝是一个非常形象的名词。如图 13-3 所示，在搜索过程中，<strong>我们“剪掉”了不满足约束条件的搜索分支</strong>，避免许多无意义的尝试，从而提高了搜索效率。</p>
 <p><img alt="根据约束条件剪枝" src="../backtracking_algorithm.assets/preorder_find_constrained_paths.png" /></p>
-<p align="center"> 图：根据约束条件剪枝 </p>
+<p align="center"> 图 13-3 &nbsp; 根据约束条件剪枝 </p>

 <h2 id="1313">13.1.3 &nbsp; 框架代码<a class="headerlink" href="#1313" title="Permanent link">&para;</a></h2>
 <p>接下来，我们尝试将回溯的“尝试、回退、剪枝”的主体框架提炼出来，提升代码的通用性。</p>
@@ -5003,9 +5003,9 @@
 </div>
 </div>
 </div>
-<p>根据题意，我们在找到值为 7 的节点后应该继续搜索，<strong>因此需要将记录解之后的 <code>return</code> 语句删除</strong>。下图对比了保留或删除 <code>return</code> 语句的搜索过程。</p>
+<p>根据题意，我们在找到值为 7 的节点后应该继续搜索，<strong>因此需要将记录解之后的 <code>return</code> 语句删除</strong>。图 13-4 对比了保留或删除 <code>return</code> 语句的搜索过程。</p>
 <p><img alt="保留与删除 return 的搜索过程对比" src="../backtracking_algorithm.assets/backtrack_remove_return_or_not.png" /></p>
-<p align="center"> 图：保留与删除 return 的搜索过程对比 </p>
+<p align="center"> 图 13-4 &nbsp; 保留与删除 return 的搜索过程对比 </p>

 <p>相比基于前序遍历的代码实现，基于回溯算法框架的代码实现虽然显得啰嗦，但通用性更好。实际上，<strong>许多回溯问题都可以在该框架下解决</strong>。我们只需根据具体问题来定义 <code>state</code> 和 <code>choices</code> ，并实现框架中的各个方法即可。</p>
 <h2 id="1314">13.1.4 &nbsp; 常用术语<a class="headerlink" href="#1314" title="Permanent link">&para;</a></h2>
@@ -3430,29 +3430,29 @@
 <p class="admonition-title">Question</p>
 <p>根据国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。给定 <span class="arithmatex">\(n\)</span> 个皇后和一个 <span class="arithmatex">\(n \times n\)</span> 大小的棋盘，寻找使得所有皇后之间无法相互攻击的摆放方案。</p>
 </div>
-<p>如下图所示，当 <span class="arithmatex">\(n = 4\)</span> 时，共可以找到两个解。从回溯算法的角度看，<span class="arithmatex">\(n \times n\)</span> 大小的棋盘共有 <span class="arithmatex">\(n^2\)</span> 个格子，给出了所有的选择 <code>choices</code> 。在逐个放置皇后的过程中，棋盘状态在不断地变化，每个时刻的棋盘就是状态 <code>state</code> 。</p>
+<p>如图 13-15 所示，当 <span class="arithmatex">\(n = 4\)</span> 时，共可以找到两个解。从回溯算法的角度看，<span class="arithmatex">\(n \times n\)</span> 大小的棋盘共有 <span class="arithmatex">\(n^2\)</span> 个格子，给出了所有的选择 <code>choices</code> 。在逐个放置皇后的过程中，棋盘状态在不断地变化，每个时刻的棋盘就是状态 <code>state</code> 。</p>
 <p><img alt="4 皇后问题的解" src="../n_queens_problem.assets/solution_4_queens.png" /></p>
-<p align="center"> 图：4 皇后问题的解 </p>
+<p align="center"> 图 13-15 &nbsp; 4 皇后问题的解 </p>

-<p>下图展示了本题的三个约束条件：<strong>多个皇后不能在同一行、同一列、同一对角线</strong>。值得注意的是，对角线分为主对角线 <code>\</code> 和次对角线 <code>/</code> 两种。</p>
+<p>图 13-16 展示了本题的三个约束条件：<strong>多个皇后不能在同一行、同一列、同一对角线</strong>。值得注意的是，对角线分为主对角线 <code>\</code> 和次对角线 <code>/</code> 两种。</p>
 <p><img alt="n 皇后问题的约束条件" src="../n_queens_problem.assets/n_queens_constraints.png" /></p>
-<p align="center"> 图：n 皇后问题的约束条件 </p>
+<p align="center"> 图 13-16 &nbsp; n 皇后问题的约束条件 </p>

 <h3 id="1">1. &nbsp; 逐行放置策略<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
 <p>皇后的数量和棋盘的行数都为 <span class="arithmatex">\(n\)</span> ，因此我们容易得到一个推论：<strong>棋盘每行都允许且只允许放置一个皇后</strong>。</p>
 <p>也就是说，我们可以采取逐行放置策略：从第一行开始，在每行放置一个皇后，直至最后一行结束。</p>
-<p>如下图所示，为 <span class="arithmatex">\(4\)</span> 皇后问题的逐行放置过程。受画幅限制，下图仅展开了第一行的其中一个搜索分支，并且将不满足列约束和对角线约束的方案都进行了剪枝。</p>
+<p>如图 13-17 所示，为 <span class="arithmatex">\(4\)</span> 皇后问题的逐行放置过程。受画幅限制，图 13-17 仅展开了第一行的其中一个搜索分支，并且将不满足列约束和对角线约束的方案都进行了剪枝。</p>
 <p><img alt="逐行放置策略" src="../n_queens_problem.assets/n_queens_placing.png" /></p>
-<p align="center"> 图：逐行放置策略 </p>
+<p align="center"> 图 13-17 &nbsp; 逐行放置策略 </p>

 <p>本质上看，<strong>逐行放置策略起到了剪枝的作用</strong>，它避免了同一行出现多个皇后的所有搜索分支。</p>
 <h3 id="2">2. &nbsp; 列与对角线剪枝<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
 <p>为了满足列约束，我们可以利用一个长度为 <span class="arithmatex">\(n\)</span> 的布尔型数组 <code>cols</code> 记录每一列是否有皇后。在每次决定放置前，我们通过 <code>cols</code> 将已有皇后的列进行剪枝，并在回溯中动态更新 <code>cols</code> 的状态。</p>
 <p>那么，如何处理对角线约束呢？设棋盘中某个格子的行列索引为 <span class="arithmatex">\((row, col)\)</span> ，选定矩阵中的某条主对角线，我们发现该对角线上所有格子的行索引减列索引都相等，<strong>即对角线上所有格子的 <span class="arithmatex">\(row - col\)</span> 为恒定值</strong>。</p>
-<p>也就是说，如果两个格子满足 <span class="arithmatex">\(row_1 - col_1 = row_2 - col_2\)</span> ，则它们一定处在同一条主对角线上。利用该规律，我们可以借助下图所示的数组 <code>diag1</code> ，记录每条主对角线上是否有皇后。</p>
+<p>也就是说，如果两个格子满足 <span class="arithmatex">\(row_1 - col_1 = row_2 - col_2\)</span> ，则它们一定处在同一条主对角线上。利用该规律，我们可以借助图 13-18 所示的数组 <code>diag1</code> ，记录每条主对角线上是否有皇后。</p>
 <p>同理，<strong>次对角线上的所有格子的 <span class="arithmatex">\(row + col\)</span> 是恒定值</strong>。我们同样也可以借助数组 <code>diag2</code> 来处理次对角线约束。</p>
 <p><img alt="处理列约束和对角线约束" src="../n_queens_problem.assets/n_queens_cols_diagonals.png" /></p>
-<p align="center"> 图：处理列约束和对角线约束 </p>
+<p align="center"> 图 13-18 &nbsp; 处理列约束和对角线约束 </p>

 <h3 id="3">3. &nbsp; 代码实现<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
 <p>请注意，<span class="arithmatex">\(n\)</span> 维方阵中 <span class="arithmatex">\(row - col\)</span> 的范围是 <span class="arithmatex">\([-n + 1, n - 1]\)</span> ，<span class="arithmatex">\(row + col\)</span> 的范围是 <span class="arithmatex">\([0, 2n - 2]\)</span> ，所以主对角线和次对角线的数量都为 <span class="arithmatex">\(2n - 1\)</span> ，即数组 <code>diag1</code> 和 <code>diag2</code> 的长度都为 <span class="arithmatex">\(2n - 1\)</span> 。</p>
@@ -3507,8 +3507,8 @@

 <h1 id="132">13.2 &nbsp; 全排列问题<a class="headerlink" href="#132" title="Permanent link">&para;</a></h1>
 <p>全排列问题是回溯算法的一个典型应用。它的定义是在给定一个集合（如一个数组或字符串）的情况下，找出这个集合中元素的所有可能的排列。</p>
-<p>下表列举了几个示例数据，包括输入数组和对应的所有排列。</p>
-<p align="center"> 表：数组与链表的效率对比 </p>
+<p>表 13-1 列举了几个示例数据，包括输入数组和对应的所有排列。</p>
+<p align="center"> 表 13-1 &nbsp; 数组与链表的效率对比 </p>

 <div class="center-table">
 <table>
@@ -3541,9 +3541,9 @@
 </div>
 <p>从回溯算法的角度看，<strong>我们可以把生成排列的过程想象成一系列选择的结果</strong>。假设输入数组为 <span class="arithmatex">\([1, 2, 3]\)</span> ，如果我们先选择 <span class="arithmatex">\(1\)</span> 、再选择 <span class="arithmatex">\(3\)</span> 、最后选择 <span class="arithmatex">\(2\)</span> ，则获得排列 <span class="arithmatex">\([1, 3, 2]\)</span> 。回退表示撤销一个选择，之后继续尝试其他选择。</p>
 <p>从回溯代码的角度看，候选集合 <code>choices</code> 是输入数组中的所有元素，状态 <code>state</code> 是直至目前已被选择的元素。请注意，每个元素只允许被选择一次，<strong>因此 <code>state</code> 中的所有元素都应该是唯一的</strong>。</p>
-<p>如下图所示，我们可以将搜索过程展开成一个递归树，树中的每个节点代表当前状态 <code>state</code> 。从根节点开始，经过三轮选择后到达叶节点，每个叶节点都对应一个排列。</p>
+<p>如图 13-5 所示，我们可以将搜索过程展开成一个递归树，树中的每个节点代表当前状态 <code>state</code> 。从根节点开始，经过三轮选择后到达叶节点，每个叶节点都对应一个排列。</p>
 <p><img alt="全排列的递归树" src="../permutations_problem.assets/permutations_i.png" /></p>
-<p align="center"> 图：全排列的递归树 </p>
+<p align="center"> 图 13-5 &nbsp; 全排列的递归树 </p>

 <h3 id="1">1. &nbsp; 重复选择剪枝<a class="headerlink" href="#1" title="Permanent link">&para;</a></h3>
 <p>为了实现每个元素只被选择一次，我们考虑引入一个布尔型数组 <code>selected</code> ，其中 <code>selected[i]</code> 表示 <code>choices[i]</code> 是否已被选择。剪枝的实现原理为：</p>
@@ -3551,11 +3551,11 @@
 <li>在做出选择 <code>choice[i]</code> 后，我们就将 <code>selected[i]</code> 赋值为 <span class="arithmatex">\(\text{True}\)</span> ，代表它已被选择。</li>
 <li>遍历选择列表 <code>choices</code> 时，跳过所有已被选择过的节点，即剪枝。</li>
 </ul>
-<p>如下图所示，假设我们第一轮选择 1 ，第二轮选择 3 ，第三轮选择 2 ，则需要在第二轮剪掉元素 1 的分支，在第三轮剪掉元素 1, 3 的分支。</p>
+<p>如图 13-6 所示，假设我们第一轮选择 1 ，第二轮选择 3 ，第三轮选择 2 ，则需要在第二轮剪掉元素 1 的分支，在第三轮剪掉元素 1, 3 的分支。</p>
 <p><img alt="全排列剪枝示例" src="../permutations_problem.assets/permutations_i_pruning.png" /></p>
-<p align="center"> 图：全排列剪枝示例 </p>
+<p align="center"> 图 13-6 &nbsp; 全排列剪枝示例 </p>

-<p>观察上图发现，该剪枝操作将搜索空间大小从 <span class="arithmatex">\(O(n^n)\)</span> 降低至 <span class="arithmatex">\(O(n!)\)</span> 。</p>
+<p>观察图 13-6 发现，该剪枝操作将搜索空间大小从 <span class="arithmatex">\(O(n^n)\)</span> 降低至 <span class="arithmatex">\(O(n!)\)</span> 。</p>
 <h3 id="2">2. &nbsp; 代码实现<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
 <p>想清楚以上信息之后，我们就可以在框架代码中做“完形填空”了。为了缩短代码行数，我们不单独实现框架代码中的各个函数，而是将他们展开在 <code>backtrack()</code> 函数中。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="1:12"><input checked="checked" id="__tabbed_1_1" name="__tabbed_1" type="radio" /><input id="__tabbed_1_2" name="__tabbed_1" type="radio" /><input id="__tabbed_1_3" name="__tabbed_1" type="radio" /><input id="__tabbed_1_4" name="__tabbed_1" type="radio" /><input id="__tabbed_1_5" name="__tabbed_1" type="radio" /><input id="__tabbed_1_6" name="__tabbed_1" type="radio" /><input id="__tabbed_1_7" name="__tabbed_1" type="radio" /><input id="__tabbed_1_8" name="__tabbed_1" type="radio" /><input id="__tabbed_1_9" name="__tabbed_1" type="radio" /><input id="__tabbed_1_10" name="__tabbed_1" type="radio" /><input id="__tabbed_1_11" name="__tabbed_1" type="radio" /><input id="__tabbed_1_12" name="__tabbed_1" type="radio" /><div class="tabbed-labels"><label for="__tabbed_1_1">Java</label><label for="__tabbed_1_2">C++</label><label for="__tabbed_1_3">Python</label><label for="__tabbed_1_4">Go</label><label for="__tabbed_1_5">JS</label><label for="__tabbed_1_6">TS</label><label for="__tabbed_1_7">C</label><label for="__tabbed_1_8">C#</label><label for="__tabbed_1_9">Swift</label><label for="__tabbed_1_10">Zig</label><label for="__tabbed_1_11">Dart</label><label for="__tabbed_1_12">Rust</label></div>
@@ -3962,17 +3962,17 @@
 <p>输入一个整数数组，<strong>数组中可能包含重复元素</strong>，返回所有不重复的排列。</p>
 </div>
 <p>假设输入数组为 <span class="arithmatex">\([1, 1, 2]\)</span> 。为了方便区分两个重复元素 <span class="arithmatex">\(1\)</span> ，我们将第二个 <span class="arithmatex">\(1\)</span> 记为 <span class="arithmatex">\(\hat{1}\)</span> 。</p>
-<p>如下图所示，上述方法生成的排列有一半都是重复的。</p>
+<p>如图 13-7 所示，上述方法生成的排列有一半都是重复的。</p>
 <p><img alt="重复排列" src="../permutations_problem.assets/permutations_ii.png" /></p>
-<p align="center"> 图：重复排列 </p>
+<p align="center"> 图 13-7 &nbsp; 重复排列 </p>

 <p>那么如何去除重复的排列呢？最直接地，考虑借助一个哈希表，直接对排列结果进行去重。然而这样做不够优雅，<strong>因为生成重复排列的搜索分支是没有必要的，应当被提前识别并剪枝</strong>，这样可以进一步提升算法效率。</p>
 <h3 id="1_1">1. &nbsp; 相等元素剪枝<a class="headerlink" href="#1_1" title="Permanent link">&para;</a></h3>
-<p>观察下图，在第一轮中，选择 <span class="arithmatex">\(1\)</span> 或选择 <span class="arithmatex">\(\hat{1}\)</span> 是等价的，在这两个选择之下生成的所有排列都是重复的。因此应该把 <span class="arithmatex">\(\hat{1}\)</span> 剪枝掉。</p>
+<p>观察图 13-8 ，在第一轮中，选择 <span class="arithmatex">\(1\)</span> 或选择 <span class="arithmatex">\(\hat{1}\)</span> 是等价的，在这两个选择之下生成的所有排列都是重复的。因此应该把 <span class="arithmatex">\(\hat{1}\)</span> 剪枝掉。</p>
 <p>同理，在第一轮选择 <span class="arithmatex">\(2\)</span> 之后，第二轮选择中的 <span class="arithmatex">\(1\)</span> 和 <span class="arithmatex">\(\hat{1}\)</span> 也会产生重复分支，因此也应将第二轮的 <span class="arithmatex">\(\hat{1}\)</span> 剪枝。</p>
 <p>本质上看，<strong>我们的目标是在某一轮选择中，保证多个相等的元素仅被选择一次</strong>。</p>
 <p><img alt="重复排列剪枝" src="../permutations_problem.assets/permutations_ii_pruning.png" /></p>
-<p align="center"> 图：重复排列剪枝 </p>
+<p align="center"> 图 13-8 &nbsp; 重复排列剪枝 </p>

 <h3 id="2_1">2. &nbsp; 代码实现<a class="headerlink" href="#2_1" title="Permanent link">&para;</a></h3>
 <p>在上一题的代码的基础上，我们考虑在每一轮选择中开启一个哈希表 <code>duplicated</code> ，用于记录该轮中已经尝试过的元素，并将重复元素剪枝。</p>
@@ -4360,9 +4360,9 @@
 <li><strong>重复选择剪枝</strong>：整个搜索过程中只有一个 <code>selected</code> 。它记录的是当前状态中包含哪些元素，作用是避免某个元素在 <code>state</code> 中重复出现。</li>
 <li><strong>相等元素剪枝</strong>：每轮选择（即每个开启的 <code>backtrack</code> 函数）都包含一个 <code>duplicated</code> 。它记录的是在遍历中哪些元素已被选择过，作用是保证相等元素只被选择一次。</li>
 </ul>
-<p>下图展示了两个剪枝条件的生效范围。注意，树中的每个节点代表一个选择，从根节点到叶节点的路径上的各个节点构成一个排列。</p>
+<p>图 13-9 展示了两个剪枝条件的生效范围。注意，树中的每个节点代表一个选择，从根节点到叶节点的路径上的各个节点构成一个排列。</p>
 <p><img alt="两种剪枝条件的作用范围" src="../permutations_problem.assets/permutations_ii_pruning_summary.png" /></p>
-<p align="center"> 图：两种剪枝条件的作用范围 </p>
+<p align="center"> 图 13-9 &nbsp; 两种剪枝条件的作用范围 </p>



@@ -3911,9 +3911,9 @@
 </div>
 </div>
 <p>向以上代码输入数组 <span class="arithmatex">\([3, 4, 5]\)</span> 和目标元素 <span class="arithmatex">\(9\)</span> ，输出结果为 <span class="arithmatex">\([3, 3, 3], [4, 5], [5, 4]\)</span> 。<strong>虽然成功找出了所有和为 <span class="arithmatex">\(9\)</span> 的子集，但其中存在重复的子集 <span class="arithmatex">\([4, 5]\)</span> 和 <span class="arithmatex">\([5, 4]\)</span></strong> 。</p>
-<p>这是因为搜索过程是区分选择顺序的，然而子集不区分选择顺序。如下图所示，先选 <span class="arithmatex">\(4\)</span> 后选 <span class="arithmatex">\(5\)</span> 与先选 <span class="arithmatex">\(5\)</span> 后选 <span class="arithmatex">\(4\)</span> 是两个不同的分支，但两者对应同一个子集。</p>
+<p>这是因为搜索过程是区分选择顺序的，然而子集不区分选择顺序。如图 13-10 所示，先选 <span class="arithmatex">\(4\)</span> 后选 <span class="arithmatex">\(5\)</span> 与先选 <span class="arithmatex">\(5\)</span> 后选 <span class="arithmatex">\(4\)</span> 是两个不同的分支，但两者对应同一个子集。</p>
 <p><img alt="子集搜索与越界剪枝" src="../subset_sum_problem.assets/subset_sum_i_naive.png" /></p>
-<p align="center"> 图：子集搜索与越界剪枝 </p>
+<p align="center"> 图 13-10 &nbsp; 子集搜索与越界剪枝 </p>

 <p>为了去除重复子集，<strong>一种直接的思路是对结果列表进行去重</strong>。但这个方法效率很低，因为：</p>
 <ul>
@@ -3921,19 +3921,19 @@
 <li>比较子集（数组）的异同非常耗时，需要先排序数组，再比较数组中每个元素的异同。</li>
 </ul>
 <h3 id="2">2. &nbsp; 重复子集剪枝<a class="headerlink" href="#2" title="Permanent link">&para;</a></h3>
-<p><strong>我们考虑在搜索过程中通过剪枝进行去重</strong>。观察下图，重复子集是在以不同顺序选择数组元素时产生的，具体来看：</p>
+<p><strong>我们考虑在搜索过程中通过剪枝进行去重</strong>。观察图 13-11 ，重复子集是在以不同顺序选择数组元素时产生的，具体来看：</p>
 <ol>
 <li>第一轮和第二轮分别选择 <span class="arithmatex">\(3\)</span> , <span class="arithmatex">\(4\)</span> ，会生成包含这两个元素的所有子集，记为 <span class="arithmatex">\([3, 4, \dots]\)</span> 。</li>
 <li>若第一轮选择 <span class="arithmatex">\(4\)</span> ，<strong>则第二轮应该跳过 <span class="arithmatex">\(3\)</span></strong> ，因为该选择产生的子集 <span class="arithmatex">\([4, 3, \dots]\)</span> 和 <code>1.</code> 中生成的子集完全重复。</li>
 </ol>
-<p>如下图所示，每一层的选择都是从左到右被逐个尝试的，因此越靠右剪枝越多。</p>
+<p>如图 13-11 所示，每一层的选择都是从左到右被逐个尝试的，因此越靠右剪枝越多。</p>
 <ol>
 <li>前两轮选择 <span class="arithmatex">\(3\)</span> , <span class="arithmatex">\(5\)</span> ，生成子集 <span class="arithmatex">\([3, 5, \dots]\)</span> 。</li>
 <li>前两轮选择 <span class="arithmatex">\(4\)</span> , <span class="arithmatex">\(5\)</span> ，生成子集 <span class="arithmatex">\([4, 5, \dots]\)</span> 。</li>
 <li>若第一轮选择 <span class="arithmatex">\(5\)</span> ，<strong>则第二轮应该跳过 <span class="arithmatex">\(3\)</span> 和 <span class="arithmatex">\(4\)</span></strong> ，因为子集 <span class="arithmatex">\([5, 3, \dots]\)</span> 和子集 <span class="arithmatex">\([5, 4, \dots]\)</span> 和 <code>1.</code> , <code>2.</code> 中描述的子集完全重复。</li>
 </ol>
 <p><img alt="不同选择顺序导致的重复子集" src="../subset_sum_problem.assets/subset_sum_i_pruning.png" /></p>
-<p align="center"> 图：不同选择顺序导致的重复子集 </p>
+<p align="center"> 图 13-11 &nbsp; 不同选择顺序导致的重复子集 </p>

 <p>总结来看，给定输入数组 <span class="arithmatex">\([x_1, x_2, \dots, x_n]\)</span> ，设搜索过程中的选择序列为 <span class="arithmatex">\([x_{i_1}, x_{i_2}, \dots , x_{i_m}]\)</span> ，则该选择序列需要满足 <span class="arithmatex">\(i_1 \leq i_2 \leq \dots \leq i_m\)</span> ，<strong>不满足该条件的选择序列都会造成重复，应当剪枝</strong>。</p>
 <h3 id="3">3. &nbsp; 代码实现<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
@@ -4362,9 +4362,9 @@
 </div>
 </div>
 </div>
-<p>如下图所示，为将数组 <span class="arithmatex">\([3, 4, 5]\)</span> 和目标元素 <span class="arithmatex">\(9\)</span> 输入到以上代码后的整体回溯过程。</p>
+<p>如图 13-12 所示，为将数组 <span class="arithmatex">\([3, 4, 5]\)</span> 和目标元素 <span class="arithmatex">\(9\)</span> 输入到以上代码后的整体回溯过程。</p>
 <p><img alt="子集和 I 回溯过程" src="../subset_sum_problem.assets/subset_sum_i.png" /></p>
-<p align="center"> 图：子集和 I 回溯过程 </p>
+<p align="center"> 图 13-12 &nbsp; 子集和 I 回溯过程 </p>

 <h2 id="1332">13.3.2 &nbsp; 考虑重复元素的情况<a class="headerlink" href="#1332" title="Permanent link">&para;</a></h2>
 <div class="admonition question">
@@ -4372,9 +4372,9 @@
 <p>给定一个正整数数组 <code>nums</code> 和一个目标正整数 <code>target</code> ，请找出所有可能的组合，使得组合中的元素和等于 <code>target</code> 。<strong>给定数组可能包含重复元素，每个元素只可被选择一次</strong>。请以列表形式返回这些组合，列表中不应包含重复组合。</p>
 </div>
 <p>相比于上题，<strong>本题的输入数组可能包含重复元素</strong>，这引入了新的问题。例如，给定数组 <span class="arithmatex">\([4, \hat{4}, 5]\)</span> 和目标元素 <span class="arithmatex">\(9\)</span> ，则现有代码的输出结果为 <span class="arithmatex">\([4, 5], [\hat{4}, 5]\)</span> ，出现了重复子集。</p>
-<p><strong>造成这种重复的原因是相等元素在某轮中被多次选择</strong>。在下图中，第一轮共有三个选择，其中两个都为 <span class="arithmatex">\(4\)</span> ，会产生两个重复的搜索分支，从而输出重复子集；同理，第二轮的两个 <span class="arithmatex">\(4\)</span> 也会产生重复子集。</p>
+<p><strong>造成这种重复的原因是相等元素在某轮中被多次选择</strong>。在图 13-13 中，第一轮共有三个选择，其中两个都为 <span class="arithmatex">\(4\)</span> ，会产生两个重复的搜索分支，从而输出重复子集；同理，第二轮的两个 <span class="arithmatex">\(4\)</span> 也会产生重复子集。</p>
 <p><img alt="相等元素导致的重复子集" src="../subset_sum_problem.assets/subset_sum_ii_repeat.png" /></p>
-<p align="center"> 图：相等元素导致的重复子集 </p>
+<p align="center"> 图 13-13 &nbsp; 相等元素导致的重复子集 </p>

 <h3 id="1_1">1. &nbsp; 相等元素剪枝<a class="headerlink" href="#1_1" title="Permanent link">&para;</a></h3>
 <p>为解决此问题，<strong>我们需要限制相等元素在每一轮中只被选择一次</strong>。实现方式比较巧妙：由于数组是已排序的，因此相等元素都是相邻的。这意味着在某轮选择中，若当前元素与其左边元素相等，则说明它已经被选择过，因此直接跳过当前元素。</p>
@@ -4854,9 +4854,9 @@
 </div>
 </div>
 </div>
-<p>下图展示了数组 <span class="arithmatex">\([4, 4, 5]\)</span> 和目标元素 <span class="arithmatex">\(9\)</span> 的回溯过程，共包含四种剪枝操作。请你将图示与代码注释相结合，理解整个搜索过程，以及每种剪枝操作是如何工作的。</p>
+<p>图 13-14 展示了数组 <span class="arithmatex">\([4, 4, 5]\)</span> 和目标元素 <span class="arithmatex">\(9\)</span> 的回溯过程，共包含四种剪枝操作。请你将图示与代码注释相结合，理解整个搜索过程，以及每种剪枝操作是如何工作的。</p>
 <p><img alt="子集和 II 回溯过程" src="../subset_sum_problem.assets/subset_sum_ii.png" /></p>
-<p align="center"> 图：子集和 II 回溯过程 </p>
+<p align="center"> 图 13-14 &nbsp; 子集和 II 回溯过程 </p>