leetcode/notes/src/knapsack.md

# 背包问题

有 `n` 件物品和一个最多能背重量为 `bagWeight` 的背包。

第 `i` 件物品的重量是 `weight[i]`，其价值是 `value[i]`，它们都是正整数。

每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。

- `dp[i][j]` 表示从下标为 `[0 - i]` 的物品里任意取，放进容量为 `j` 的背包，价值总和最大是多少。
- 递推公式：
  - 不放物品 `i`：`dp[i - 1][j]`
  - 放物品 `i`：`dp[i - 1][j - weight[i]] + value[i]`
  - 这两种情况选价值最大的那个，即 `dp[i][j] = max{dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]}`
- 初始化
  - `dp[i][0] = 0` 即当前背包能装的重量为 `0`，就是什么都装不下，当然价值为 `0`
  - `dp[0][j]`
    - `if (j < weight[0])`, `dp[0][j] = 0` 背包装不下第 `0` 个物品
    - `if (j >= weight[0])`, `dp[0][j] = value[0]` 背包能装下第 `0` 个物品
  - `i = 0` 和 `j = 0` 的情况都初始化完了，因此我们写双重循环的时候 `i` 和 `j` 应该从 `1` 开始。
- `i` 和 `j` 都从前往后遍历

```cpp
void bag_problem_2d() {
  vector<int> weight = {1, 3, 4};
  vector<int> value = {15, 20, 30};
  int bagWeight = 4;

  // 二维数组
  // 之所以初始化 j 的范围是 0 ~ bagWeight + 1 ，是因为我们会索引 dp[i][bagWeight]
  vector<vector<int>> dp(weight.size(), vector<int>(bagWeight + 1, 0));

  // 初始化
  for (int j = weight[0]; j <= bagWeight; j++) {
    dp[0][j] = value[0];
  }

  // 开始遍历
  for (int i = 1; i < weight.size(); i++) {  // 遍历物品
    for (int j = 1; j <= bagWeight; j++) {   // 遍历背包容量
      if (j < weight[i])
        dp[i][j] = dp[i - 1][j];
      else
        dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
    }
  }
}
```

接下来优化我们的代码。

注意到递推公式的右侧只用到了 `dp[i - 1]`，我们可以把它看成是 `dp[i]` 上一步的状态，因此每一次迭代的时候我们完全可以将 `dp[i - 1]` 覆盖到 `dp[i]`，这样可以将二维数组压缩到一维。

递推公式可以修改成：`dp[j] = max{dp[j], dp[j - weight[i]] + value[i]}`

这就是滚动数组的思路，当上一层可以重复利用的时候，我们直接把上一层拷贝到当前层。从递推公式来看，只要递推公式满足了右侧只用了 `dp[i - 1]` 那么就可以压缩。

来分析 DP 的思路：

- `dp[j]` 表示第 `i` 层容量为 `j` 的背包所能背的物品的最大价值。
- 递推公式：
  - `dp[j] = dp[j]`, `if j < weight[i]` 因为如果现在的物品重量比背包容量还大，那背包就装不下了，只能不装现在的这一个，那就是 `dp[i][j] = dp[i - 1][j]`，也就是 `dp[j] = dp[j]`
  - `dp[j] = max{dp[j], dp[j - weight[i]] + value[i]}`, `if j >= weight[i]` 这是能装下的情况
  - 总结一下就是只有当 `j >= weight[i]` 的时候我们才会调用第二个递推公式，否则 `dp[j]` 不变，于是我们可以将这一个放到第二层 for 循环里，第二层 for 循环的遍历范围是 `weight[i] <= j <= bagWeight`
- 由于滚动数组每次都会覆盖上一层，因此初始化的时候我们只需要将滚动数组作为二维数组的第一层初始化
  - `dp[j]` 当 `j >= weight[0]` 时应该为 `value[0]` 也就是能装下第 `0` 个物品，否则为 `0`
  - 如果初始化了 `i = 0` 的第一层的话，那么双重 for 循环就应该从 `1` 开始。
  - 当你实际写代码的时候会发现，双重 for 循环可以用来初始化 `i = 0` 的情况，因此我们只需要初始化 `dp[j] = 0`，然后 `i` 从 `0` 开始就行。
- 遍历顺序：
  - 物品 `i` 应该从前往后遍历
  - 但是背包重量 `j` 应该从后往前遍历

