--- comments: true --- # 14.4 0-1 背包問題背包問題是一個非常好的動態規劃入門題目，是動態規劃中最常見的問題形式。其具有很多變種，例如 0-1 背包問題、完全背包問題、多重背包問題等。在本節中，我們先來求解最常見的 0-1 背包問題。 !!! question 給定 $n$ 個物品，第 $i$ 個物品的重量為 $wgt[i-1]$、價值為 $val[i-1]$ ，和一個容量為 $cap$ 的背包。每個物品只能選擇一次，問在限定背包容量下能放入物品的最大價值。觀察圖 14-17 ，由於物品編號 $i$ 從 $1$ 開始計數，陣列索引從 $0$ 開始計數，因此物品 $i$ 對應重量 $wgt[i-1]$ 和價值 $val[i-1]$ 。 ![0-1 背包的示例資料](knapsack_problem.assets/knapsack_example.png){ class="animation-figure" }

圖 14-17 0-1 背包的示例資料

我們可以將 0-1 背包問題看作一個由 $n$ 輪決策組成的過程，對於每個物體都有不放入和放入兩種決策，因此該問題滿足決策樹模型。該問題的目標是求解“在限定背包容量下能放入物品的最大價值”，因此較大機率是一個動態規劃問題。 **第一步：思考每輪的決策，定義狀態，從而得到 $dp$ 表** 對於每個物品來說，不放入背包，背包容量不變；放入背包，背包容量減小。由此可得狀態定義：當前物品編號 $i$ 和剩餘背包容量 $c$ ，記為 $[i, c]$ 。狀態 $[i, c]$ 對應的子問題為：**前 $i$ 個物品在剩餘容量為 $c$ 的背包中的最大價值**，記為 $dp[i, c]$ 。待求解的是 $dp[n, cap]$ ，因此需要一個尺寸為 $(n+1) \times (cap+1)$ 的二維 $dp$ 表。 **第二步：找出最優子結構，進而推導出狀態轉移方程** 當我們做出物品 $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]) $$ 需要注意的是，若當前物品重量 $wgt[i - 1]$ 超出剩餘背包容量 $c$ ，則只能選擇不放入背包。 **第三步：確定邊界條件和狀態轉移順序** 當無物品或無剩餘背包容量時最大價值為 $0$ ，即首列 $dp[i, 0]$ 和首行 $dp[0, c]$ 都等於 $0$ 。當前狀態 $[i, c]$ 從上方的狀態 $[i-1, c]$ 和左上方的狀態 $[i-1, c-wgt[i-1]]$ 轉移而來，因此透過兩層迴圈正序走訪整個 $dp$ 表即可。根據以上分析，我們接下來按順序實現暴力搜尋、記憶化搜尋、動態規劃解法。 ### 1. 方法一：暴力搜尋搜尋程式碼包含以下要素。 - **遞迴參數**：狀態 $[i, c]$ 。 - **返回值**：子問題的解 $dp[i, c]$ 。 - **終止條件**：當物品編號越界 $i = 0$ 或背包剩餘容量為 $0$ 時，終止遞迴並返回價值 $0$ 。 - **剪枝**：若當前物品重量超出背包剩餘容量，則只能選擇不放入背包。 === "Python" ```python title="knapsack.py" def knapsack_dfs(wgt: list[int], val: list[int], i: int, c: int) -> int: """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) ``` === "C++" ```cpp title="knapsack.cpp" /* 0-1 背包：暴力搜尋 */ int knapsackDFS(vector &wgt, vector &val, int i, int c) { // 若已選完所有物品或背包無剩餘容量，則返回價值 0 if (i == 0 || c == 0) { return 0; } // 若超過背包容量，則只能選擇不放入背包 if (wgt[i - 1] > c) { return knapsackDFS(wgt, val, i - 1, c); } // 計算不放入和放入物品 i 的最大價值 int no = knapsackDFS(wgt, val, i - 1, c); int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1]; // 返回兩種方案中價值更大的那一個 return max(no, yes); } ``` === "Java" ```java title="knapsack.java" /* 0-1 背包：暴力搜尋 */ int knapsackDFS(int[] wgt, int[] val, int i, int c) { // 若已選完所有物品或背包無剩餘容量，則返回價值 0 if (i == 0 || c == 0) { return 0; } // 若超過背包容量，則只能選擇不放入背包 if (wgt[i - 1] > c) { return knapsackDFS(wgt, val, i - 1, c); } // 計算不放入和放入物品 i 的最大價值 int no = knapsackDFS(wgt, val, i - 1, c); int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1]; // 返回兩種方案中價值更大的那一個 return Math.max(no, yes); } ``` === "C#" ```csharp title="knapsack.cs" /* 0-1 背包：暴力搜尋 */ int KnapsackDFS(int[] weight, int[] val, int i, int c) { // 若已選完所有物品或背包無剩餘容量，則返回價值 0 if (i == 0 || c == 0) { return 0; } // 若超過背包容量，則只能選擇不放入背包 if (weight[i - 1] > c) { return KnapsackDFS(weight, val, i - 1, c); } // 計算不放入和放入物品 i 的最大價值 int no = KnapsackDFS(weight, val, i - 1, c); int yes = KnapsackDFS(weight, val, i - 1, c - weight[i - 1]) + val[i - 1]; // 返回兩種方案中價值更大的那一個 return Math.Max(no, yes); } ``` === "Go" ```go title="knapsack.go" /* 0-1 背包：暴力搜尋 */ func knapsackDFS(wgt, val []int, i, c int) int { // 若已選完所有物品或背包無剩餘容量，則返回價值 0 if i == 0 || c == 0 { return 0 } // 若超過背包容量，則只能選擇不放入背包 if wgt[i-1] > c { return knapsackDFS(wgt, val, i-1, c) } // 計算不放入和放入物品 i 的最大價值 no := knapsackDFS(wgt, val, i-1, c) yes := knapsackDFS(wgt, val, i-1, c-wgt[i-1]) + val[i-1] // 返回兩種方案中價值更大的那一個 return int(math.Max(float64(no), float64(yes))) } ``` === "Swift" ```swift title="knapsack.swift" /* 0-1 背包：暴力搜尋 */ func knapsackDFS(wgt: [Int], val: [Int], i: Int, c: Int) -> Int { // 若已選完所有物品或背包無剩餘容量，則返回價值 0 if i == 0 || c == 0 { return 0 } // 若超過背包容量，則只能選擇不放入背包 if wgt[i - 1] > c { return knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c) } // 計算不放入和放入物品 i 的最大價值 let no = knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c) let yes = knapsackDFS(wgt: wgt, val: val, i: i - 1, c: c - wgt[i - 1]) + val[i - 1] // 返回兩種方案中價值更大的那一個 return max(no, yes) } ``` === "JS" ```javascript title="knapsack.js" /* 0-1 背包：暴力搜尋 */ function knapsackDFS(wgt, val, i, c) { // 若已選完所有物品或背包無剩餘容量，則返回價值 0 if (i === 0 || c === 0) { return 0; } // 若超過背包容量，則只能選擇不放入背包 if (wgt[i - 1] > c) { return knapsackDFS(wgt, val, i - 1, c); } // 計算不放入和放入物品 i 的最大價值 const no = knapsackDFS(wgt, val, i - 1, c); const yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1]; // 返回兩種方案中價值更大的那一個 return Math.max(no, yes); } ``` === "TS" ```typescript title="knapsack.ts" /* 0-1 背包：暴力搜尋 */ function knapsackDFS( wgt: Array, val: Array, i: number, c: number ): number { // 若已選完所有物品或背包無剩餘容量，則返回價值 0 if (i === 0 || c === 0) { return 0; } // 若超過背包容量，則只能選擇不放入背包 if (wgt[i - 1] > c) { return knapsackDFS(wgt, val, i - 1, c); } // 計算不放入和放入物品 i 的最大價值 const no = knapsackDFS(wgt, val, i - 1, c); const yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1]; // 返回兩種方案中價值更大的那一個 return Math.max(no, yes); } ``` === "Dart" ```dart title="knapsack.dart" /* 0-1 背包：暴力搜尋 */ int knapsackDFS(List wgt, List val, int i, int c) { // 若已選完所有物品或背包無剩餘容量，則返回價值 0 if (i == 0 || c == 0) { return 0; } // 若超過背包容量，則只能選擇不放入背包 if (wgt[i - 1] > c) { return knapsackDFS(wgt, val, i - 1, c); } // 計算不放入和放入物品 i 的最大價值 int no = knapsackDFS(wgt, val, i - 1, c); int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1]; // 返回兩種方案中價值更大的那一個 return max(no, yes); } ``` === "Rust" ```rust title="knapsack.rs" /* 0-1 背包：暴力搜尋 */ fn knapsack_dfs(wgt: &[i32], val: &[i32], i: usize, c: usize) -> i32 { // 若已選完所有物品或背包無剩餘容量，則返回價值 0 if i == 0 || c == 0 { return 0; } // 若超過背包容量，則只能選擇不放入背包 if wgt[i - 1] > c as i32 { return knapsack_dfs(wgt, val, i - 1, c); } // 計算不放入和放入物品 i 的最大價值 let no = knapsack_dfs(wgt, val, i - 1, c); let yes = knapsack_dfs(wgt, val, i - 1, c - wgt[i - 1] as usize) + val[i - 1]; // 返回兩種方案中價值更大的那一個 std::cmp::max(no, yes) } ``` === "C" ```c title="knapsack.c" /* 0-1 背包：暴力搜尋 */ int knapsackDFS(int wgt[], int val[], int i, int c) { // 若已選完所有物品或背包無剩餘容量，則返回價值 0 if (i == 0 || c == 0) { return 0; } // 若超過背包容量，則只能選擇不放入背包 if (wgt[i - 1] > c) { return knapsackDFS(wgt, val, i - 1, c); } // 計算不放入和放入物品 i 的最大價值 int no = knapsackDFS(wgt, val, i - 1, c); int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1]; // 返回兩種方案中價值更大的那一個 return myMax(no, yes); } ``` === "Kotlin" ```kotlin title="knapsack.kt" /* 0-1 背包：暴力搜尋 */ fun knapsackDFS( wgt: IntArray, _val: IntArray, i: Int, c: Int ): Int { // 若已選完所有物品或背包無剩餘容量，則返回價值 0 if (i == 0 || c == 0) { return 0 } // 若超過背包容量，則只能選擇不放入背包 if (wgt[i - 1] > c) { return knapsackDFS(wgt, _val, i - 1, c) } // 計算不放入和放入物品 i 的最大價值 val no = knapsackDFS(wgt, _val, i - 1, c) val yes = knapsackDFS(wgt, _val, i - 1, c - wgt[i - 1]) + _val[i - 1] // 返回兩種方案中價值更大的那一個 return max(no, yes) } ``` === "Ruby" ```ruby title="knapsack.rb" [class]{}-[func]{knapsack_dfs} ``` === "Zig" ```zig title="knapsack.zig" // 0-1 背包：暴力搜尋 fn knapsackDFS(wgt: []i32, val: []i32, i: usize, c: usize) i32 { // 若已選完所有物品或背包無剩餘容量，則返回價值 0 if (i == 0 or c == 0) { return 0; } // 若超過背包容量，則只能選擇不放入背包 if (wgt[i - 1] > c) { return knapsackDFS(wgt, val, i - 1, c); } // 計算不放入和放入物品 i 的最大價值 var no = knapsackDFS(wgt, val, i - 1, c); var yes = knapsackDFS(wgt, val, i - 1, c - @as(usize, @intCast(wgt[i - 1]))) + val[i - 1]; // 返回兩種方案中價值更大的那一個 return @max(no, yes); } ``` ??? pythontutor "視覺化執行"

