背包问题是一个非常好的动态规划入门题目，是动态规划中最常见的问题形式。其具有很多变种，例如 0-1 背包问题、完全背包问题、多重背包问题等。
在本节中，我们先来求解最常见的 0-1 背包问题。
!!! question
给定 $n$ 个物品，第 $i$ 个物品的重量为 $wgt[i-1]$、价值为 $val[i-1]$ ，和一个容量为 $cap$ 的背包。每个物品只能选择一次，问在不超过背包容量下能放入物品的最大价值。
观察下图，由于物品编号 i i i 从 1 1 1 开始计数，数组索引从 0 0 0 开始计数，因此物品 i i i 对应重量 w g t [ i − 1 ] wgt[i-1] wgt[i−1] 和价值 v a l [ i − 1 ] val[i-1] val[i−1] 。
我们可以将 0-1 背包问题看作是一个由 n n n 轮决策组成的过程，每个物体都有不放入和放入两种决策，因此该问题是满足决策树模型的。
该问题的目标是求解“在限定背包容量下的最大价值”，因此较大概率是个动态规划问题。
第一步：思考每轮的决策，定义状态，从而得到 d p dp dp 表
对于每个物品来说，不放入背包，背包容量不变；放入背包，背包容量减小。由此可得状态定义：当前物品编号 i i i 和剩余背包容量 c c c ，记为 [ i , c ] [i, c] [i,c] 。
状态 [ i , c ] [i, c] [i,c] 对应的子问题为：前 i i i 个物品在剩余容量为 c c c 的背包中的最大价值，记为 d p [ i , c ] dp[i, c] dp[i,c] 。
待求解的是 d p [ n , c a p ] dp[n, cap] dp[n,cap] ，因此需要一个尺寸为 ( n + 1 ) × ( c a p + 1 ) (n+1) \times (cap+1) (n+1)×(cap+1) 的二维 d p dp dp 表。
第二步：找出最优子结构，进而推导出状态转移方程
当我们做出物品 i i i 的决策后，剩余的是前 i − 1 i-1 i−1 个物品的决策，可分为以下两种情况。
- 不放入物品 i i i ：背包容量不变，状态变化为 [ i − 1 , c ] [i-1, c] [i−1,c] 。
- 放入物品 i i i ：背包容量减小 w g t [ i − 1 ] wgt[i-1] wgt[i−1] ，价值增加 v a l [ i − 1 ] val[i-1] val[i−1] ，状态变化为 [ i − 1 , c − w g t [ i − 1 ] ] [i-1, c-wgt[i-1]] [i−1,c−wgt[i−1]] 。
上述分析向我们揭示了本题的最优子结构：最大价值 d p [ i , c ] dp[i, c] dp[i,c] 等于不放入物品 i i i 和放入物品 i i i 两种方案中的价值更大的那一个。由此可推出状态转移方程：
d p [ i , c ] = max ( d p [ i − 1 , c ] , d p [ i − 1 , c − w g t [ i − 1 ] ] + v a l [ i − 1 ] ) dp[i, c] = \max(dp[i-1, c], dp[i-1, c - wgt[i-1]] + val[i-1]) dp[i,c]=max(dp[i−1,c],dp[i−1,c−wgt[i−1]]+val[i−1])
需要注意的是，若当前物品重量 w g t [ i − 1 ] wgt[i - 1] wgt[i−1] 超出剩余背包容量 c c c ，则只能选择不放入背包。
第三步：确定边界条件和状态转移顺序
当无物品或无剩余背包容量时最大价值为 0 0 0 ，即首列 d p [ i , 0 ] dp[i, 0] dp[i,0] 和首行 d p [ 0 , c ] dp[0, c] dp[0,c] 都等于 0 0 0 。
当前状态 [ i , c ] [i, c] [i,c] 从上方的状态 [ i − 1 , c ] [i-1, c] [i−1,c] 和左上方的状态 [ i − 1 , c − w g t [ i − 1 ] ] [i-1, c-wgt[i-1]] [i−1,c−wgt[i−1]] 转移而来，因此通过两层循环正序遍历整个 d p dp dp 表即可。
根据以上分析，我们接下来按顺序实现暴力搜索、记忆化搜索、动态规划解法。
方法一：暴力搜索
搜索代码包含以下要素。
- 递归参数：状态 [ i , c ] [i, c] [i,c] 。
- 返回值：子问题的解 d p [ i , c ] dp[i, c] dp[i,c] 。
- 终止条件：当物品编号越界 i = 0 i = 0 i=0 或背包剩余容量为 0 0 0 时，终止递归并返回价值 0 0 0 。
- 剪枝：若当前物品重量超出背包剩余容量，则只能不放入背包。
=== “Python”
```python title="knapsack.py"
[class]{}-[func]{knapsack_dfs}
```
=== “C++”
```cpp title="knapsack.cpp"
[class]{}-[func]{knapsackDFS}
```
=== “Java”
```java title="knapsack.java"
[class]{knapsack}-[func]{knapsackDFS}
```
=== “C#”
```csharp title="knapsack.cs"
[class]{knapsack}-[func]{knapsackDFS}
```
=== “Go”
```go title="knapsack.go"
[class]{}-[func]{knapsackDFS}
```
=== “Swift”
```swift title="knapsack.swift"
[class]{}-[func]{knapsackDFS}
```
=== “JS”
```javascript title="knapsack.js"
[class]{}-[func]{knapsackDFS}
```
=== “TS”
```typescript title="knapsack.ts"
[class]{}-[func]{knapsackDFS}
```
=== “Dart”
```dart title="knapsack.dart"
[class]{}-[func]{knapsackDFS}
```
=== “Rust”
```rust title="knapsack.rs"
[class]{}-[func]{knapsack_dfs}
```
=== “C”
```c title="knapsack.c"
[class]{}-[func]{knapsackDFS}
```
=== “Zig”
```zig title="knapsack.zig"
[class]{}-[func]{knapsackDFS}
```
如下图所示，由于每个物品都会产生不选和选两条搜索分支，因此时间复杂度为 O ( 2 n ) O(2^n) O(2n) 。
观察递归树，容易发现其中存在重叠子问题，例如 d p [ 1 , 10 ] dp[1, 10] dp[1,10] 等。而当物品较多、背包容量较大，尤其是相同重量的物品较多时，重叠子问题的数量将会大幅增多。
方法二：记忆化搜索
为了保证重叠子问题只被计算一次，我们借助记忆列表 mem 来记录子问题的解，其中 mem[i][c] 对应 d p [ i , c ] dp[i, c] dp[i,c] 。
引入记忆化之后，时间复杂度取决于子问题数量，也就是 O ( n × c a p ) O(n \times cap) O(n×cap) 。
=== “Python”
```python title="knapsack.py"
[class]{}-[func]{knapsack_dfs_mem}
```
=== “C++”
```cpp title="knapsack.cpp"
[class]{}-[func]{knapsackDFSMem}
```
=== “Java”
```java title="knapsack.java"
[class]{knapsack}-[func]{knapsackDFSMem}
```
=== “C#”
```csharp title="knapsack.cs"
[class]{knapsack}-[func]{knapsackDFSMem}
```
=== “Go”
```go title="knapsack.go"
[class]{}-[func]{knapsackDFSMem}
```
=== “Swift”
```swift title="knapsack.swift"
[class]{}-[func]{knapsackDFSMem}
```
=== “JS”
```javascript title="knapsack.js"
[class]{}-[func]{knapsackDFSMem}
```
=== “TS”
```typescript title="knapsack.ts"
[class]{}-[func]{knapsackDFSMem}
```
=== “Dart”
```dart title="knapsack.dart"
[class]{}-[func]{knapsackDFSMem}
```
=== “Rust”
```rust title="knapsack.rs"
[class]{}-[func]{knapsack_dfs_mem}
```
=== “C”
```c title="knapsack.c"
[class]{}-[func]{knapsackDFSMem}
```
=== “Zig”
```zig title="knapsack.zig"
[class]{}-[func]{knapsackDFSMem}
```
下图展示了在记忆化递归中被剪掉的搜索分支。
方法三：动态规划
动态规划实质上就是在状态转移中填充 d p dp dp 表的过程，代码如下所示。
=== “Python”
```python title="knapsack.py"
[class]{}-[func]{knapsack_dp}
```
=== “C++”
```cpp title="knapsack.cpp"
[class]{}-[func]{knapsackDP}
```
=== “Java”
```java title="knapsack.java"
[class]{knapsack}-[func]{knapsackDP}
```
=== “C#”
```csharp title="knapsack.cs"
[class]{knapsack}-[func]{knapsackDP}
```
=== “Go”
```go title="knapsack.go"
[class]{}-[func]{knapsackDP}
```
=== “Swift”
```swift title="knapsack.swift"
[class]{}-[func]{knapsackDP}
```
=== “JS”
```javascript title="knapsack.js"
[class]{}-[func]{knapsackDP}
```
=== “TS”
```typescript title="knapsack.ts"
[class]{}-[func]{knapsackDP}
```
=== “Dart”
```dart title="knapsack.dart"
[class]{}-[func]{knapsackDP}
```
=== “Rust”
```rust title="knapsack.rs"
[class]{}-[func]{knapsack_dp}
```
=== “C”
```c title="knapsack.c"
[class]{}-[func]{knapsackDP}
```
=== “Zig”
```zig title="knapsack.zig"
[class]{}-[func]{knapsackDP}
```
如下图所示，时间复杂度和空间复杂度都由数组 dp 大小决定，即 O ( n × c a p ) O(n \times cap) O(n×cap) 。
=== “<1>”
=== “<2>”
=== “<3>”
=== “<4>”
=== “<5>”
=== “<6>”
=== “<7>”
=== “<8>”
=== “<9>”
=== “<10>”
=== “<11>”
=== “<12>”
=== “<13>”
=== “<14>”
空间优化
由于每个状态都只与其上一行的状态有关，因此我们可以使用两个数组滚动前进，将空间复杂度从 O ( n 2 ) O(n^2) O(n2) 将低至 O ( n ) O(n) O(n) 。
进一步思考，我们是否可以仅用一个数组实现空间优化呢？观察可知，每个状态都是由正上方或左上方的格子转移过来的。假设只有一个数组，当开始遍历第 i i i 行时，该数组存储的仍然是第 i − 1 i-1 i−1 行的状态。
- 如果采取正序遍历，那么遍历到 d p [ i , j ] dp[i, j] dp[i,j] 时，左上方 d p [ i − 1 , 1 ] dp[i-1, 1] dp[i−1,1] ~ d p [ i − 1 , j − 1 ] dp[i-1, j-1] dp[i−1,j−1] 值可能已经被覆盖，此时就无法得到正确的状态转移结果。
- 如果采取倒序遍历，则不会发生覆盖问题，状态转移可以正确进行。
下图展示了在单个数组下从第 i = 1 i = 1 i=1 行转换至第 i = 2 i = 2 i=2 行的过程。请思考正序遍历和倒序遍历的区别。
=== “<1>”
=== “<2>”
=== “<3>”
=== “<4>”
=== “<5>”
=== “<6>”
在代码实现中，我们仅需将数组 dp 的第一维 i i i 直接删除，并且把内循环更改为倒序遍历即可。
=== “Python”
```python title="knapsack.py"
[class]{}-[func]{knapsack_dp_comp}
```
=== “C++”
```cpp title="knapsack.cpp"
[class]{}-[func]{knapsackDPComp}
```
=== “Java”
```java title="knapsack.java"
[class]{knapsack}-[func]{knapsackDPComp}
```
=== “C#”
```csharp title="knapsack.cs"
[class]{knapsack}-[func]{knapsackDPComp}
```
=== “Go”
```go title="knapsack.go"
[class]{}-[func]{knapsackDPComp}
```
=== “Swift”
```swift title="knapsack.swift"
[class]{}-[func]{knapsackDPComp}
```
=== “JS”
```javascript title="knapsack.js"
[class]{}-[func]{knapsackDPComp}
```
=== “TS”
```typescript title="knapsack.ts"
[class]{}-[func]{knapsackDPComp}
```
=== “Dart”
```dart title="knapsack.dart"
[class]{}-[func]{knapsackDPComp}
```
=== “Rust”
```rust title="knapsack.rs"
[class]{}-[func]{knapsack_dp_comp}
```
=== “C”
```c title="knapsack.c"
[class]{}-[func]{knapsackDPComp}
```
=== “Zig”
```zig title="knapsack.zig"
[class]{}-[func]{knapsackDPComp}
```