deploy

2026-07-07 05:04:20 +00:00 · 2023-08-21 19:32:49 +08:00
parent c0f960b443
commit c359c07fe0
67 changed files with 443 additions and 442 deletions
@@ -3444,7 +3444,7 @@ dp[i] = \min(dp[i-1], dp[i-2]) + cost[i]
 <p>这便可以引出最优子结构的含义：<strong>原问题的最优解是从子问题的最优解构建得来的</strong>。</p>
 <p>本题显然具有最优子结构：我们从两个子问题最优解 <span class="arithmatex">\(dp[i-1]\)</span> , <span class="arithmatex">\(dp[i-2]\)</span> 中挑选出较优的那一个，并用它构建出原问题 <span class="arithmatex">\(dp[i]\)</span> 的最优解。</p>
 <p>那么，上节的爬楼梯题目有没有最优子结构呢？它的目标是求解方案数量，看似是一个计数问题，但如果换一种问法：“求解最大方案数量”。我们意外地发现，<strong>虽然题目修改前后是等价的，但最优子结构浮现出来了</strong>：第 <span class="arithmatex">\(n\)</span> 阶最大方案数量等于第 <span class="arithmatex">\(n-1\)</span> 阶和第 <span class="arithmatex">\(n-2\)</span> 阶最大方案数量之和。所以说，最优子结构的解释方式比较灵活，在不同问题中会有不同的含义。</p>
-<p>根据状态转移方程，以及初始状态 <span class="arithmatex">\(dp[1] = cost[1]\)</span> , <span class="arithmatex">\(dp[2] = cost[2]\)</span> ，可以得出动态规划代码。</p>
+<p>根据状态转移方程，以及初始状态 <span class="arithmatex">\(dp[1] = cost[1]\)</span> , <span class="arithmatex">\(dp[2] = cost[2]\)</span> ，我们就可以得到动态规划代码。</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">
@@ -3630,6 +3630,7 @@ dp[i] = \min(dp[i-1], dp[i-2]) + cost[i]
 </div>
 </div>
 </div>
+<p>下图展示了以上代码的动态规划过程。</p>
 <p><img alt="爬楼梯最小代价的动态规划过程" src="../dp_problem_features.assets/min_cost_cs_dp.png" /></p>
 <p align="center"> 图：爬楼梯最小代价的动态规划过程 </p>

@@ -3801,7 +3802,7 @@ dp[i] = \min(dp[i-1], dp[i-2]) + cost[i]
 <p class="admonition-title">带约束爬楼梯</p>
 <p>给定一个共有 <span class="arithmatex">\(n\)</span> 阶的楼梯，你每步可以上 <span class="arithmatex">\(1\)</span> 阶或者 <span class="arithmatex">\(2\)</span> 阶，<strong>但不能连续两轮跳 <span class="arithmatex">\(1\)</span> 阶</strong>，请问有多少种方案可以爬到楼顶。</p>
 </div>
-<p>例如，爬上第 <span class="arithmatex">\(3\)</span> 阶仅剩 <span class="arithmatex">\(2\)</span> 种可行方案，其中连续三次跳 <span class="arithmatex">\(1\)</span> 阶的方案不满足约束条件，因此被舍弃。</p>
+<p>例如下图，爬上第 <span class="arithmatex">\(3\)</span> 阶仅剩 <span class="arithmatex">\(2\)</span> 种可行方案，其中连续三次跳 <span class="arithmatex">\(1\)</span> 阶的方案不满足约束条件，因此被舍弃。</p>
 <p><img alt="带约束爬到第 3 阶的方案数量" src="../dp_problem_features.assets/climbing_stairs_constraint_example.png" /></p>
 <p align="center"> 图：带约束爬到第 3 阶的方案数量 </p>

@@ -3812,7 +3813,7 @@ dp[i] = \min(dp[i-1], dp[i-2]) + cost[i]
 <li>当 <span class="arithmatex">\(j\)</span> 等于 <span class="arithmatex">\(1\)</span> ，即上一轮跳了 <span class="arithmatex">\(1\)</span> 阶时，这一轮只能选择跳 <span class="arithmatex">\(2\)</span> 阶。</li>
 <li>当 <span class="arithmatex">\(j\)</span> 等于 <span class="arithmatex">\(2\)</span> ，即上一轮跳了 <span class="arithmatex">\(2\)</span> 阶时，这一轮可选择跳 <span class="arithmatex">\(1\)</span> 阶或跳 <span class="arithmatex">\(2\)</span> 阶。</li>
 </ul>