如圖 14-18 所示，由於每個物品都會產生不選和選兩條搜尋分支，因此時間複雜度為 $O(2^n)$ 。觀察遞迴樹，容易發現其中存在重疊子問題，例如 $dp[1, 10]$ 等。而當物品較多、背包容量較大，尤其是相同重量的物品較多時，重疊子問題的數量將會大幅增多。 ![0-1 背包問題的暴力搜尋遞迴樹](knapsack_problem.assets/knapsack_dfs.png){ class="animation-figure" }

圖 14-18 0-1 背包問題的暴力搜尋遞迴樹

### 2. 方法二：記憶化搜尋為了保證重疊子問題只被計算一次，我們藉助記憶串列 `mem` 來記錄子問題的解，其中 `mem[i][c]` 對應 $dp[i, c]$ 。引入記憶化之後，**時間複雜度取決於子問題數量**，也就是 $O(n \times cap)$ 。實現程式碼如下： === "Python" ```python title="knapsack.py" def knapsack_dfs_mem( wgt: list[int], val: list[int], mem: list[list[int]], i: int, c: int ) -> int: """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] ``` === "C++" ```cpp title="knapsack.cpp" /* 0-1 背包：記憶化搜尋 */ int knapsackDFSMem(vector &wgt, vector &val, vector> &mem, int i, int c) { // 若已選完所有物品或背包無剩餘容量，則返回價值 0 if (i == 0 || c == 0) { return 0; } // 若已有記錄，則直接返回 if (mem[i][c] != -1) { return mem[i][c]; } // 若超過背包容量，則只能選擇不放入背包 if (wgt[i - 1] > c) { return knapsackDFSMem(wgt, val, mem, i - 1, c); } // 計算不放入和放入物品 i 的最大價值 int no = knapsackDFSMem(wgt, val, mem, i - 1, c); int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1]; // 記錄並返回兩種方案中價值更大的那一個 mem[i][c] = max(no, yes); return mem[i][c]; } ``` === "Java" ```java title="knapsack.java" /* 0-1 背包：記憶化搜尋 */ int knapsackDFSMem(int[] wgt, int[] val, int[][] mem, int i, int c) { // 若已選完所有物品或背包無剩餘容量，則返回價值 0 if (i == 0 || c == 0) { return 0; } // 若已有記錄，則直接返回 if (mem[i][c] != -1) { return mem[i][c]; } // 若超過背包容量，則只能選擇不放入背包 if (wgt[i - 1] > c) { return knapsackDFSMem(wgt, val, mem, i - 1, c); } // 計算不放入和放入物品 i 的最大價值 int no = knapsackDFSMem(wgt, val, mem, i - 1, c); int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1]; // 記錄並返回兩種方案中價值更大的那一個 mem[i][c] = Math.max(no, yes); return mem[i][c]; } ``` === "C#" ```csharp title="knapsack.cs" /* 0-1 背包：記憶化搜尋 */ int KnapsackDFSMem(int[] weight, int[] val, int[][] mem, int i, int c) { // 若已選完所有物品或背包無剩餘容量，則返回價值 0 if (i == 0 || c == 0) { return 0; } // 若已有記錄，則直接返回 if (mem[i][c] != -1) { return mem[i][c]; } // 若超過背包容量，則只能選擇不放入背包 if (weight[i - 1] > c) { return KnapsackDFSMem(weight, val, mem, i - 1, c); } // 計算不放入和放入物品 i 的最大價值 int no = KnapsackDFSMem(weight, val, mem, i - 1, c); int yes = KnapsackDFSMem(weight, val, mem, i - 1, c - weight[i - 1]) + val[i - 1]; // 記錄並返回兩種方案中價值更大的那一個 mem[i][c] = Math.Max(no, yes); return mem[i][c]; } ``` === "Go" ```go title="knapsack.go" /* 0-1 背包：記憶化搜尋 */ func knapsackDFSMem(wgt, val []int, mem [][]int, i, c int) int { // 若已選完所有物品或背包無剩餘容量，則返回價值 0 if i == 0 || c == 0 { return 0 } // 若已有記錄，則直接返回 if mem[i][c] != -1 { return mem[i][c] } // 若超過背包容量，則只能選擇不放入背包 if wgt[i-1] > c { return knapsackDFSMem(wgt, val, mem, i-1, c) } // 計算不放入和放入物品 i 的最大價值 no := knapsackDFSMem(wgt, val, mem, i-1, c) yes := knapsackDFSMem(wgt, val, mem, i-1, c-wgt[i-1]) + val[i-1] // 返回兩種方案中價值更大的那一個 mem[i][c] = int(math.Max(float64(no), float64(yes))) return mem[i][c] } ``` === "Swift" ```swift title="knapsack.swift" /* 0-1 背包：記憶化搜尋 */ func knapsackDFSMem(wgt: [Int], val: [Int], mem: inout [[Int]], i: Int, c: Int) -> Int { // 若已選完所有物品或背包無剩餘容量，則返回價值 0 if i == 0 || c == 0 { return 0 } // 若已有記錄，則直接返回 if mem[i][c] != -1 { return mem[i][c] } // 若超過背包容量，則只能選擇不放入背包 if wgt[i - 1] > c { return knapsackDFSMem(wgt: wgt, val: val, mem: &mem, i: i - 1, c: c) } // 計算不放入和放入物品 i 的最大價值 let no = knapsackDFSMem(wgt: wgt, val: val, mem: &mem, i: i - 1, c: c) let yes = knapsackDFSMem(wgt: wgt, val: val, mem: &mem, i: i - 1, c: c - wgt[i - 1]) + val[i - 1] // 記錄並返回兩種方案中價值更大的那一個 mem[i][c] = max(no, yes) return mem[i][c] } ``` === "JS" ```javascript title="knapsack.js" /* 0-1 背包：記憶化搜尋 */ function knapsackDFSMem(wgt, val, mem, i, c) { // 若已選完所有物品或背包無剩餘容量，則返回價值 0 if (i === 0 || c === 0) { return 0; } // 若已有記錄，則直接返回 if (mem[i][c] !== -1) { return mem[i][c]; } // 若超過背包容量，則只能選擇不放入背包 if (wgt[i - 1] > c) { return knapsackDFSMem(wgt, val, mem, i - 1, c); } // 計算不放入和放入物品 i 的最大價值 const no = knapsackDFSMem(wgt, val, mem, i - 1, c); const yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1]; // 記錄並返回兩種方案中價值更大的那一個 mem[i][c] = Math.max(no, yes); return mem[i][c]; } ``` === "TS" ```typescript title="knapsack.ts" /* 0-1 背包：記憶化搜尋 */ function knapsackDFSMem( wgt: Array, val: Array, mem: Array>, i: number, c: number ): number { // 若已選完所有物品或背包無剩餘容量，則返回價值 0 if (i === 0 || c === 0) { return 0; } // 若已有記錄，則直接返回 if (mem[i][c] !== -1) { return mem[i][c]; } // 若超過背包容量，則只能選擇不放入背包 if (wgt[i - 1] > c) { return knapsackDFSMem(wgt, val, mem, i - 1, c); } // 計算不放入和放入物品 i 的最大價值 const no = knapsackDFSMem(wgt, val, mem, i - 1, c); const yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1]; // 記錄並返回兩種方案中價值更大的那一個 mem[i][c] = Math.max(no, yes); return mem[i][c]; } ``` === "Dart" ```dart title="knapsack.dart" /* 0-1 背包：記憶化搜尋 */ int knapsackDFSMem( List wgt, List val, List> mem, int i, int c, ) { // 若已選完所有物品或背包無剩餘容量，則返回價值 0 if (i == 0 || c == 0) { return 0; } // 若已有記錄，則直接返回 if (mem[i][c] != -1) { return mem[i][c]; } // 若超過背包容量，則只能選擇不放入背包 if (wgt[i - 1] > c) { return knapsackDFSMem(wgt, val, mem, i - 1, c); } // 計算不放入和放入物品 i 的最大價值 int no = knapsackDFSMem(wgt, val, mem, i - 1, c); int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1]; // 記錄並返回兩種方案中價值更大的那一個 mem[i][c] = max(no, yes); return mem[i][c]; } ``` === "Rust" ```rust title="knapsack.rs" /* 0-1 背包：記憶化搜尋 */ fn knapsack_dfs_mem(wgt: &[i32], val: &[i32], mem: &mut Vec>, i: usize, c: usize) -> i32 { // 若已選完所有物品或背包無剩餘容量，則返回價值 0 if i == 0 || c == 0 { return 0; } // 若已有記錄，則直接返回 if mem[i][c] != -1 { return mem[i][c]; } // 若超過背包容量，則只能選擇不放入背包 if wgt[i - 1] > c as i32 { return knapsack_dfs_mem(wgt, val, mem, i - 1, c); } // 計算不放入和放入物品 i 的最大價值 let no = knapsack_dfs_mem(wgt, val, mem, i - 1, c); let yes = knapsack_dfs_mem(wgt, val, mem, i - 1, c - wgt[i - 1] as usize) + val[i - 1]; // 記錄並返回兩種方案中價值更大的那一個 mem[i][c] = std::cmp::max(no, yes); mem[i][c] } ``` === "C" ```c title="knapsack.c" /* 0-1 背包：記憶化搜尋 */ int knapsackDFSMem(int wgt[], int val[], int memCols, int **mem, int i, int c) { // 若已選完所有物品或背包無剩餘容量，則返回價值 0 if (i == 0 || c == 0) { return 0; } // 若已有記錄，則直接返回 if (mem[i][c] != -1) { return mem[i][c]; } // 若超過背包容量，則只能選擇不放入背包 if (wgt[i - 1] > c) { return knapsackDFSMem(wgt, val, memCols, mem, i - 1, c); } // 計算不放入和放入物品 i 的最大價值 int no = knapsackDFSMem(wgt, val, memCols, mem, i - 1, c); int yes = knapsackDFSMem(wgt, val, memCols, mem, i - 1, c - wgt[i - 1]) + val[i - 1]; // 記錄並返回兩種方案中價值更大的那一個 mem[i][c] = myMax(no, yes); return mem[i][c]; } ``` === "Kotlin" ```kotlin title="knapsack.kt" /* 0-1 背包：記憶化搜尋 */ fun knapsackDFSMem( wgt: IntArray, _val: IntArray, mem: Array, i: Int, c: Int ): Int { // 若已選完所有物品或背包無剩餘容量，則返回價值 0 if (i == 0 || c == 0) { return 0 } // 若已有記錄，則直接返回 if (mem[i][c] != -1) { return mem[i][c] } // 若超過背包容量，則只能選擇不放入背包 if (wgt[i - 1] > c) { return knapsackDFSMem(wgt, _val, mem, i - 1, c) } // 計算不放入和放入物品 i 的最大價值 val no = knapsackDFSMem(wgt, _val, mem, i - 1, c) val yes = knapsackDFSMem(wgt, _val, mem, i - 1, c - wgt[i - 1]) + _val[i - 1] // 記錄並返回兩種方案中價值更大的那一個 mem[i][c] = max(no, yes) return mem[i][c] } ``` === "Ruby" ```ruby title="knapsack.rb" [class]{}-[func]{knapsack_dfs_mem} ``` === "Zig" ```zig title="knapsack.zig" // 0-1 背包：記憶化搜尋 fn knapsackDFSMem(wgt: []i32, val: []i32, mem: anytype, i: usize, c: usize) i32 { // 若已選完所有物品或背包無剩餘容量，則返回價值 0 if (i == 0 or c == 0) { return 0; } // 若已有記錄，則直接返回 if (mem[i][c] != -1) { return mem[i][c]; } // 若超過背包容量，則只能選擇不放入背包 if (wgt[i - 1] > c) { return knapsackDFSMem(wgt, val, mem, i - 1, c); } // 計算不放入和放入物品 i 的最大價值 var no = knapsackDFSMem(wgt, val, mem, i - 1, c); var yes = knapsackDFSMem(wgt, val, mem, i - 1, c - @as(usize, @intCast(wgt[i - 1]))) + val[i - 1]; // 記錄並返回兩種方案中價值更大的那一個 mem[i][c] = @max(no, yes); return mem[i][c]; } ``` ??? pythontutor "視覺化執行"

