xinyin025/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-07-09 22:16:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
This commit is contained in:
krahets
2023-08-17 05:12:05 +08:00
parent f0826da7f6
commit 97c532b228
67 changed files with 1481 additions and 1066 deletions
Download Patch File Download Diff File Expand all files Collapse all files
chapter_dynamic_programming/dp_problem_features.md
+4 -4
View File
@@ -25,7 +25,7 @@ status: new
![爬到第 3 阶的最小代价](dp_problem_features.assets/min_cost_cs_example.png)
<p align="center"> Fig. 爬到第 3 阶的最小代价 </p>
<p align="center"> 图：爬到第 3 阶的最小代价 </p>
设 $dp[i]$ 为爬到第 $i$ 阶累计付出的代价，由于第 $i$ 阶只可能从 $i - 1$ 阶或 $i - 2$ 阶走来，因此 $dp[i]$ 只可能等于 $dp[i - 1] + cost[i]$ 或 $dp[i - 2] + cost[i]$ 。为了尽可能减少代价，我们应该选择两者中较小的那一个，即：
@@ -248,7 +248,7 @@ $$
![爬楼梯最小代价的动态规划过程](dp_problem_features.assets/min_cost_cs_dp.png)
<p align="center"> Fig. 爬楼梯最小代价的动态规划过程 </p>
<p align="center"> 图：爬楼梯最小代价的动态规划过程 </p>
本题也可以进行状态压缩，将一维压缩至零维，使得空间复杂度从 $O(n)$ 降低至 $O(1)$ 。
@@ -447,7 +447,7 @@ $$
![带约束爬到第 3 阶的方案数量](dp_problem_features.assets/climbing_stairs_constraint_example.png)
<p align="center"> Fig. 带约束爬到第 3 阶的方案数量 </p>
<p align="center"> 图：带约束爬到第 3 阶的方案数量 </p>
在该问题中，如果上一轮是跳 $1$ 阶上来的，那么下一轮就必须跳 $2$ 阶。这意味着，**下一步选择不能由当前状态（当前楼梯阶数）独立决定，还和前一个状态（上轮楼梯阶数）有关**。
@@ -469,7 +469,7 @@ $$
![考虑约束下的递推关系](dp_problem_features.assets/climbing_stairs_constraint_state_transfer.png)
<p align="center"> Fig. 考虑约束下的递推关系 </p>
<p align="center"> 图：考虑约束下的递推关系 </p>
最终，返回 $dp[n, 1] + dp[n, 2]$ 即可，两者之和代表爬到第 $n$ 阶的方案总数。
chapter_dynamic_programming/dp_solution_pipeline.md
+8 -6
View File
@@ -44,7 +44,7 @@ status: new
![最小路径和示例数据](dp_solution_pipeline.assets/min_path_sum_example.png)
<p align="center"> Fig. 最小路径和示例数据 </p>
<p align="center"> 图：最小路径和示例数据 </p>
**第一步：思考每轮的决策，定义状态，从而得到 $dp$ 表**
@@ -56,7 +56,7 @@ status: new
![状态定义与 dp 表](dp_solution_pipeline.assets/min_path_sum_solution_step1.png)
<p align="center"> Fig. 状态定义与 dp 表 </p>
<p align="center"> 图：状态定义与 dp 表 </p>
!!! note
@@ -76,7 +76,7 @@ $$
![最优子结构与状态转移方程](dp_solution_pipeline.assets/min_path_sum_solution_step2.png)
<p align="center"> Fig. 最优子结构与状态转移方程 </p>
<p align="center"> 图：最优子结构与状态转移方程 </p>
!!! note
@@ -92,7 +92,7 @@ $$
![边界条件与状态转移顺序](dp_solution_pipeline.assets/min_path_sum_solution_step3.png)
<p align="center"> Fig. 边界条件与状态转移顺序 </p>
<p align="center"> 图：边界条件与状态转移顺序 </p>
!!! note
@@ -322,7 +322,7 @@ $$
![暴力搜索递归树](dp_solution_pipeline.assets/min_path_sum_dfs.png)
<p align="center"> Fig. 暴力搜索递归树 </p>
<p align="center"> 图：暴力搜索递归树 </p>
每个状态都有向下和向右两种选择，从左上角走到右下角总共需要 $m + n - 2$ 步，所以最差时间复杂度为 $O(2^{m + n})$ 。请注意，这种计算方式未考虑临近网格边界的情况，当到达网络边界时只剩下一种选择。因此实际的路径数量会少一些。
@@ -586,7 +586,7 @@ $$
![记忆化搜索递归树](dp_solution_pipeline.assets/min_path_sum_dfs_mem.png)
<p align="center"> Fig. 记忆化搜索递归树 </p>
<p align="center"> 图：记忆化搜索递归树 </p>
### 方法三：动态规划
@@ -893,6 +893,8 @@ $$
=== "<12>"
![min_path_sum_dp_step12](dp_solution_pipeline.assets/min_path_sum_dp_step12.png)
<p align="center"> 图：最小路径和的动态规划过程 </p>
### 状态压缩
由于每个格子只与其左边和上边的格子有关，因此我们可以只用一个单行数组来实现 $dp$ 表。
chapter_dynamic_programming/edit_distance_problem.md
+5 -3
View File
@@ -17,7 +17,7 @@ status: new
![编辑距离的示例数据](edit_distance_problem.assets/edit_distance_example.png)
<p align="center"> Fig. 编辑距离的示例数据 </p>
<p align="center"> 图：编辑距离的示例数据 </p>
**编辑距离问题可以很自然地用决策树模型来解释**。字符串对应树节点，一轮决策（一次编辑操作）对应树的一条边。
@@ -27,7 +27,7 @@ status: new
![基于决策树模型表示编辑距离问题](edit_distance_problem.assets/edit_distance_decision_tree.png)
<p align="center"> Fig. 基于决策树模型表示编辑距离问题 </p>
<p align="center"> 图：基于决策树模型表示编辑距离问题 </p>
**第一步：思考每轮的决策，定义状态，从而得到 $dp$ 表**
@@ -54,7 +54,7 @@ status: new
![编辑距离的状态转移](edit_distance_problem.assets/edit_distance_state_transfer.png)
<p align="center"> Fig. 编辑距离的状态转移 </p>
<p align="center"> 图：编辑距离的状态转移 </p>
根据以上分析，可得最优子结构：$dp[i, j]$ 的最少编辑步数等于 $dp[i, j-1]$ , $dp[i-1, j]$ , $dp[i-1, j-1]$ 三者中的最少编辑步数，再加上本次的编辑步数 $1$ 。对应的状态转移方程为：
@@ -411,6 +411,8 @@ $$
=== "<15>"
![edit_distance_dp_step15](edit_distance_problem.assets/edit_distance_dp_step15.png)
<p align="center"> 图：编辑距离的动态规划过程 </p>
### 状态压缩
由于 $dp[i,j]$ 是由上方 $dp[i-1, j]$ 、左方 $dp[i, j-1]$ 、左上方状态 $dp[i-1, j-1]$ 转移而来，而正序遍历会丢失左上方 $dp[i-1, j-1]$ ，倒序遍历无法提前构建 $dp[i, j-1]$ ，因此两种遍历顺序都不可取。
chapter_dynamic_programming/intro_to_dynamic_programming.md
+7 -7
View File
@@ -17,7 +17,7 @@ status: new
![爬到第 3 阶的方案数量](intro_to_dynamic_programming.assets/climbing_stairs_example.png)
<p align="center"> Fig. 爬到第 3 阶的方案数量 </p>
<p align="center"> 图：爬到第 3 阶的方案数量 </p>
本题的目标是求解方案数量，**我们可以考虑通过回溯来穷举所有可能性**。具体来说，将爬楼梯想象为一个多轮选择的过程：从地面出发，每轮选择上 $1$ 阶或 $2$ 阶，每当到达楼梯顶部时就将方案数量加 $1$ ，当越过楼梯顶部时就将其剪枝。
@@ -149,7 +149,7 @@ status: new
// 当爬到第 n 阶时，方案数量加 1
if (state === n) res.set(0, res.get(0) + 1);
// 遍历所有选择
for (choice of choices) {
for (const choice of choices) {
// 剪枝：不允许越过第 n 阶
if (state + choice > n) break;
// 尝试：做出选择，更新状态
@@ -182,7 +182,7 @@ status: new
// 当爬到第 n 阶时，方案数量加 1
if (state === n) res.set(0, res.get(0) + 1);
// 遍历所有选择
for (let choice of choices) {
for (const choice of choices) {
// 剪枝：不允许越过第 n 阶
if (state + choice > n) break;
// 尝试：做出选择，更新状态
@@ -382,7 +382,7 @@ $$
![方案数量递推关系](intro_to_dynamic_programming.assets/climbing_stairs_state_transfer.png)
<p align="center"> Fig. 方案数量递推关系 </p>
<p align="center"> 图：方案数量递推关系 </p>
我们可以根据递推公式得到暴力搜索解法：
@@ -609,7 +609,7 @@ $$
![爬楼梯对应递归树](intro_to_dynamic_programming.assets/climbing_stairs_dfs_tree.png)
<p align="center"> Fig. 爬楼梯对应递归树 </p>
<p align="center"> 图：爬楼梯对应递归树 </p>
观察上图发现，**指数阶的时间复杂度是由于「重叠子问题」导致的**。例如：$dp[9]$ 被分解为 $dp[8]$ 和 $dp[7]$ ，$dp[8]$ 被分解为 $dp[7]$ 和 $dp[6]$ ，两者都包含子问题 $dp[7]$ 。
@@ -921,7 +921,7 @@ $$
![记忆化搜索对应递归树](intro_to_dynamic_programming.assets/climbing_stairs_dfs_memo_tree.png)
<p align="center"> Fig. 记忆化搜索对应递归树 </p>
<p align="center"> 图：记忆化搜索对应递归树 </p>
## 14.1.3. &nbsp; 方法三：动态规划
@@ -1165,7 +1165,7 @@ $$
![爬楼梯的动态规划过程](intro_to_dynamic_programming.assets/climbing_stairs_dp.png)
<p align="center"> Fig. 爬楼梯的动态规划过程 </p>
<p align="center"> 图：爬楼梯的动态规划过程 </p>
## 14.1.4. &nbsp; 状态压缩
chapter_dynamic_programming/knapsack_problem.md
+7 -3
View File
@@ -17,7 +17,7 @@ status: new
![0-1 背包的示例数据](knapsack_problem.assets/knapsack_example.png)
<p align="center"> Fig. 0-1 背包的示例数据 </p>
<p align="center"> 图：0-1 背包的示例数据 </p>
我们可以将 0-1 背包问题看作是一个由 $n$ 轮决策组成的过程，每个物体都有不放入和放入两种决策，因此该问题是满足决策树模型的。
@@ -273,7 +273,7 @@ $$
![0-1 背包的暴力搜索递归树](knapsack_problem.assets/knapsack_dfs.png)
<p align="center"> Fig. 0-1 背包的暴力搜索递归树 </p>
<p align="center"> 图：0-1 背包的暴力搜索递归树 </p>
### 方法二：记忆化搜索
@@ -539,7 +539,7 @@ $$
![0-1 背包的记忆化搜索递归树](knapsack_problem.assets/knapsack_dfs_mem.png)
<p align="center"> Fig. 0-1 背包的记忆化搜索递归树 </p>
<p align="center"> 图：0-1 背包的记忆化搜索递归树 </p>
### 方法三：动态规划
@@ -822,6 +822,8 @@ $$
=== "<14>"
![knapsack_dp_step14](knapsack_problem.assets/knapsack_dp_step14.png)
<p align="center"> 图：0-1 背包的动态规划过程 </p>
### 状态压缩
由于每个状态都只与其上一行的状态有关，因此我们可以使用两个数组滚动前进，将空间复杂度从 $O(n^2)$ 将低至 $O(n)$ 。
@@ -851,6 +853,8 @@ $$
=== "<6>"
![knapsack_dp_comp_step6](knapsack_problem.assets/knapsack_dp_comp_step6.png)
<p align="center"> 图：0-1 背包的状态压缩后的动态规划过程 </p>
在代码实现中，我们仅需将数组 `dp` 的第一维 $i$ 直接删除，并且把内循环更改为倒序遍历即可。
=== "Java"
chapter_dynamic_programming/unbounded_knapsack_problem.md
+7 -3
View File
@@ -15,7 +15,7 @@ status: new
![完全背包问题的示例数据](unbounded_knapsack_problem.assets/unbounded_knapsack_example.png)
<p align="center"> Fig. 完全背包问题的示例数据 </p>
<p align="center"> 图：完全背包问题的示例数据 </p>
完全背包和 0-1 背包问题非常相似，**区别仅在于不限制物品的选择次数**。
@@ -294,6 +294,8 @@ $$
=== "<6>"
![unbounded_knapsack_dp_comp_step6](unbounded_knapsack_problem.assets/unbounded_knapsack_dp_comp_step6.png)
<p align="center"> 图：完全背包的状态压缩后的动态规划过程 </p>
代码实现比较简单，仅需将数组 `dp` 的第一维删除。
=== "Java"
@@ -537,7 +539,7 @@ $$
![零钱兑换问题的示例数据](unbounded_knapsack_problem.assets/coin_change_example.png)
<p align="center"> Fig. 零钱兑换问题的示例数据 </p>
<p align="center"> 图：零钱兑换问题的示例数据 </p>
**零钱兑换可以看作是完全背包的一种特殊情况**，两者具有以下联系与不同点：
@@ -907,6 +909,8 @@ $$
=== "<15>"
![coin_change_dp_step15](unbounded_knapsack_problem.assets/coin_change_dp_step15.png)
<p align="center"> 图：零钱兑换问题的动态规划过程 </p>
### 状态压缩
零钱兑换的状态压缩的处理方式和完全背包一致。
@@ -1182,7 +1186,7 @@ $$
![零钱兑换问题 II 的示例数据](unbounded_knapsack_problem.assets/coin_change_ii_example.png)
<p align="center"> Fig. 零钱兑换问题 II 的示例数据 </p>
<p align="center"> 图：零钱兑换问题 II 的示例数据 </p>
相比于上一题，本题目标是组合数量，因此子问题变为：**前 $i$ 种硬币能够凑出金额 $a$ 的组合数量**。而 $dp$ 表仍然是尺寸为 $(n+1) \times (amt + 1)$ 的二维矩阵。