Fig. 0-1 背包的示例数据
+ +接下来，我们仍然先从回溯角度入手，先给出暴力搜索解法；再引入记忆化处理，得到记忆化搜索和动态规划解法。 + +## 13.3.1. 方法一：暴力搜索 + +0-1 背包问题是一道典型的“选或不选”的问题，0 代表不选、1 代表选。我们可以将 0-1 背包看作是一个由 $n$ 轮决策组成的搜索过程，对于每个物体都有不放入和放入两种决策。不放入背包，背包容量不变；放入背包，背包容量减小。由此可得： + +- **状态包括物品编号 $i$ 和背包容量 $c$**，记为 $[i, c]$ 。 +- 状态 $[i, c]$ 对应子问题“**前 $i$ 个物品在容量为 $c$ 背包中的最大价值**”，解记为 $dp[i, c]$ 。 + +当我们做出物品 $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] = \max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1]) +$$ + +以下是暴力搜索的实现代码，其中包含以下要素： + +- **递归参数**：状态 $[i, c]$ ；**返回值**：子问题的解 $dp[i, c]$ 。 +- **终止条件**：当已完成 $n$ 轮决策或背包无剩余容量为时，终止递归并返回价值 $0$ 。 +- **剪枝**：若当前物品重量 $wgt[i - 1]$ 超出剩余背包容量 $c$ ，则只能选择不放入背包。 + +=== "Java" + + ```java title="knapsack.java" + [class]{knapsack}-[func]{knapsackDFS} + ``` + +=== "C++" + + ```cpp title="knapsack.cpp" + [class]{}-[func]{knapsackDFS} + ``` + +=== "Python" + + ```python title="knapsack.py" + def knapsack_dfs(wgt, val, i, c): + """0-1 背包：暴力搜索""" + # 若已选完所有物品或背包无容量，则返回价值 0 + if i == 0 or c == 0: + return 0 + # 若超过背包容量，则只能不放入背包 + if wgt[i - 1] > c: + return knapsack_dfs(wgt, val, i - 1, c) + # 计算不放入和放入物品 i 的最大价值 + no = knapsack_dfs(wgt, val, i - 1, c) + yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1] + # 返回两种方案中价值更大的那一个 + return max(no, yes) + ``` + +=== "Go" + + ```go title="knapsack.go" + [class]{}-[func]{knapsackDFS} + ``` + +=== "JavaScript" + + ```javascript title="knapsack.js" + [class]{}-[func]{knapsackDFS} + ``` + +=== "TypeScript" + + ```typescript title="knapsack.ts" + [class]{}-[func]{knapsackDFS} + ``` + +=== "C" + + ```c title="knapsack.c" + [class]{}-[func]{knapsackDFS} + ``` + +=== "C#" + + ```csharp title="knapsack.cs" + [class]{knapsack}-[func]{knapsackDFS} + ``` + +=== "Swift" + + ```swift title="knapsack.swift" + [class]{}-[func]{knapsackDFS} + ``` + +=== "Zig" + + ```zig title="knapsack.zig" + [class]{}-[func]{knapsackDFS} + ``` + +=== "Dart" + + ```dart title="knapsack.dart" + [class]{}-[func]{knapsackDFS} + ``` + +如下图所示，由于每个物品都会产生不选和选两条搜索分支，因此最差时间复杂度为 $O(2^n)$ 。 + +观察递归树，容易发现其中存在一些「重叠子问题」。而当物品较多、背包容量较大，尤其是当相同重量的物品较多时，重叠子问题的数量将会大幅增多。 + + + +Fig. 0-1 背包的暴力搜索递归树
+ +## 13.3.2. 方法二：记忆化搜索 + +为了防止重复求解重叠子问题，我们借助一个记忆列表 `mem` 来记录子问题的解，其中 `mem[i][c]` 表示前 $i$ 个物品在容量为 $c$ 背包中的最大价值。当再次遇到相同子问题时，直接从 `mem` 中获取记录。 + +=== "Java" + + ```java title="knapsack.java" + [class]{knapsack}-[func]{knapsackDFSMem} + ``` + +=== "C++" + + ```cpp title="knapsack.cpp" + [class]{}-[func]{knapsackDFSMem} + ``` + +=== "Python" + + ```python title="knapsack.py" + def knapsack_dfs_mem(wgt, val, mem, i, c): + """0-1 背包：记忆化搜索""" + # 若已选完所有物品或背包无容量，则返回价值 0 + if i == 0 or c == 0: + return 0 + # 若已有记录，则直接返回 + if mem[i][c] != -1: + return mem[i][c] + # 若超过背包容量，则只能不放入背包 + if wgt[i - 1] > c: + return knapsack_dfs_mem(wgt, val, mem, i - 1, c) + # 计算不放入和放入物品 i 的最大价值 + no = knapsack_dfs_mem(wgt, val, mem, i - 1, c) + yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1] + # 记录并返回两种方案中价值更大的那一个 + mem[i][c] = max(no, yes) + return mem[i][c] + ``` + +=== "Go" + + ```go title="knapsack.go" + [class]{}-[func]{knapsackDFSMem} + ``` + +=== "JavaScript" + + ```javascript title="knapsack.js" + [class]{}-[func]{knapsackDFSMem} + ``` + +=== "TypeScript" + + ```typescript title="knapsack.ts" + [class]{}-[func]{knapsackDFSMem} + ``` + +=== "C" + + ```c title="knapsack.c" + [class]{}-[func]{knapsackDFSMem} + ``` + +=== "C#" + + ```csharp title="knapsack.cs" + [class]{knapsack}-[func]{knapsackDFSMem} + ``` + +=== "Swift" + + ```swift title="knapsack.swift" + [class]{}-[func]{knapsackDFSMem} + ``` + +=== "Zig" + + ```zig title="knapsack.zig" + [class]{}-[func]{knapsackDFSMem} + ``` + +=== "Dart" + + ```dart title="knapsack.dart" + [class]{}-[func]{knapsackDFSMem} + ``` + +引入记忆化之后，所有子问题最多只被计算一次，**因此时间复杂度取决于子问题数量**，也就是 $O(n \times cap)$ 。 + + + +Fig. 0-1 背包的记忆化搜索递归树
+ +## 13.3.3. 方法三：动态规划 + +接下来就是体力活了，我们将“从顶至底”的记忆化搜索代码译写为“从底至顶”的动态规划代码。 + +=== "Java" + + ```java title="knapsack.java" + [class]{knapsack}-[func]{knapsackDP} + ``` + +=== "C++" + + ```cpp title="knapsack.cpp" + [class]{}-[func]{knapsackDP} + ``` + +=== "Python" + + ```python title="knapsack.py" + def knapsack_dp(wgt, val, cap): + """0-1 背包：动态规划""" + n = len(wgt) + # 初始化 dp 列表 + dp = [[0] * (cap + 1) for _ in range(n + 1)] + # 状态转移 + for i in range(1, n + 1): + for c in range(1, cap + 1): + if wgt[i - 1] > c: + # 若超过背包容量，则不选物品 i + dp[i][c] = dp[i - 1][c] + else: + # 不选和选物品 i 这两种方案的较大值 + dp[i][c] = max(dp[i - 1][c - wgt[i - 1]] + val[i - 1], dp[i - 1][c]) + return dp[n][cap] + ``` + +=== "Go" + + ```go title="knapsack.go" + [class]{}-[func]{knapsackDP} + ``` + +=== "JavaScript" + + ```javascript title="knapsack.js" + [class]{}-[func]{knapsackDP} + ``` + +=== "TypeScript" + + ```typescript title="knapsack.ts" + [class]{}-[func]{knapsackDP} + ``` + +=== "C" + + ```c title="knapsack.c" + [class]{}-[func]{knapsackDP} + ``` + +=== "C#" + + ```csharp title="knapsack.cs" + [class]{knapsack}-[func]{knapsackDP} + ``` + +=== "Swift" + + ```swift title="knapsack.swift" + [class]{}-[func]{knapsackDP} + ``` + +=== "Zig" + + ```zig title="knapsack.zig" + [class]{}-[func]{knapsackDP} + ``` + +=== "Dart" + + ```dart title="knapsack.dart" + [class]{}-[func]{knapsackDP} + ``` + +观察下图，动态规划的过程本质上就是填充 $dp$ 列表（矩阵）的过程，时间复杂度也为 $O(n \times cap)$ 。 + +=== "<1>" +  + +=== "<2>" +  + +=== "<3>" +  + +=== "<4>" +  + +=== "<5>" +  + +=== "<6>" +  + +=== "<7>" +  + +=== "<8>" +  + +=== "<9>" +  + +=== "<10>" +  + +=== "<11>" +  + +=== "<12>" +  + +=== "<13>" +  + +=== "<14>" +  + +**接下来考虑状态压缩**。以上代码中的 $dp$ 矩阵占用 $O(n \times cap)$ 空间。由于每个状态都只与其上一行的状态有关，因此我们可以使用两个数组滚动前进，将空间复杂度从 $O(n^2)$ 将低至 $O(n)$ 。代码省略，有兴趣的同学可以自行实现。 + +那么，我们是否可以仅用一个数组实现状态压缩呢？观察可知，每个状态都是由左上方或正上方的格子转移过来的。假设只有一个数组，当遍历到第 $i$ 行时，该数组存储的仍然是第 $i-1$ 行的状态，为了避免左边区域的格子被覆盖，我们应采取倒序遍历，这样方可实现正确的状态转移。 + +以下动画展示了在单个数组下从第 $i=1$ 行转换至第 $i=2$ 行的过程。建议你思考一下正序遍历和倒序遍历的区别。 + +=== "<1>" +  + +=== "<2>" +  + +=== "<3>" +  + +=== "<4>" +  + +=== "<5>" +  + +=== "<6>" +  + +如以下代码所示，我们仅需将 $dp$ 列表的第一维 $i$ 直接删除，并且将内循环修改为倒序遍历即可。 + +=== "Java" + + ```java title="knapsack.java" + [class]{knapsack}-[func]{knapsackDPComp} + ``` + +=== "C++" + + ```cpp title="knapsack.cpp" + [class]{}-[func]{knapsackDPComp} + ``` + +=== "Python" + + ```python title="knapsack.py" + def knapsack_dp_comp(wgt, val, cap): + """0-1 背包：状态压缩后的动态规划""" + n = len(wgt) + # 初始化 dp 列表 + dp = [0] * (cap + 1) + # 状态转移 + for i in range(1, n + 1): + # 倒序遍历 + for c in range(cap, 0, -1): + if wgt[i - 1] > c: + # 若超过背包容量，则不选物品 i + dp[c] = dp[c] + else: + # 不选和选物品 i 这两种方案的较大值 + dp[c] = max(dp[c - wgt[i - 1]] + val[i - 1], dp[c]) + return dp[cap] + ``` + +=== "Go" + + ```go title="knapsack.go" + [class]{}-[func]{knapsackDPComp} + ``` + +=== "JavaScript" + + ```javascript title="knapsack.js" + [class]{}-[func]{knapsackDPComp} + ``` + +=== "TypeScript" + + ```typescript title="knapsack.ts" + [class]{}-[func]{knapsackDPComp} + ``` + +=== "C" + + ```c title="knapsack.c" + [class]{}-[func]{knapsackDPComp} + ``` + +=== "C#" + + ```csharp title="knapsack.cs" + [class]{knapsack}-[func]{knapsackDPComp} + ``` + +=== "Swift" + + ```swift title="knapsack.swift" + [class]{}-[func]{knapsackDPComp} + ``` + +=== "Zig" + + ```zig title="knapsack.zig" + [class]{}-[func]{knapsackDPComp} + ``` + +=== "Dart" + + ```dart title="knapsack.dart" + [class]{}-[func]{knapsackDPComp} + ``` diff --git a/chapter_graph/graph_operations.md b/chapter_graph/graph_operations.md index 89ca5d3b5..57ae7bb94 100644 --- a/chapter_graph/graph_operations.md +++ b/chapter_graph/graph_operations.md @@ -1152,8 +1152,8 @@ comments: true panic("error") } // 删除边 vet1 - vet2 - DeleteSliceElms(g.adjList[vet1], vet2) - DeleteSliceElms(g.adjList[vet2], vet1) + g.adjList[vet1] = DeleteSliceElms(g.adjList[vet1], vet2) + g.adjList[vet2] = DeleteSliceElms(g.adjList[vet2], vet1) } /* 添加顶点 */ @@ -1175,8 +1175,8 @@ comments: true // 在邻接表中删除顶点 vet 对应的链表 delete(g.adjList, vet) // 遍历其他顶点的链表，删除所有包含 vet 的边 - for _, list := range g.adjList { - DeleteSliceElms(list, vet) + for v, list := range g.adjList { + g.adjList[v] = DeleteSliceElms(list, vet) } } diff --git a/chapter_hashing/hash_map.md b/chapter_hashing/hash_map.md index 3ea18ce49..29d9f3acb 100755 --- a/chapter_hashing/hash_map.md +++ b/chapter_hashing/hash_map.md @@ -12,11 +12,11 @@ comments: trueFig. 哈希表的抽象表示
-除哈希表外，我们还可以使用数组或链表实现查询功能，其中： +除哈希表外，我们还可以使用数组或链表实现查询功能。若将学生数据看作数组（链表）元素，则有： -- 查询元素需要遍历数组（链表）中的所有元素，使用 $O(n)$ 时间； -- 添加元素仅需添加至数组（链表）的尾部即可，使用 $O(1)$ 时间； -- 删除元素需要先查询再删除，使用 $O(n)$ 时间； +- **添加元素**：仅需将元素添加至数组（链表）的尾部即可，使用 $O(1)$ 时间； +- **查询元素**：由于数组（链表）是乱序的，因此需要遍历数组（链表）中的所有元素，使用 $O(n)$ 时间； +- **删除元素**：需要先查询到元素，再从数组中删除，使用 $O(n)$ 时间；