全螢幕觀看 >

圖 14-19 展示了在記憶化搜尋中被剪掉的搜尋分支。 ![0-1 背包問題的記憶化搜尋遞迴樹](knapsack_problem.assets/knapsack_dfs_mem.png){ class="animation-figure" }

圖 14-19 0-1 背包問題的記憶化搜尋遞迴樹

### 3. 方法三：動態規劃動態規劃實質上就是在狀態轉移中填充 $dp$ 表的過程，程式碼如下所示： === "Python" ```python title="knapsack.py" def knapsack_dp(wgt: list[int], val: list[int], cap: int) -> int: """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], dp[i - 1][c - wgt[i - 1]] + val[i - 1]) return dp[n][cap] ``` === "C++" ```cpp title="knapsack.cpp" /* 0-1 背包：動態規劃 */ int knapsackDP(vector &wgt, vector &val, int cap) { int n = wgt.size(); // 初始化 dp 表 vector> dp(n + 1, vector(cap + 1, 0)); // 狀態轉移 for (int i = 1; i <= n; i++) { for (int c = 1; c <= cap; c++) { if (wgt[i - 1] > c) { // 若超過背包容量，則不選物品 i dp[i][c] = dp[i - 1][c]; } else { // 不選和選物品 i 這兩種方案的較大值 dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]); } } } return dp[n][cap]; } ``` === "Java" ```java title="knapsack.java" /* 0-1 背包：動態規劃 */ int knapsackDP(int[] wgt, int[] val, int cap) { int n = wgt.length; // 初始化 dp 表 int[][] dp = new int[n + 1][cap + 1]; // 狀態轉移 for (int i = 1; i <= n; i++) { for (int c = 1; c <= cap; c++) { if (wgt[i - 1] > c) { // 若超過背包容量，則不選物品 i dp[i][c] = dp[i - 1][c]; } else { // 不選和選物品 i 這兩種方案的較大值 dp[i][c] = Math.max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]); } } } return dp[n][cap]; } ``` === "C#" ```csharp title="knapsack.cs" /* 0-1 背包：動態規劃 */ int KnapsackDP(int[] weight, int[] val, int cap) { int n = weight.Length; // 初始化 dp 表 int[,] dp = new int[n + 1, cap + 1]; // 狀態轉移 for (int i = 1; i <= n; i++) { for (int c = 1; c <= cap; c++) { if (weight[i - 1] > c) { // 若超過背包容量，則不選物品 i dp[i, c] = dp[i - 1, c]; } else { // 不選和選物品 i 這兩種方案的較大值 dp[i, c] = Math.Max(dp[i - 1, c - weight[i - 1]] + val[i - 1], dp[i - 1, c]); } } } return dp[n, cap]; } ``` === "Go" ```go title="knapsack.go" /* 0-1 背包：動態規劃 */ func knapsackDP(wgt, val []int, cap int) int { n := len(wgt) // 初始化 dp 表 dp := make([][]int, n+1) for i := 0; i <= n; i++ { dp[i] = make([]int, cap+1) } // 狀態轉移 for i := 1; i <= n; i++ { for c := 1; c <= cap; c++ { if wgt[i-1] > c { // 若超過背包容量，則不選物品 i dp[i][c] = dp[i-1][c] } else { // 不選和選物品 i 這兩種方案的較大值 dp[i][c] = int(math.Max(float64(dp[i-1][c]), float64(dp[i-1][c-wgt[i-1]]+val[i-1]))) } } } return dp[n][cap] } ``` === "Swift" ```swift title="knapsack.swift" /* 0-1 背包：動態規劃 */ func knapsackDP(wgt: [Int], val: [Int], cap: Int) -> Int { let n = wgt.count // 初始化 dp 表 var dp = Array(repeating: Array(repeating: 0, count: cap + 1), count: n + 1) // 狀態轉移 for i in 1 ... n { for c in 1 ... cap { if wgt[i - 1] > c { // 若超過背包容量，則不選物品 i dp[i][c] = dp[i - 1][c] } else { // 不選和選物品 i 這兩種方案的較大值 dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]) } } } return dp[n][cap] } ``` === "JS" ```javascript title="knapsack.js" /* 0-1 背包：動態規劃 */ function knapsackDP(wgt, val, cap) { const n = wgt.length; // 初始化 dp 表 const dp = Array(n + 1) .fill(0) .map(() => Array(cap + 1).fill(0)); // 狀態轉移 for (let i = 1; i <= n; i++) { for (let c = 1; c <= cap; c++) { if (wgt[i - 1] > c) { // 若超過背包容量，則不選物品 i dp[i][c] = dp[i - 1][c]; } else { // 不選和選物品 i 這兩種方案的較大值 dp[i][c] = Math.max( dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1] ); } } } return dp[n][cap]; } ``` === "TS" ```typescript title="knapsack.ts" /* 0-1 背包：動態規劃 */ function knapsackDP( wgt: Array, val: Array, cap: number ): number { const n = wgt.length; // 初始化 dp 表 const dp = Array.from({ length: n + 1 }, () => Array.from({ length: cap + 1 }, () => 0) ); // 狀態轉移 for (let i = 1; i <= n; i++) { for (let c = 1; c <= cap; c++) { if (wgt[i - 1] > c) { // 若超過背包容量，則不選物品 i dp[i][c] = dp[i - 1][c]; } else { // 不選和選物品 i 這兩種方案的較大值 dp[i][c] = Math.max( dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1] ); } } } return dp[n][cap]; } ``` === "Dart" ```dart title="knapsack.dart" /* 0-1 背包：動態規劃 */ int knapsackDP(List wgt, List val, int cap) { int n = wgt.length; // 初始化 dp 表 List> dp = List.generate(n + 1, (index) => List.filled(cap + 1, 0)); // 狀態轉移 for (int i = 1; i <= n; i++) { for (int c = 1; c <= cap; c++) { if (wgt[i - 1] > c) { // 若超過背包容量，則不選物品 i dp[i][c] = dp[i - 1][c]; } else { // 不選和選物品 i 這兩種方案的較大值 dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]); } } } return dp[n][cap]; } ``` === "Rust" ```rust title="knapsack.rs" /* 0-1 背包：動態規劃 */ fn knapsack_dp(wgt: &[i32], val: &[i32], cap: usize) -> i32 { let n = wgt.len(); // 初始化 dp 表 let mut dp = vec![vec![0; cap + 1]; n + 1]; // 狀態轉移 for i in 1..=n { for c in 1..=cap { if wgt[i - 1] > c as i32 { // 若超過背包容量，則不選物品 i dp[i][c] = dp[i - 1][c]; } else { // 不選和選物品 i 這兩種方案的較大值 dp[i][c] = std::cmp::max( dp[i - 1][c], dp[i - 1][c - wgt[i - 1] as usize] + val[i - 1], ); } } } dp[n][cap] } ``` === "C" ```c title="knapsack.c" /* 0-1 背包：動態規劃 */ int knapsackDP(int wgt[], int val[], int cap, int wgtSize) { int n = wgtSize; // 初始化 dp 表 int **dp = malloc((n + 1) * sizeof(int *)); for (int i = 0; i <= n; i++) { dp[i] = calloc(cap + 1, sizeof(int)); } // 狀態轉移 for (int i = 1; i <= n; i++) { for (int c = 1; c <= cap; c++) { if (wgt[i - 1] > c) { // 若超過背包容量，則不選物品 i dp[i][c] = dp[i - 1][c]; } else { // 不選和選物品 i 這兩種方案的較大值 dp[i][c] = myMax(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]); } } } int res = dp[n][cap]; // 釋放記憶體 for (int i = 0; i <= n; i++) { free(dp[i]); } return res; } ``` === "Kotlin" ```kotlin title="knapsack.kt" /* 0-1 背包：動態規劃 */ fun knapsackDP(wgt: IntArray, _val: IntArray, cap: Int): Int { val n = wgt.size // 初始化 dp 表 val dp = Array(n + 1) { IntArray(cap + 1) } // 狀態轉移 for (i in 1..n) { for (c in 1..cap) { if (wgt[i - 1] > c) { // 若超過背包容量，則不選物品 i dp[i][c] = dp[i - 1][c] } else { // 不選和選物品 i 這兩種方案的較大值 dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + _val[i - 1]) } } } return dp[n][cap] } ``` === "Ruby" ```ruby title="knapsack.rb" [class]{}-[func]{knapsack_dp} ``` === "Zig" ```zig title="knapsack.zig" // 0-1 背包：動態規劃 fn knapsackDP(comptime wgt: []i32, val: []i32, comptime cap: usize) i32 { comptime var n = wgt.len; // 初始化 dp 表 var dp = [_][cap + 1]i32{[_]i32{0} ** (cap + 1)} ** (n + 1); // 狀態轉移 for (1..n + 1) |i| { for (1..cap + 1) |c| { if (wgt[i - 1] > c) { // 若超過背包容量，則不選物品 i dp[i][c] = dp[i - 1][c]; } else { // 不選和選物品 i 這兩種方案的較大值 dp[i][c] = @max(dp[i - 1][c], dp[i - 1][c - @as(usize, @intCast(wgt[i - 1]))] + val[i - 1]); } } } return dp[n][cap]; } ``` ??? pythontutor "視覺化執行"