-<p>在该定义下，<span class="arithmatex">\(dp[i, j]\)</span> 表示状态 <span class="arithmatex">\([i, j]\)</span> 对应的方案数。在该定义下的状态转移方程为：</p>
+<p>如下图所示，在该定义下，<span class="arithmatex">\(dp[i, j]\)</span> 表示状态 <span class="arithmatex">\([i, j]\)</span> 对应的方案数。此时状态转移方程为：</p>
 <div class="arithmatex">\[
 \begin{cases}
 dp[i, 1] = dp[i-1, 2] \\
@@ -3515,14 +3515,14 @@
 <p class="admonition-title">Question</p>
 <p>给定一个 <span class="arithmatex">\(n \times m\)</span> 的二维网格 <code>grid</code> ，网格中的每个单元格包含一个非负整数，表示该单元格的代价。机器人以左上角单元格为起始点，每次只能向下或者向右移动一步，直至到达右下角单元格。请返回从左上角到右下角的最小路径和。</p>
 </div>
-<p>例如以下示例数据，给定网格的最小路径和为 <span class="arithmatex">\(13\)</span> 。</p>
+<p>下图展示了一个例子，给定网格的最小路径和为 <span class="arithmatex">\(13\)</span> 。</p>
 <p><img alt="最小路径和示例数据" src="../dp_solution_pipeline.assets/min_path_sum_example.png" /></p>
 <p align="center"> 图：最小路径和示例数据 </p>

 <p><strong>第一步：思考每轮的决策，定义状态，从而得到 <span class="arithmatex">\(dp\)</span> 表</strong></p>
 <p>本题的每一轮的决策就是从当前格子向下或向右一步。设当前格子的行列索引为 <span class="arithmatex">\([i, j]\)</span> ，则向下或向右走一步后，索引变为 <span class="arithmatex">\([i+1, j]\)</span> 或 <span class="arithmatex">\([i, j+1]\)</span> 。因此，状态应包含行索引和列索引两个变量，记为 <span class="arithmatex">\([i, j]\)</span> 。</p>
 <p>状态 <span class="arithmatex">\([i, j]\)</span> 对应的子问题为：从起始点 <span class="arithmatex">\([0, 0]\)</span> 走到 <span class="arithmatex">\([i, j]\)</span> 的最小路径和，解记为 <span class="arithmatex">\(dp[i, j]\)</span> 。</p>
-<p>至此，我们就得到了一个二维 <span class="arithmatex">\(dp\)</span> 矩阵，其尺寸与输入网格 <span class="arithmatex">\(grid\)</span> 相同。</p>
+<p>至此，我们就得到了下图所示的二维 <span class="arithmatex">\(dp\)</span> 矩阵，其尺寸与输入网格 <span class="arithmatex">\(grid\)</span> 相同。</p>
 <p><img alt="状态定义与 dp 表" src="../dp_solution_pipeline.assets/min_path_sum_solution_step1.png" /></p>
 <p align="center"> 图：状态定义与 dp 表 </p>

@@ -3533,7 +3533,7 @@
 </div>
 <p><strong>第二步：找出最优子结构，进而推导出状态转移方程</strong></p>
 <p>对于状态 <span class="arithmatex">\([i, j]\)</span> ，它只能从上边格子 <span class="arithmatex">\([i-1, j]\)</span> 和左边格子 <span class="arithmatex">\([i, j-1]\)</span> 转移而来。因此最优子结构为：到达 <span class="arithmatex">\([i, j]\)</span> 的最小路径和由 <span class="arithmatex">\([i, j-1]\)</span> 的最小路径和与 <span class="arithmatex">\([i-1, j]\)</span> 的最小路径和，这两者较小的那一个决定。</p>
-<p>根据以上分析，可推出以下状态转移方程：</p>
+<p>根据以上分析，可推出下图所示的状态转移方程：</p>
 <div class="arithmatex">\[
 dp[i, j] = \min(dp[i-1, j], dp[i, j-1]) + grid[i, j]
 \]</div>
@@ -3547,7 +3547,7 @@ dp[i, j] = \min(dp[i-1, j], dp[i, j-1]) + grid[i, j]
 </div>
 <p><strong>第三步：确定边界条件和状态转移顺序</strong></p>
 <p>在本题中，处在首行的状态只能向右转移，首列状态只能向下转移，因此首行 <span class="arithmatex">\(i = 0\)</span> 和首列 <span class="arithmatex">\(j = 0\)</span> 是边界条件。</p>
-<p>每个格子是由其左方格子和上方格子转移而来，因此我们使用采用循环来遍历矩阵，外循环遍历各行、内循环遍历各列。</p>
+<p>如下图所示，由于每个格子是由其左方格子和上方格子转移而来，因此我们使用采用循环来遍历矩阵，外循环遍历各行、内循环遍历各列。</p>
 <p><img alt="边界条件与状态转移顺序" src="../dp_solution_pipeline.assets/min_path_sum_solution_step3.png" /></p>
 <p align="center"> 图：边界条件与状态转移顺序 </p>

@@ -3990,7 +3990,7 @@ dp[i, j] = \min(dp[i-1, j], dp[i, j-1]) + grid[i, j]
 </div>
 </div>
 </div>
-<p>引入记忆化后，所有子问题的解只需计算一次，因此时间复杂度取决于状态总数，即网格尺寸 <span class="arithmatex">\(O(nm)\)</span> 。</p>
+<p>如下图所示，在引入记忆化后，所有子问题的解只需计算一次，因此时间复杂度取决于状态总数，即网格尺寸 <span class="arithmatex">\(O(nm)\)</span> 。</p>
 <p><img alt="记忆化搜索递归树" src="../dp_solution_pipeline.assets/min_path_sum_dfs_mem.png" /></p>
 <p align="center"> 图：记忆化搜索递归树 </p>

@@ -3462,7 +3462,7 @@
 <p>状态 <span class="arithmatex">\([i, j]\)</span> 对应的子问题：<strong>将 <span class="arithmatex">\(s\)</span> 的前 <span class="arithmatex">\(i\)</span> 个字符更改为 <span class="arithmatex">\(t\)</span> 的前 <span class="arithmatex">\(j\)</span> 个字符所需的最少编辑步数</strong>。</p>
 <p>至此，得到一个尺寸为 <span class="arithmatex">\((i+1) \times (j+1)\)</span> 的二维 <span class="arithmatex">\(dp\)</span> 表。</p>
 <p><strong>第二步：找出最优子结构，进而推导出状态转移方程</strong></p>
-<p>考虑子问题 <span class="arithmatex">\(dp[i, j]\)</span> ，其对应的两个字符串的尾部字符为 <span class="arithmatex">\(s[i-1]\)</span> 和 <span class="arithmatex">\(t[j-1]\)</span> ，可根据不同编辑操作分为三种情况：</p>
+<p>考虑子问题 <span class="arithmatex">\(dp[i, j]\)</span> ，其对应的两个字符串的尾部字符为 <span class="arithmatex">\(s[i-1]\)</span> 和 <span class="arithmatex">\(t[j-1]\)</span> ，可根据不同编辑操作分为下图所示的三种情况：</p>
 <ol>
 <li>在 <span class="arithmatex">\(s[i-1]\)</span> 之后添加 <span class="arithmatex">\(t[j-1]\)</span> ，则剩余子问题 <span class="arithmatex">\(dp[i, j-1]\)</span> 。</li>
 <li>删除 <span class="arithmatex">\(s[i-1]\)</span> ，则剩余子问题 <span class="arithmatex">\(dp[i-1, j]\)</span> 。</li>
@@ -3789,7 +3789,7 @@ dp[i-1] , dp[i-2] , \dots , dp[2] , dp[1]
 <div class="arithmatex">\[
 dp[i] = dp[i-1] + dp[i-2]
 \]</div>
-<p>这意味着在爬楼梯问题中，各个子问题之间存在递推关系，<strong>原问题的解可以由子问题的解构建得来</strong>。</p>
+<p>这意味着在爬楼梯问题中，各个子问题之间存在递推关系，<strong>原问题的解可以由子问题的解构建得来</strong>。下图展示了该递推关系。</p>
 <p><img alt="方案数量递推关系" src="../intro_to_dynamic_programming.assets/climbing_stairs_state_transfer.png" /></p>
 <p align="center"> 图：方案数量递推关系 </p>

@@ -4492,6 +4492,10 @@ dp[i] = dp[i-1] + dp[i-2]
 </div>
 </div>
 </div>
+<p>下图模拟了以上代码的执行过程。</p>
+<p><img alt="爬楼梯的动态规划过程" src="../intro_to_dynamic_programming.assets/climbing_stairs_dp.png" /></p>
+<p align="center"> 图：爬楼梯的动态规划过程 </p>
+
 <p>与回溯算法一样，动态规划也使用“状态”概念来表示问题求解的某个特定阶段，每个状态都对应一个子问题以及相应的局部最优解。例如，爬楼梯问题的状态定义为当前所在楼梯阶数 <span class="arithmatex">\(i\)</span> 。</p>
 <p>总结以上，动态规划的常用术语包括：</p>
 <ul>
@@ -4499,9 +4503,6 @@ dp[i] = dp[i-1] + dp[i-2]
 <li>将最小子问题对应的状态（即第 <span class="arithmatex">\(1\)</span> , <span class="arithmatex">\(2\)</span> 阶楼梯）称为「初始状态」。</li>
 <li>将递推公式 <span class="arithmatex">\(dp[i] = dp[i-1] + dp[i-2]\)</span> 称为「状态转移方程」。</li>
 </ul>
-<p><img alt="爬楼梯的动态规划过程" src="../intro_to_dynamic_programming.assets/climbing_stairs_dp.png" /></p>
-<p align="center"> 图：爬楼梯的动态规划过程 </p>
-
 <h2 id="1414">14.1.4 &nbsp; 状态压缩<a class="headerlink" href="#1414" title="Permanent link">&para;</a></h2>
 <p>细心的你可能发现，<strong>由于 <span class="arithmatex">\(dp[i]\)</span> 只与 <span class="arithmatex">\(dp[i-1]\)</span> 和 <span class="arithmatex">\(dp[i-2]\)</span> 有关，因此我们无须使用一个数组 <code>dp</code> 来存储所有子问题的解</strong>，而只需两个变量滚动前进即可。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="5:12"><input checked="checked" id="__tabbed_5_1" name="__tabbed_5" type="radio" /><input id="__tabbed_5_2" name="__tabbed_5" type="radio" /><input id="__tabbed_5_3" name="__tabbed_5" type="radio" /><input id="__tabbed_5_4" name="__tabbed_5" type="radio" /><input id="__tabbed_5_5" name="__tabbed_5" type="radio" /><input id="__tabbed_5_6" name="__tabbed_5" type="radio" /><input id="__tabbed_5_7" name="__tabbed_5" type="radio" /><input id="__tabbed_5_8" name="__tabbed_5" type="radio" /><input id="__tabbed_5_9" name="__tabbed_5" type="radio" /><input id="__tabbed_5_10" name="__tabbed_5" type="radio" /><input id="__tabbed_5_11" name="__tabbed_5" type="radio" /><input id="__tabbed_5_12" name="__tabbed_5" type="radio" /><div class="tabbed-labels"><label for="__tabbed_5_1">Java</label><label for="__tabbed_5_2">C++</label><label for="__tabbed_5_3">Python</label><label for="__tabbed_5_4">Go</label><label for="__tabbed_5_5">JS</label><label for="__tabbed_5_6">TS</label><label for="__tabbed_5_7">C</label><label for="__tabbed_5_8">C#</label><label for="__tabbed_5_9">Swift</label><label for="__tabbed_5_10">Zig</label><label for="__tabbed_5_11">Dart</label><label for="__tabbed_5_12">Rust</label></div>
@@ -3454,7 +3454,7 @@
 <p class="admonition-title">Question</p>
 <p>给定 <span class="arithmatex">\(n\)</span> 个物品，第 <span class="arithmatex">\(i\)</span> 个物品的重量为 <span class="arithmatex">\(wgt[i-1]\)</span> 、价值为 <span class="arithmatex">\(val[i-1]\)</span> ，和一个容量为 <span class="arithmatex">\(cap\)</span> 的背包。每个物品只能选择一次，问在不超过背包容量下能放入物品的最大价值。</p>
 </div>
-<p>请注意，物品编号 <span class="arithmatex">\(i\)</span> 从 <span class="arithmatex">\(1\)</span> 开始计数，数组索引从 <span class="arithmatex">\(0\)</span> 开始计数，因此物品 <span class="arithmatex">\(i\)</span> 对应重量 <span class="arithmatex">\(wgt[i-1]\)</span> 和价值 <span class="arithmatex">\(val[i-1]\)</span> 。</p>
+<p>观察下图，由于物品编号 <span class="arithmatex">\(i\)</span> 从 <span class="arithmatex">\(1\)</span> 开始计数，数组索引从 <span class="arithmatex">\(0\)</span> 开始计数，因此物品 <span class="arithmatex">\(i\)</span> 对应重量 <span class="arithmatex">\(wgt[i-1]\)</span> 和价值 <span class="arithmatex">\(val[i-1]\)</span> 。</p>
 <p><img alt="0-1 背包的示例数据" src="../knapsack_problem.assets/knapsack_example.png" /></p>
 <p align="center"> 图：0-1 背包的示例数据 </p>

@@ -3915,6 +3915,7 @@ dp[i, c] = \max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1])
 </div>
 </div>
 </div>
