diff --git a/codes/cpp/chapter_dynamic_programming/climbing_stairs_constraint_dp.cpp b/codes/cpp/chapter_dynamic_programming/climbing_stairs_constraint_dp.cpp index 3b47667d8..ca3210261 100644 --- a/codes/cpp/chapter_dynamic_programming/climbing_stairs_constraint_dp.cpp +++ b/codes/cpp/chapter_dynamic_programming/climbing_stairs_constraint_dp.cpp @@ -11,7 +11,7 @@ int climbingStairsConstraintDP(int n) { if (n == 1 || n == 2) { return n; } - // 初始化 dp 列表，用于存储子问题的解 + // 初始化 dp 表，用于存储子问题的解 vector> dp(n + 1, vector(3, 0)); // 初始状态：预设最小子问题的解 dp[1][1] = 1; diff --git a/codes/cpp/chapter_dynamic_programming/climbing_stairs_dp.cpp b/codes/cpp/chapter_dynamic_programming/climbing_stairs_dp.cpp index daa2f5b40..144986ba5 100644 --- a/codes/cpp/chapter_dynamic_programming/climbing_stairs_dp.cpp +++ b/codes/cpp/chapter_dynamic_programming/climbing_stairs_dp.cpp @@ -10,7 +10,7 @@ int climbingStairsDP(int n) { if (n == 1 || n == 2) return n; - // 初始化 dp 列表，用于存储子问题的解 + // 初始化 dp 表，用于存储子问题的解 vector dp(n + 1); // 初始状态：预设最小子问题的解 dp[1] = 1; diff --git a/codes/cpp/chapter_dynamic_programming/min_cost_climbing_stairs_dp.cpp b/codes/cpp/chapter_dynamic_programming/min_cost_climbing_stairs_dp.cpp index f24a7626a..d4a0d917b 100644 --- a/codes/cpp/chapter_dynamic_programming/min_cost_climbing_stairs_dp.cpp +++ b/codes/cpp/chapter_dynamic_programming/min_cost_climbing_stairs_dp.cpp @@ -11,7 +11,7 @@ int minCostClimbingStairsDP(vector &cost) { int n = cost.size() - 1; if (n == 1 || n == 2) return cost[n]; - // 初始化 dp 列表，用于存储子问题的解 + // 初始化 dp 表，用于存储子问题的解 vector dp(n + 1); // 初始状态：预设最小子问题的解 dp[1] = cost[1]; diff --git a/codes/csharp/chapter_dynamic_programming/climbing_stairs_constraint_dp.cs b/codes/csharp/chapter_dynamic_programming/climbing_stairs_constraint_dp.cs index 2e6242c05..099efc106 100644 --- a/codes/csharp/chapter_dynamic_programming/climbing_stairs_constraint_dp.cs +++ b/codes/csharp/chapter_dynamic_programming/climbing_stairs_constraint_dp.cs @@ -12,7 +12,7 @@ public class climbing_stairs_constraint_dp { if (n == 1 || n == 2) { return n; } - // 初始化 dp 列表，用于存储子问题的解 + // 初始化 dp 表，用于存储子问题的解 int[,] dp = new int[n + 1, 3]; // 初始状态：预设最小子问题的解 dp[1, 1] = 1; diff --git a/codes/csharp/chapter_dynamic_programming/climbing_stairs_dp.cs b/codes/csharp/chapter_dynamic_programming/climbing_stairs_dp.cs index 1e7347e1c..3f2b0121e 100644 --- a/codes/csharp/chapter_dynamic_programming/climbing_stairs_dp.cs +++ b/codes/csharp/chapter_dynamic_programming/climbing_stairs_dp.cs @@ -11,7 +11,7 @@ public class climbing_stairs_dp { public int climbingStairsDP(int n) { if (n == 1 || n == 2) return n; - // 初始化 dp 列表，用于存储子问题的解 + // 初始化 dp 表，用于存储子问题的解 int[] dp = new int[n + 1]; // 初始状态：预设最小子问题的解 dp[1] = 1; diff --git a/codes/csharp/chapter_dynamic_programming/knapsack.cs b/codes/csharp/chapter_dynamic_programming/knapsack.cs index 08ffe5470..1e46f4d1b 100644 --- a/codes/csharp/chapter_dynamic_programming/knapsack.cs +++ b/codes/csharp/chapter_dynamic_programming/knapsack.cs @@ -49,7 +49,7 @@ public class knapsack { /* 0-1 背包：动态规划 */ public int knapsack_dp(int[] weight, int[] val, int cap) { int n = weight.Length; - // 初始化 dp 列表 + // 初始化 dp 表 int[,] dp = new int[n + 1, cap + 1]; // 状态转移 for (int i = 1; i <= n; i++) { @@ -69,7 +69,7 @@ public class knapsack { /* 0-1 背包：状态压缩后的动态规划 */ public int knapsack_dp_comp(int[] weight, int[] val, int cap) { int n = weight.Length; - // 初始化 dp 列表 + // 初始化 dp 表 int[] dp = new int[cap + 1]; // 状态转移 for (int i = 1; i <= n; i++) { diff --git a/codes/csharp/chapter_dynamic_programming/min_cost_climbing_stairs_dp.cs b/codes/csharp/chapter_dynamic_programming/min_cost_climbing_stairs_dp.cs index d45cc4bc8..d7b2b4ade 100644 --- a/codes/csharp/chapter_dynamic_programming/min_cost_climbing_stairs_dp.cs +++ b/codes/csharp/chapter_dynamic_programming/min_cost_climbing_stairs_dp.cs @@ -12,7 +12,7 @@ public class min_cost_climbing_stairs_dp { int n = cost.Length - 1; if (n == 1 || n == 2) return cost[n]; - // 初始化 dp 列表，用于存储子问题的解 + // 初始化 dp 表，用于存储子问题的解 int[] dp = new int[n + 1]; // 初始状态：预设最小子问题的解 dp[1] = cost[1]; diff --git a/codes/java/chapter_dynamic_programming/climbing_stairs_constraint_dp.java b/codes/java/chapter_dynamic_programming/climbing_stairs_constraint_dp.java index dafd51a04..eac9166bf 100644 --- a/codes/java/chapter_dynamic_programming/climbing_stairs_constraint_dp.java +++ b/codes/java/chapter_dynamic_programming/climbing_stairs_constraint_dp.java @@ -12,7 +12,7 @@ public class climbing_stairs_constraint_dp { if (n == 1 || n == 2) { return n; } - // 初始化 dp 列表，用于存储子问题的解 + // 初始化 dp 表，用于存储子问题的解 int[][] dp = new int[n + 1][3]; // 初始状态：预设最小子问题的解 dp[1][1] = 1; diff --git a/codes/java/chapter_dynamic_programming/climbing_stairs_dp.java b/codes/java/chapter_dynamic_programming/climbing_stairs_dp.java index 7249755a9..3cd9393ad 100644 --- a/codes/java/chapter_dynamic_programming/climbing_stairs_dp.java +++ b/codes/java/chapter_dynamic_programming/climbing_stairs_dp.java @@ -11,7 +11,7 @@ public class climbing_stairs_dp { public static int climbingStairsDP(int n) { if (n == 1 || n == 2) return n; - // 初始化 dp 列表，用于存储子问题的解 + // 初始化 dp 表，用于存储子问题的解 int[] dp = new int[n + 1]; // 初始状态：预设最小子问题的解 dp[1] = 1; diff --git a/codes/java/chapter_dynamic_programming/min_cost_climbing_stairs_dp.java b/codes/java/chapter_dynamic_programming/min_cost_climbing_stairs_dp.java index ec6297e9f..95c7fd0d5 100644 --- a/codes/java/chapter_dynamic_programming/min_cost_climbing_stairs_dp.java +++ b/codes/java/chapter_dynamic_programming/min_cost_climbing_stairs_dp.java @@ -14,7 +14,7 @@ public class min_cost_climbing_stairs_dp { int n = cost.length - 1; if (n == 1 || n == 2) return cost[n]; - // 初始化 dp 列表，用于存储子问题的解 + // 初始化 dp 表，用于存储子问题的解 int[] dp = new int[n + 1]; // 初始状态：预设最小子问题的解 dp[1] = cost[1]; diff --git a/codes/python/chapter_dynamic_programming/climbing_stairs_constraint_dp.py b/codes/python/chapter_dynamic_programming/climbing_stairs_constraint_dp.py index acbbfae61..261ec230e 100644 --- a/codes/python/chapter_dynamic_programming/climbing_stairs_constraint_dp.py +++ b/codes/python/chapter_dynamic_programming/climbing_stairs_constraint_dp.py @@ -9,7 +9,7 @@ def climbing_stairs_constraint_dp(n: int) -> int: """带约束爬楼梯：动态规划""" if n == 1 or n == 2: return n - # 初始化 dp 列表，用于存储子问题的解 + # 初始化 dp 表，用于存储子问题的解 dp = [[0] * 3 for _ in range(n + 1)] # 初始状态：预设最小子问题的解 dp[1][1], dp[1][2] = 1, 0 diff --git a/codes/python/chapter_dynamic_programming/climbing_stairs_dp.py b/codes/python/chapter_dynamic_programming/climbing_stairs_dp.py index feb799f72..2c322691e 100644 --- a/codes/python/chapter_dynamic_programming/climbing_stairs_dp.py +++ b/codes/python/chapter_dynamic_programming/climbing_stairs_dp.py @@ -9,7 +9,7 @@ def climbing_stairs_dp(n: int) -> int: """爬楼梯：动态规划""" if n == 1 or n == 2: return n - # 初始化 dp 列表，用于存储子问题的解 + # 初始化 dp 表，用于存储子问题的解 dp = [0] * (n + 1) # 初始状态：预设最小子问题的解 dp[1], dp[2] = 1, 2 diff --git a/codes/python/chapter_dynamic_programming/knapsack.py b/codes/python/chapter_dynamic_programming/knapsack.py index 9f8d3cff4..e776bc2a7 100644 --- a/codes/python/chapter_dynamic_programming/knapsack.py +++ b/codes/python/chapter_dynamic_programming/knapsack.py @@ -42,7 +42,7 @@ def knapsack_dfs_mem(wgt, val, mem, i, c): def knapsack_dp(wgt, val, cap): """0-1 背包：动态规划""" n = len(wgt) - # 初始化 dp 列表 + # 初始化 dp 表 dp = [[0] * (cap + 1) for _ in range(n + 1)] # 状态转移 for i in range(1, n + 1): @@ -59,7 +59,7 @@ def knapsack_dp(wgt, val, cap): def knapsack_dp_comp(wgt, val, cap): """0-1 背包：状态压缩后的动态规划""" n = len(wgt) - # 初始化 dp 列表 + # 初始化 dp 表 dp = [0] * (cap + 1) # 状态转移 for i in range(1, n + 1): diff --git a/codes/python/chapter_dynamic_programming/min_cost_climbing_stairs_dp.py b/codes/python/chapter_dynamic_programming/min_cost_climbing_stairs_dp.py index 020259bb4..dc3ebd596 100644 --- a/codes/python/chapter_dynamic_programming/min_cost_climbing_stairs_dp.py +++ b/codes/python/chapter_dynamic_programming/min_cost_climbing_stairs_dp.py @@ -10,7 +10,7 @@ def min_cost_climbing_stairs_dp(cost: list[int]) -> int: n = len(cost) - 1 if n == 1 or n == 2: return cost[n] - # 初始化 dp 列表，用于存储子问题的解 + # 初始化 dp 表，用于存储子问题的解 dp = [0] * (n + 1) # 初始状态：预设最小子问题的解 dp[1], dp[2] = cost[1], cost[2] diff --git a/docs/chapter_dynamic_programming/intro_to_dynamic_programming.md b/docs/chapter_dynamic_programming/intro_to_dynamic_programming.md index eb32cf2d1..1f4556c95 100644 --- a/docs/chapter_dynamic_programming/intro_to_dynamic_programming.md +++ b/docs/chapter_dynamic_programming/intro_to_dynamic_programming.md @@ -122,9 +122,9 @@ $$ 也就是说，在爬楼梯问题中，**各个子问题之间不是相互独立的，原问题的解可以由子问题的解构成**。 -我们可以基于此递推公式写出暴力搜索代码：以 $dp[n]$ 为起始点，**从顶至底地将一个较大问题拆解为两个较小问题的和**，直至到达最小子问题 $dp[1]$ 和 $dp[2]$ 时返回。其中，最小子问题的解是已知的，即爬到第 $1$ , $2$ 阶分别有 $1$ , $2$ 种方案。 +我们可以基于此递推公式写出暴力搜索代码：以 $dp[n]$ 为起始点，**从顶至底地将一个较大问题拆解为两个较小问题的和**，直至到达最小子问题 $dp[1]$ 和 $dp[2]$ 时返回。其中，最小子问题的解 $dp[1] = 1$ , $dp[2] = 2$ 是已知的，代表爬到第 $1$ , $2$ 阶分别有 $1$ , $2$ 种方案。 -观察以下代码，它与回溯解法都属于深度优先搜索，但比回溯算法更加简洁。 +观察以下代码，它和标准回溯代码都属于深度优先搜索，但更加简洁。 === "Java" @@ -214,7 +214,7 @@ $$ [class]{}-[func]{climbingStairsDFS} ``` -下图展示了该方法形成的递归树。对于问题 $dp[n]$ ，递归树的深度为 $n$ ，时间复杂度为 $O(2^n)$ 。指数阶的运行时间增长地非常快，如果我们输入一个比较大的 $n$ ，则会陷入漫长的等待之中。 +下图展示了暴力搜索形成的递归树。对于问题 $dp[n]$ ，其递归树的深度为 $n$ ，时间复杂度为 $O(2^n)$ 。指数阶的运行时间增长地非常快，如果我们输入一个比较大的 $n$ ，则会陷入漫长的等待之中。 ![爬楼梯对应递归树](intro_to_dynamic_programming.assets/climbing_stairs_dfs_tree.png) @@ -393,15 +393,15 @@ $$ [class]{}-[func]{climbingStairsDP} ``` -与回溯算法一样，动态规划也使用“状态”概念来表示问题求解的某个特定阶段，每个状态都对应一个子问题以及相应的局部最优解。例如对于爬楼梯问题，状态定义为当前所在楼梯阶数。**动态规划的常用术语包括**： +与回溯算法一样，动态规划也使用“状态”概念来表示问题求解的某个特定阶段，每个状态都对应一个子问题以及相应的局部最优解。例如对于爬楼梯问题，状态定义为当前所在楼梯阶数 $i$ 。**动态规划的常用术语包括**： -- 将 $dp$ 数组称为「状态列表」，$dp[i]$ 代表第 $i$ 个状态的解； -- 将最简单子问题对应的状态（即第 $1$ , $2$ 阶楼梯）称为「初始状态」； +- 将数组 `dp` 称为「$dp$ 表」，$dp[i]$ 表示状态 $i$ 对应子问题的解； +- 将最小子问题对应的状态（即第 $1$ , $2$ 阶楼梯）称为「初始状态」； - 将递推公式 $dp[i] = dp[i-1] + dp[i-2]$ 称为「状态转移方程」； ![爬楼梯的动态规划过程](intro_to_dynamic_programming.assets/climbing_stairs_dp.png) -细心的你可能发现，**由于 $dp[i]$ 只与 $dp[i-1]$ 和 $dp[i-2]$ 有关，因此我们无需使用一个数组 `dp` 来存储所有状态**，而只需两个变量滚动前进即可。如以下代码所示，由于省去了数组 `dp` 占用的空间，因此空间复杂度从 $O(n)$ 降低至 $O(1)$ 。 +细心的你可能发现，**由于 $dp[i]$ 只与 $dp[i-1]$ 和 $dp[i-2]$ 有关，因此我们无需使用一个数组 `dp` 来存储所有子问题的解**，而只需两个变量滚动前进即可。如以下代码所示，由于省去了数组 `dp` 占用的空间，因此空间复杂度从 $O(n)$ 降低至 $O(1)$ 。 === "Java" diff --git a/docs/chapter_dynamic_programming/knapsack_problem.md b/docs/chapter_dynamic_programming/knapsack_problem.md index c8151dbfe..8cf075936 100644 --- a/docs/chapter_dynamic_programming/knapsack_problem.md +++ b/docs/chapter_dynamic_programming/knapsack_problem.md @@ -1,44 +1,57 @@ # 0-1 背包问题 -背包问题是学习动态规划的一个非常好的入门题目，其涉及到“选择与不选择”和“限制条件下的最优化”等问题，是动态规划中最常见的问题形式。 +背包问题是一个非常好的动态规划入门题目，是动态规划中最常见的问题形式。其具有很多变种，例如 0-1 背包问题、完全背包问题、多重背包问题等。 -背包问题具有很多变种，例如 0-1 背包问题、完全背包问题、多重背包问题等。在本节中，我们先来学习最简单的 0-1 背包问题。 +在本节中，我们先来学习基础的的 0-1 背包问题。 !!! question 给定 $n$ 个物品，第 $i$ 个物品的重量为 $wgt[i-1]$ 、价值为 $val[i-1]$ ，现在有个容量为 $cap$ 的背包，请求解在不超过背包容量下背包中物品的最大价值。 - 请注意，物品编号 $i$ 从 $1$ 开始计数，但数组索引从 $0$ 开始计数，因此物品 $i$ 对应重量 $wgt[i-1]$ 和价值 $val[i-1]$ 。 + 请注意，物品编号 $i$ 从 $1$ 开始计数，数组索引从 $0$ 开始计数，因此物品 $i$ 对应重量 $wgt[i-1]$ 和价值 $val[i-1]$ 。 下图给出了一个 0-1 背包的示例数据，背包内的最大价值为 $220$ 。 ![0-1 背包的示例数据](knapsack_problem.assets/knapsack_example.png) -接下来，我们仍然先从回溯角度入手，先给出暴力搜索解法；再引入记忆化处理，得到记忆化搜索和动态规划解法。 +我们可以将 0-1 背包问题看作是一个由 $n$ 轮决策组成的过程，每个物体都有不放入和放入两种决策，因此该问题是满足决策树模型的。此外，该问题的目标是求解“在限定背包容量下的最大价值”，因此较大概率是个动态规划问题。我们接下来尝试求解它。 -## 方法一：暴力搜索 +**第一步：思考每轮的决策，定义状态，从而得到 $dp$ 表** + +在 0-1 背包问题中，不放入背包，背包容量不变；放入背包，背包容量减小。由此可得状态定义：当前物品编号 $i$ 和剩余背包容量 $c$ ，记为 $[i, c]$ 。 + +状态 $[i, c]$ 对应的子问题为：**前 $i$ 个物品在剩余容量为 $c$ 的背包中的最大价值**，记为 $dp[i, c]$ 。 -0-1 背包问题是一道典型的“选或不选”的问题，0 代表不选、1 代表选。我们可以将 0-1 背包看作是一个由 $n$ 轮决策组成的搜索过程，对于每个物体都有不放入和放入两种决策。不放入背包，背包容量不变；放入背包，背包容量减小。由此可得： +至此，我们得到一个尺寸为 $n \times cap$ 的二维 $dp$ 矩阵。 -- **状态包括物品编号 $i$ 和背包容量 $c$**，记为 $[i, c]$ 。 -- 状态 $[i, c]$ 对应子问题“**前 $i$ 个物品在容量为 $c$ 背包中的最大价值**”，解记为 $dp[i, c]$ 。 +**第二步：找出最优子结构，进而推导出状态转移方程** -当我们做出物品 $i$ 的决策后，剩余的是前 $i-1$ 个物品的子问题，因此状态转移分为两种： +当我们做出物品 $i$ 的决策后，剩余的是前 $i-1$ 个物品的决策。因此，状态转移分为两种情况： - **不放入物品 $i$** ：背包容量不变，状态转移至 $[i-1, c]$ ； - **放入物品 $i$** ：背包容量减小 $wgt[i-1]$ ，价值增加 $val[i-1]$ ，状态转移至 $[i-1, c-wgt[i-1]]$ ； -上述的状态转移向我们展示了本题的「最优子结构」：**最大价值 $dp[i, c]$ 等于不放入物品 $i$ 和放入物品 $i$ 两种方案中的价值更大的那一个**。由此可推出状态转移方程： +上述的状态转移向我们揭示了本题的最优子结构：**最大价值 $dp[i, c]$ 等于不放入物品 $i$ 和放入物品 $i$ 两种方案中的价值更大的那一个**。由此可推出状态转移方程： $$ dp[i, c] = \max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1]) $$ -以下是暴力搜索的实现代码，其中包含以下要素： +需要注意的是，若当前物品重量 $wgt[i - 1]$ 超出剩余背包容量 $c$ ，则只能选择不放入背包。 + +**第三步：确定边界条件和状态转移顺序** + +当无物品或无剩余背包容量时最大价值为 $0$ ，即所有 $dp[i, 0]$ 和 $dp[0, c]$ 都等于 $0$ 。 + +当前状态 $[i, c]$ 从上方的状态 $[i-1, c]$ 和左上方的状态 $[i-1, c-wgt[i-1]]$ 转移而来，因此通过两层循环正序遍历整个 $dp$ 表即可。 + +## 方法一：暴力搜索 + +搜索代码包含以下要素： - **递归参数**：状态 $[i, c]$ ；**返回值**：子问题的解 $dp[i, c]$ 。 -- **终止条件**：当已完成 $n$ 轮决策或背包无剩余容量为时，终止递归并返回价值 $0$ 。 -- **剪枝**：若当前物品重量 $wgt[i - 1]$ 超出剩余背包容量 $c$ ，则只能选择不放入背包。 +- **终止条件**：当物品编号越界 $i = 0$ 或背包剩余容量为 $0$ 时，终止递归并返回价值 $0$ 。 +- **剪枝**：若当前物品重量超出背包剩余容量，则只能不放入背包。 === "Java" @@ -108,13 +121,13 @@ $$ 如下图所示，由于每个物品都会产生不选和选两条搜索分支，因此最差时间复杂度为 $O(2^n)$ 。 -观察递归树，容易发现其中存在一些「重叠子问题」。而当物品较多、背包容量较大，尤其是当相同重量的物品较多时，重叠子问题的数量将会大幅增多。 +观察递归树，容易发现其中存在一些「重叠子问题」，例如 $dp[1, 10]$ 等。而当物品较多、背包容量较大，尤其是当相同重量的物品较多时，重叠子问题的数量将会大幅增多。 ![0-1 背包的暴力搜索递归树](knapsack_problem.assets/knapsack_dfs.png) ## 方法二：记忆化搜索 -为了防止重复求解重叠子问题，我们借助一个记忆列表 `mem` 来记录子问题的解，其中 `mem[i][c]` 表示前 $i$ 个物品在容量为 $c$ 背包中的最大价值。当再次遇到相同子问题时，直接从 `mem` 中获取记录。 +为了防止重复求解重叠子问题，我们借助一个记忆列表 `mem` 来记录子问题的解，其中 `mem[i][c]` 对应解 $dp[i, c]$ 。 === "Java" @@ -182,13 +195,13 @@ $$ [class]{}-[func]{knapsackDFSMem} ``` -引入记忆化之后，所有子问题最多只被计算一次，**因此时间复杂度取决于子问题数量**，也就是 $O(n \times cap)$ 。 +引入记忆化之后，所有子问题都只被计算一次，**因此时间复杂度取决于子问题数量**，也就是 $O(n \times cap)$ 。 ![0-1 背包的记忆化搜索递归树](knapsack_problem.assets/knapsack_dfs_mem.png) ## 方法三：动态规划 -接下来就是体力活了，我们将“从顶至底”的记忆化搜索代码译写为“从底至顶”的动态规划代码。 +动态规划解法本质上就是在状态转移中填充 `dp` 矩阵的过程，代码如下所示。 === "Java" @@ -256,7 +269,7 @@ $$ [class]{}-[func]{knapsackDP} ``` -观察下图，动态规划的过程本质上就是填充 $dp$ 列表（矩阵）的过程，时间复杂度也为 $O(n \times cap)$ 。 +如下图所示，时间复杂度由 `dp` 矩阵大小决定，为 $O(n \times cap)$ 。 === "<1>" ![0-1 背包的动态规划过程](knapsack_problem.assets/knapsack_dp_step1.png) @@ -300,9 +313,9 @@ $$ === "<14>" ![knapsack_dp_step14](knapsack_problem.assets/knapsack_dp_step14.png) -**接下来考虑状态压缩**。以上代码中的 $dp$ 矩阵占用 $O(n \times cap)$ 空间。由于每个状态都只与其上一行的状态有关，因此我们可以使用两个数组滚动前进，将空间复杂度从 $O(n^2)$ 将低至 $O(n)$ 。代码省略，有兴趣的同学可以自行实现。 +**最后考虑状态压缩**。以上代码中的 `dp` 矩阵占用 $O(n \times cap)$ 空间。由于每个状态都只与其上一行的状态有关，因此我们可以使用两个数组滚动前进，将空间复杂度从 $O(n^2)$ 将低至 $O(n)$ 。代码省略，有兴趣的同学可以自行实现。 -那么，我们是否可以仅用一个数组实现状态压缩呢？观察可知，每个状态都是由左上方或正上方的格子转移过来的。假设只有一个数组，当遍历到第 $i$ 行时，该数组存储的仍然是第 $i-1$ 行的状态，为了避免左边区域的格子被覆盖，我们应采取倒序遍历，这样方可实现正确的状态转移。 +那么，我们是否可以仅用一个数组实现状态压缩呢？观察可知，每个状态都是由左上方或正上方的格子转移过来的。假设只有一个数组，当遍历到第 $i$ 行时，该数组存储的仍然是第 $i-1$ 行的状态，为了避免左边区域的格子在状态转移中被覆盖，我们应采取倒序遍历。 以下动画展示了在单个数组下从第 $i=1$ 行转换至第 $i=2$ 行的过程。建议你思考一下正序遍历和倒序遍历的区别。 @@ -324,7 +337,7 @@ $$ === "<6>" ![knapsack_dp_comp_step6](knapsack_problem.assets/knapsack_dp_comp_step6.png) -如以下代码所示，我们仅需将 $dp$ 列表的第一维 $i$ 直接删除，并且将内循环修改为倒序遍历即可。 +如以下代码所示，我们仅需将 `dp` 矩阵的第一维 $i$ 直接删除，并且将内循环修改为倒序遍历即可。 === "Java" diff --git a/docs/chapter_tree/avl_tree.md b/docs/chapter_tree/avl_tree.md index 6c23d39a5..c97ed495a 100644 --- a/docs/chapter_tree/avl_tree.md +++ b/docs/chapter_tree/avl_tree.md @@ -542,10 +542,10 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉 | 失衡节点的平衡因子 | 子节点的平衡因子 | 应采用的旋转方法 | | ---------------- | ---------------- | ---------------- | -| $>0$ （即左偏树） | $\geq 0$ | 右旋 | -| $>0$ （即左偏树） | $<0$ | 先左旋后右旋 | -| $<0$ （即右偏树） | $\leq 0$ | 左旋 | -| $<0$ （即右偏树） | $>0$ | 先右旋后左旋 | +| $>1$ （即左偏树） | $\geq 0$ | 右旋 | +| $>1$ （即左偏树） | $<0$ | 先左旋后右旋 | +| $<-1$ （即右偏树） | $\leq 0$ | 左旋 | +| $<-1$ （即右偏树） | $>0$ | 先右旋后左旋 |