全螢幕觀看 >

如圖 14-20 所示，時間複雜度和空間複雜度都由陣列 `dp` 大小決定，即 $O(n \times cap)$ 。 === "<1>" ![0-1 背包問題的動態規劃過程](knapsack_problem.assets/knapsack_dp_step1.png){ class="animation-figure" } === "<2>" ![knapsack_dp_step2](knapsack_problem.assets/knapsack_dp_step2.png){ class="animation-figure" } === "<3>" ![knapsack_dp_step3](knapsack_problem.assets/knapsack_dp_step3.png){ class="animation-figure" } === "<4>" ![knapsack_dp_step4](knapsack_problem.assets/knapsack_dp_step4.png){ class="animation-figure" } === "<5>" ![knapsack_dp_step5](knapsack_problem.assets/knapsack_dp_step5.png){ class="animation-figure" } === "<6>" ![knapsack_dp_step6](knapsack_problem.assets/knapsack_dp_step6.png){ class="animation-figure" } === "<7>" ![knapsack_dp_step7](knapsack_problem.assets/knapsack_dp_step7.png){ class="animation-figure" } === "<8>" ![knapsack_dp_step8](knapsack_problem.assets/knapsack_dp_step8.png){ class="animation-figure" } === "<9>" ![knapsack_dp_step9](knapsack_problem.assets/knapsack_dp_step9.png){ class="animation-figure" } === "<10>" ![knapsack_dp_step10](knapsack_problem.assets/knapsack_dp_step10.png){ class="animation-figure" } === "<11>" ![knapsack_dp_step11](knapsack_problem.assets/knapsack_dp_step11.png){ class="animation-figure" } === "<12>" ![knapsack_dp_step12](knapsack_problem.assets/knapsack_dp_step12.png){ class="animation-figure" } === "<13>" ![knapsack_dp_step13](knapsack_problem.assets/knapsack_dp_step13.png){ class="animation-figure" } === "<14>" ![knapsack_dp_step14](knapsack_problem.assets/knapsack_dp_step14.png){ class="animation-figure" }