+<p>下图展示了在记忆化递归中被剪掉的搜索分支。</p>
 <p><img alt="0-1 背包的记忆化搜索递归树" src="../knapsack_problem.assets/knapsack_dfs_mem.png" /></p>
 <p align="center"> 图：0-1 背包的记忆化搜索递归树 </p>

@@ -4189,7 +4190,7 @@ dp[i, c] = \max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1])
 <li>如果采取正序遍历，那么遍历到 <span class="arithmatex">\(dp[i, j]\)</span> 时，左上方 <span class="arithmatex">\(dp[i-1, 1]\)</span> ~ <span class="arithmatex">\(dp[i-1, j-1]\)</span> 值可能已经被覆盖，此时就无法得到正确的状态转移结果。</li>
 <li>如果采取倒序遍历，则不会发生覆盖问题，状态转移可以正确进行。</li>
 </ul>
-<p>以下动画展示了在单个数组下从第 <span class="arithmatex">\(i = 1\)</span> 行转换至第 <span class="arithmatex">\(i = 2\)</span> 行的过程。请思考正序遍历和倒序遍历的区别。</p>
+<p>下图展示了在单个数组下从第 <span class="arithmatex">\(i = 1\)</span> 行转换至第 <span class="arithmatex">\(i = 2\)</span> 行的过程。请思考正序遍历和倒序遍历的区别。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="5:6"><input checked="checked" id="__tabbed_5_1" name="__tabbed_5" type="radio" /><input id="__tabbed_5_2" name="__tabbed_5" type="radio" /><input id="__tabbed_5_3" name="__tabbed_5" type="radio" /><input id="__tabbed_5_4" name="__tabbed_5" type="radio" /><input id="__tabbed_5_5" name="__tabbed_5" type="radio" /><input id="__tabbed_5_6" name="__tabbed_5" type="radio" /><div class="tabbed-labels"><label for="__tabbed_5_1">&lt;1&gt;</label><label for="__tabbed_5_2">&lt;2&gt;</label><label for="__tabbed_5_3">&lt;3&gt;</label><label for="__tabbed_5_4">&lt;4&gt;</label><label for="__tabbed_5_5">&lt;5&gt;</label><label for="__tabbed_5_6">&lt;6&gt;</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -3837,7 +3837,7 @@ dp[i, c] = \max(dp[i-1, c], dp[i, c - wgt[i-1]] + val[i-1])
 </div>
 <h3 id="3">3. &nbsp; 状态压缩<a class="headerlink" href="#3" title="Permanent link">&para;</a></h3>
 <p>由于当前状态是从左边和上边的状态转移而来，<strong>因此状态压缩后应该对 <span class="arithmatex">\(dp\)</span> 表中的每一行采取正序遍历</strong>。</p>
-<p>这个遍历顺序与 0-1 背包正好相反。请通过以下动画来理解两者的区别。</p>
+<p>这个遍历顺序与 0-1 背包正好相反。请借助下图来理解两者的区别。</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="2:6"><input checked="checked" id="__tabbed_2_1" name="__tabbed_2" type="radio" /><input id="__tabbed_2_2" name="__tabbed_2" type="radio" /><input id="__tabbed_2_3" name="__tabbed_2" type="radio" /><input id="__tabbed_2_4" name="__tabbed_2" type="radio" /><input id="__tabbed_2_5" name="__tabbed_2" type="radio" /><input id="__tabbed_2_6" name="__tabbed_2" type="radio" /><div class="tabbed-labels"><label for="__tabbed_2_1">&lt;1&gt;</label><label for="__tabbed_2_2">&lt;2&gt;</label><label for="__tabbed_2_3">&lt;3&gt;</label><label for="__tabbed_2_4">&lt;4&gt;</label><label for="__tabbed_2_5">&lt;5&gt;</label><label for="__tabbed_2_6">&lt;6&gt;</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">