```cpp
void bag_problem_1d() {
  vector<int> weight = {1, 3, 4};
  vector<int> value = {15, 20, 30};
  int bagWeight = 4;

  // 初始化
  // 之所以初始化 j 的范围是 0 ~ bagWeight + 1 ，是因为我们会索引 dp[bagWeight]
  vector<int> dp(bagWeight + 1, 0);
  for (int i = 0; i < weight.size(); i++) {         // 遍历物品
    for (int j = bagWeight; j >= weight[i]; j--) {  // 遍历背包容量
      dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
    }
  }
}
```

**Q: 能不能先遍历容量，再遍历物品？**

**A:** 不行，因为我们本来就是要用上一层的 `i - 1` 来覆盖这一层的 `i`。

**Q: 为啥二维不用从后往前呢？**

**A:** 因为 `dp[i][j]` 都是通过上一层即 `dp[i - 1][j]` 计算而来，本层的 `dp[i][j]` 并不会被覆盖。

**Q: 一维从后往前的本质是什么？**

**A:** 如果从后往前的话，`dp[j - weight[i]] + value[i]` 就用的是上一层的数据（这才是我们想要的），但如果从前往后的话，`dp[j - weight[i]] + value[i]` 就用的是这一层的数据，这将会导致物品被重复放进去。

## [416. 分割等和子集](https://leetcode.cn/problems/partition-equal-subset-sum/)

二维数组：

- `dp[i][j]` 表示是否可以从 0 ~ i 选取一些元素，使得总和等于 j
- 递推公式为：
  - `dp[i][j] = dp[i - 1][j] || dp[i - 1][j - nums[i]]`, `j >= nums[i]`
  - `dp[i][j] = dp[i - 1][j]`, `j < nums[i]`
- 初始化：
  - `dp[0][j] = (j == nums[0])`
  - `dp[i][0] = false`
- `i` 和 `j` 都从前往后

滚动数组：

- `dp[j]` 表示是否可以从 0 ~ i 选取一些元素，使得总和等于 j
- 递推公式为：
  - `dp[j] = dp[j] || dp[j - nums[i]]`, `j >= nums[i]`
  - `dp[j] = dp[j]`, `j < nums[i]`
  - 因此第二层 for 循环的范围可以直接定成 `nums[i] <= j <= target`，然后调用第一个递推公式
- 初始化：
  - `dp[j] = (j == nums[0])` 这是第一层也就是 `i == 0` 的情况
  - 这种情况可以写成默认初始化为 `false`，而 `dp[nums[0]] = true`
- 遍历顺序：
  - `i` 从前往后，范围是 `1 <= i < length`
  - `j` 从后往前，范围是 `nums[i] <= j <= target`

本题中可以不初始化第一层，然后 `i` 从 0 开始。

## [1049. 最后一块石头的重量 II](https://leetcode.cn/problems/last-stone-weight-ii/)

仔细思考一下每个石头重量的加减方式，你会发现其实最终的重量可以这样表示：

`final = k0 * w0 + k1 * w1 + k2 * w2 + ...`

其中 `ki` 为 `+1` 或 `-1`，`wi` 为第 `i` 个石头的重量。

那么 `ki` 取负的所有石头重量之和我们表示为 `neg`，其它石头重量之和为 `total - neg`。

我们的目的就是要在 `neg <= total/2` 的前提下，让 `neg` 达到最大。

这就是一个 01 背包问题。

- `i` 对应石头下标，每个石头的重量为 `stones[i]`，价值为 `stones[i]`
- `j` 对应背包容量，最大为 `total/2`

我们直接上滚动数组：

- `dp[j]` 表示从 0 ~ i 中选石头，放进容量为 `j` 的背包，所能达到的最大价值
- 迭代公式：
  - `if (j < stones[i]) dp[j] = dp[j]`
  - `if (j >= stones[i]) dp[j] = max{dp[j], dp[j - stones[i]] + stones[i]}`
  - 第二层迭代的范围是 `stones[i] ~ total/2`
- 初始化：
  - `if (j < stones[0]) dp[j] = 0`
  - `if (j >= stones[0]) dp[j] = stones[0]`
- 遍历：
  - `i` 从 1 到 length - 1
  - `j` 从 `total/2` 向下取整，遍历到 `stones[i]`

本题中可以不初始化第一层，然后 `i` 从 0 开始。