圖 14-20 0-1 背包問題的動態規劃過程

### 4. 空間最佳化由於每個狀態都只與其上一行的狀態有關，因此我們可以使用兩個陣列滾動前進，將空間複雜度從 $O(n^2)$ 降至 $O(n)$ 。進一步思考，我們能否僅用一個陣列實現空間最佳化呢？觀察可知，每個狀態都是由正上方或左上方的格子轉移過來的。假設只有一個陣列，當開始走訪第 $i$ 行時，該陣列儲存的仍然是第 $i-1$ 行的狀態。 - 如果採取正序走訪，那麼走訪到 $dp[i, j]$ 時，左上方 $dp[i-1, 1]$ ~ $dp[i-1, j-1]$ 值可能已經被覆蓋，此時就無法得到正確的狀態轉移結果。 - 如果採取倒序走訪，則不會發生覆蓋問題，狀態轉移可以正確進行。圖 14-21 展示了在單個陣列下從第 $i = 1$ 行轉換至第 $i = 2$ 行的過程。請思考正序走訪和倒序走訪的區別。 === "<1>" ![0-1 背包的空間最佳化後的動態規劃過程](knapsack_problem.assets/knapsack_dp_comp_step1.png){ class="animation-figure" } === "<2>" ![knapsack_dp_comp_step2](knapsack_problem.assets/knapsack_dp_comp_step2.png){ class="animation-figure" } === "<3>" ![knapsack_dp_comp_step3](knapsack_problem.assets/knapsack_dp_comp_step3.png){ class="animation-figure" } === "<4>" ![knapsack_dp_comp_step4](knapsack_problem.assets/knapsack_dp_comp_step4.png){ class="animation-figure" } === "<5>" ![knapsack_dp_comp_step5](knapsack_problem.assets/knapsack_dp_comp_step5.png){ class="animation-figure" } === "<6>" ![knapsack_dp_comp_step6](knapsack_problem.assets/knapsack_dp_comp_step6.png){ class="animation-figure" }

圖 14-21 0-1 背包的空間最佳化後的動態規劃過程

在程式碼實現中，我們僅需將陣列 `dp` 的第一維 $i$ 直接刪除，並且把內迴圈更改為倒序走訪即可： === "Python" ```python title="knapsack.py" def knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -> int: """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], dp[c - wgt[i - 1]] + val[i - 1]) return dp[cap] ``` === "C++" ```cpp title="knapsack.cpp" /* 0-1 背包：空間最佳化後的動態規劃 */ int knapsackDPComp(vector &wgt, vector &val, int cap) { int n = wgt.size(); // 初始化 dp 表 vector dp(cap + 1, 0); // 狀態轉移 for (int i = 1; i <= n; i++) { // 倒序走訪 for (int c = cap; c >= 1; c--) { if (wgt[i - 1] <= c) { // 不選和選物品 i 這兩種方案的較大值 dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]); } } } return dp[cap]; } ``` === "Java" ```java title="knapsack.java" /* 0-1 背包：空間最佳化後的動態規劃 */ int knapsackDPComp(int[] wgt, int[] val, int cap) { int n = wgt.length; // 初始化 dp 表 int[] dp = new int[cap + 1]; // 狀態轉移 for (int i = 1; i <= n; i++) { // 倒序走訪 for (int c = cap; c >= 1; c--) { if (wgt[i - 1] <= c) { // 不選和選物品 i 這兩種方案的較大值 dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]); } } } return dp[cap]; } ``` === "C#" ```csharp title="knapsack.cs" /* 0-1 背包：空間最佳化後的動態規劃 */ int KnapsackDPComp(int[] weight, int[] val, int cap) { int n = weight.Length; // 初始化 dp 表 int[] dp = new int[cap + 1]; // 狀態轉移 for (int i = 1; i <= n; i++) { // 倒序走訪 for (int c = cap; c > 0; c--) { if (weight[i - 1] > c) { // 若超過背包容量，則不選物品 i dp[c] = dp[c]; } else { // 不選和選物品 i 這兩種方案的較大值 dp[c] = Math.Max(dp[c], dp[c - weight[i - 1]] + val[i - 1]); } } } return dp[cap]; } ``` === "Go" ```go title="knapsack.go" /* 0-1 背包：空間最佳化後的動態規劃 */ func knapsackDPComp(wgt, val []int, cap int) int { n := len(wgt) // 初始化 dp 表 dp := make([]int, cap+1) // 狀態轉移 for i := 1; i <= n; i++ { // 倒序走訪 for c := cap; c >= 1; c-- { if wgt[i-1] <= c { // 不選和選物品 i 這兩種方案的較大值 dp[c] = int(math.Max(float64(dp[c]), float64(dp[c-wgt[i-1]]+val[i-1]))) } } } return dp[cap] } ``` === "Swift" ```swift title="knapsack.swift" /* 0-1 背包：空間最佳化後的動態規劃 */ func knapsackDPComp(wgt: [Int], val: [Int], cap: Int) -> Int { let n = wgt.count // 初始化 dp 表 var dp = Array(repeating: 0, count: cap + 1) // 狀態轉移 for i in 1 ... n { // 倒序走訪 for c in (1 ... cap).reversed() { if wgt[i - 1] <= c { // 不選和選物品 i 這兩種方案的較大值 dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]) } } } return dp[cap] } ``` === "JS" ```javascript title="knapsack.js" /* 0-1 背包：狀態壓縮後的動態規劃 */ function knapsackDPComp(wgt, val, cap) { const n = wgt.length; // 初始化 dp 表 const dp = Array(cap + 1).fill(0); // 狀態轉移 for (let i = 1; i <= n; i++) { // 倒序走訪 for (let c = cap; c >= 1; c--) { if (wgt[i - 1] <= c) { // 不選和選物品 i 這兩種方案的較大值 dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]); } } } return dp[cap]; } ``` === "TS" ```typescript title="knapsack.ts" /* 0-1 背包：狀態壓縮後的動態規劃 */ function knapsackDPComp( wgt: Array, val: Array, cap: number ): number { const n = wgt.length; // 初始化 dp 表 const dp = Array(cap + 1).fill(0); // 狀態轉移 for (let i = 1; i <= n; i++) { // 倒序走訪 for (let c = cap; c >= 1; c--) { if (wgt[i - 1] <= c) { // 不選和選物品 i 這兩種方案的較大值 dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]); } } } return dp[cap]; } ``` === "Dart" ```dart title="knapsack.dart" /* 0-1 背包：空間最佳化後的動態規劃 */ int knapsackDPComp(List wgt, List val, int cap) { int n = wgt.length; // 初始化 dp 表 List dp = List.filled(cap + 1, 0); // 狀態轉移 for (int i = 1; i <= n; i++) { // 倒序走訪 for (int c = cap; c >= 1; c--) { if (wgt[i - 1] <= c) { // 不選和選物品 i 這兩種方案的較大值 dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]); } } } return dp[cap]; } ``` === "Rust" ```rust title="knapsack.rs" /* 0-1 背包：空間最佳化後的動態規劃 */ fn knapsack_dp_comp(wgt: &[i32], val: &[i32], cap: usize) -> i32 { let n = wgt.len(); // 初始化 dp 表 let mut dp = vec![0; cap + 1]; // 狀態轉移 for i in 1..=n { // 倒序走訪 for c in (1..=cap).rev() { if wgt[i - 1] <= c as i32 { // 不選和選物品 i 這兩種方案的較大值 dp[c] = std::cmp::max(dp[c], dp[c - wgt[i - 1] as usize] + val[i - 1]); } } } dp[cap] } ``` === "C" ```c title="knapsack.c" /* 0-1 背包：空間最佳化後的動態規劃 */ int knapsackDPComp(int wgt[], int val[], int cap, int wgtSize) { int n = wgtSize; // 初始化 dp 表 int *dp = calloc(cap + 1, sizeof(int)); // 狀態轉移 for (int i = 1; i <= n; i++) { // 倒序走訪 for (int c = cap; c >= 1; c--) { if (wgt[i - 1] <= c) { // 不選和選物品 i 這兩種方案的較大值 dp[c] = myMax(dp[c], dp[c - wgt[i - 1]] + val[i - 1]); } } } int res = dp[cap]; // 釋放記憶體 free(dp); return res; } ``` === "Kotlin" ```kotlin title="knapsack.kt" /* 0-1 背包：空間最佳化後的動態規劃 */ fun knapsackDPComp(wgt: IntArray, _val: IntArray, cap: Int): Int { val n = wgt.size // 初始化 dp 表 val dp = IntArray(cap + 1) // 狀態轉移 for (i in 1..n) { // 倒序走訪 for (c in cap downTo 1) { if (wgt[i - 1] <= c) { // 不選和選物品 i 這兩種方案的較大值 dp[c] = max(dp[c], dp[c - wgt[i - 1]] + _val[i - 1]) } } } return dp[cap] } ``` === "Ruby" ```ruby title="knapsack.rb" [class]{}-[func]{knapsack_dp_comp} ``` === "Zig" ```zig title="knapsack.zig" // 0-1 背包：空間最佳化後的動態規劃 fn knapsackDPComp(wgt: []i32, val: []i32, comptime cap: usize) i32 { var n = wgt.len; // 初始化 dp 表 var dp = [_]i32{0} ** (cap + 1); // 狀態轉移 for (1..n + 1) |i| { // 倒序走訪 var c = cap; while (c > 0) : (c -= 1) { if (wgt[i - 1] < c) { // 不選和選物品 i 這兩種方案的較大值 dp[c] = @max(dp[c], dp[c - @as(usize, @intCast(wgt[i - 1]))] + val[i - 1]); } } } return dp[cap]; } ``` ??? pythontutor "視覺化執行"

全螢幕觀看 >