专题八：01背包问题01背包是背包问题中最简单的问题。01背包的约束条件是给定几种物品，每种物品有且只有一个，并且有权值

0 背包问题概述

背包问题 (Knapsack problem) 是⼀种组合优化的 NP完全问题。

问题可以描述为：给定⼀组物品，每种物品都有⾃⼰的重量和价格，在限定的总重量内，我们如何选择，才能使得物品的总价格最⾼。

根据物品的个数，分为如下⼏类：

- 01 背包问题：每个物品只有⼀个
- 完全背包问题：每个物品有⽆限多个
- 多重背包问题：每件物品最多有 si 个
- 混合背包问题：每个物品会有上⾯三种情况......
- 分组背包问题：物品有 n 组，每组物品⾥有若⼲个，每组⾥最多选⼀个物品

其中上述分类⾥⾯，根据背包是否装满，⼜分为两类：

- 不⼀定装满背包
- 背包⼀定装满

优化⽅案：

- 空间优化 - 滚动数组
- 单调队列优化
- 贪⼼优化

根据限定条件的个数，⼜分为两类：

- 限定条件只有⼀个：⽐如体积 -> 普通的背包问题
- 限定条件有两个：⽐如体积 + 重量 -> ⼆维费⽤背包问题

根据不同的问法，⼜分为很多类：

- 输出⽅案
- 求⽅案总数
- 最优⽅案
- ⽅案可⾏性

其实还有很多分类，但是我们仅需了解即可。

因此，背包问题种类⾮常繁多，题型⾮常丰富，难度也是⾮常难以捉摸。但是，尽管种类⾮常多，都是从 01 背包问题演化过来的。所以，⼀定要把 01 背包问题学好。

1 【模板】01背包

1.1 题目链接

DP41 【模板】01背包

1.2 题目描述

1.3 解法（动态规划）

算法思路：

我们先解决第⼀问：

状态表⽰：

dp[i][j] 表⽰：从前 i 个物品中挑选，总体积「不超过」 j ，所有的选法中，能挑选出来的最⼤价值。
状态转移⽅程：
- 线性 dp 状态转移⽅程分析⽅式，⼀般都是根据「最后⼀步」的状况，来分情况讨论：
  - i. 不选第 i 个物品：相当于就是去前 i - 1 个物品中挑选，并且总体积不超过 j 。此时 dp[i][j] = dp[i - 1][j] ；
  - ii. 选择第 i 个物品：那么我就只能去前 i - 1 个物品中，挑选总体积不超过 j - v[i]的物品。此时 dp[i][j] = dp[i - 1][j - v[i]] + w[i] 。但是这种状态不⼀定存在，因此需要特判⼀下。
- 综上，状态转移⽅程为： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - v[i]] +w[i]) 。
初始化：

我们多加⼀⾏，⽅便我们的初始化，此时仅需将第⼀⾏初始化为 0 即可。因为什么也不选，也能满⾜体积不⼩于 j 的情况，此时的价值为 0 。
填表顺序：

根据「状态转移⽅程」，我们仅需「从上往下」填表即可。
返回值：

根据「状态表⽰」，返回 dp[n][V] 。

接下来解决第⼆问：

第⼆问仅需微调⼀下 dp 过程的五步即可。

因为有可能凑不⻬ j 体积的物品，因此我们把不合法的状态设置为 -1 。

状态表⽰：

dp[i][j] 表⽰：从前 i 个物品中挑选，总体积「正好」等于 j ，所有的选法中，能挑选出来的最⼤价值。
状态转移⽅程：

dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - v[i]] + w[i]) 。

但是在使⽤ dp[i - 1][j - v[i]] 的时候，不仅要判断 j >= v[i] ，⼜要判断 dp[i - 1][j - v[i]] 表⽰的情况是否存在，也就是 dp[i - 1][j - v[i]] != -1 。
初始化：
- 我们多加⼀⾏，⽅便我们的初始化：
  - i. 第⼀个格⼦为 0 ，因为正好能凑⻬体积为 0 的背包；
  - ii. 但是第⼀⾏后⾯的格⼦都是 -1 ，因为没有物品，⽆法满⾜体积⼤于 0 的情况。
填表顺序：

根据「状态转移⽅程」，我们仅需「从上往下」填表即可。
返回值：

由于最后可能凑不成体积为 V 的情况，因此返回之前需要「特判」⼀下。

空间优化：

背包问题基本上都是利⽤「滚动数组」来做空间上的优化：
- i. 利⽤「滚动数组」优化；
- ii. 直接在「原始代码」上修改。
在01背包问题中，优化的结果为：
- i. 删掉所有的横坐标；
- ii. 修改⼀下 j 的遍历顺序。

1.4 C++算法代码：

优化前的算法代码：

#include <iostream>
#include <string.h>
using namespace std;

const int N = 1001;
int n, V, v[N], w[N];
int dp[N][N];

int main()
{
    // 读入数据  背包可容纳物品个数n 体积V
    cin >> n >> V;
    // 依次读入  物品所需体积v[i] 价值w[i]
    for(int i = 1; i <= n; i++)
        cin >> v[i] >> w[i];
    
    // 第一问
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= V; j++)
        {
            dp[i][j] = dp[i - 1][j];
            if(j >= v[i])
                dp[i][j] = max(dp[i][j], dp[i - 1][j - v[i]] + w[i]);
        }
    }
    cout << dp[n][V] <<endl;

    // 第二问
    memset(dp, 0, sizeof(dp));
    for(int j = 1; j <= V; j++) dp[0][j] = -1;
    for(int i = 1; i <= n; i++)
    {
        for(int j = 0; j <= V; j++)
        {
            dp[i][j] = dp[i - 1][j];
            if(j >= v[i] && dp[i - 1][j - v[i]] != -1)
                dp[i][j] = max(dp[i][j], dp[i - 1][j - v[i]] + w[i]);
        }
    }
    cout << (dp[n][V] == -1 ? 0 : dp[n][V]);
    return 0;
}

优化后的算法代码：

#include <iostream>
#include <string.h>
using namespace std;

const int N = 1001;
int n, V, v[N], w[N];
int dp[N];

int main()
{
    // 读入数据  背包可容纳物品个数n 体积V
    cin >> n >> V;
    // 依次读入  物品所需体积v[i] 价值w[i]
    for(int i = 1; i <= n; i++)
        cin >> v[i] >> w[i];
    
    // 第一问
    for(int i = 1; i <= n; i++)
        for(int j = V; j >= 0; j--)
            if(j >= v[i])
                dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
   
    cout << dp[V] <<endl;

    // 第二问
    memset(dp, 0, sizeof(dp));
    for(int j = 1; j <= V; j++) dp[j] = -1;
    for(int i = 1; i <= n; i++)
        for(int j = V; j >= 0; j--)
            if(j >= v[i] && dp[j - v[i]] != -1)
                dp[j] = max(dp[j], dp[j - v[i]] + w[i]);

    cout << (dp[V] == -1 ? 0 : dp[V]) << endl;
    return 0;
}

2 分割等和子集

2.1 题目链接

416. 分割等和子集

2.2 题目描述

给你一个 只包含正整数 的非空数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

示例 1：

输入： nums = [1,5,11,5]
输出： true
解释： 数组可以分割成 [1, 5, 5] 和 [11] 。

示例 2：

输入： nums = [1,2,3,5]
输出： false
解释： 数组不能分割成两个元素和相等的子集。

提示：

1 <= nums.length <= 200
1 <= nums[i] <= 100

2.3 解法（动态规划）

算法思路：

先将问题转化成我们「熟悉」的题型。
- 如果数组能够被分成两个相同元素之和相同的⼦集，那么原数组必须有下⾯⼏个性质：
  - i. 所有元素之和应该是⼀个偶数；
  - ii. 数组中最⼤的元素应该⼩于所有元素总和的⼀半；
  - iii. 挑选⼀些数，这些数的总和应该等于数组总和的⼀半。
- 根据前两个性质，我们可以提前判断数组能够被划分。根据最后⼀个性质，我们发现问题就转化成了「01 背包」的模型：
  - i. 数组中的元素只能选择⼀次；
  - ii. 每个元素⾯临被选择或者不被选择的处境；
  - iii. 选出来的元素总和要等于所有元素总和的⼀半。
- 其中，数组内的元素就是物品，总和就是背包。
那么我们就可以⽤背包模型的分析⽅式，来处理这道题。

请⼤家注意，「不要背」状态转移⽅程，因为题型变化之后，状态转移⽅程就会跟着变化。我们要记住的是分析问题的模式。⽤这种分析问题的模式来解决问题。

状态表⽰：

dp[i][j] 表⽰在前 i 个元素中选择，所有的选法中，能否凑成总和为 j 这个数。
状态转移⽅程：
- ⽼规矩，根据「最后⼀个位置」的元素，结合题⽬的要求，分情况讨论：
  - i. 不选择 nums[i] ：那么我们是否能够凑成总和为 j ，就要看在前 i - 1 个元素中选，能否凑成总和为 j 。根据状态表⽰，此时 dp[i][j] = dp[i - 1][j] ；
  - ii. 选择 nums[i] ：这种情况下是有前提条件的，此时的 nums[i] 应该是⼩于等于 j 。
    - 因为如果这个元素都⽐要凑成的总和⼤，选择它就没有意义呀。那么我们是否能够凑成总和为 j ，就要看在前 i - 1 个元素中选，能否凑成总和为 j - nums[i] 。根据状态表⽰，此时 dp[i][j] = dp[i - 1][j - nums[i]] 。
- 综上所述，两种情况下只要有⼀种能够凑成总和为 j ，那么这个状态就是 true 。因此，状态转移⽅程为：
  - dp[i][j] = dp[i - 1][j]
  - if(nums[i - 1] <= j) dp[i][j] = dp[i][j] || dp[i - 1][j - nums[i]]
初始化：
- 由于需要⽤到上⼀⾏的数据，因此我们可以先把第⼀⾏初始化。
- 第⼀⾏表⽰不选择任何元素，要凑成⽬标和 j 。只有当⽬标和为 0 的时候才能做到，因此第⼀⾏仅需初始化第⼀个元素 dp[0][0] = true
填表顺序：

根据「状态转移⽅程」，我们需要「从上往下」填写每⼀⾏，每⼀⾏的顺序是「⽆所谓的」。
返回值：
- 根据「状态表⽰」，返回 dp[n][aim] 的值。
- 其中 n 表⽰数组的⼤⼩， aim 表⽰要凑的⽬标和。
空间优化：

所有的「背包问题」，都可以进⾏空间上的优化。
对于 01背包类型的，我们的优化策略是：
- i. 删掉第⼀维；
- ii. 修改第⼆层循环的遍历顺序即可。

2.4 C++算法代码：

优化前的算法代码:

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int n = nums.size(), sum =0;
        for(int e : nums) sum += e;
        if(sum % 2) return false;
        int aim = sum / 2;
        vector<vector<bool>> dp(n + 1, vector<bool>(aim + 1));
        for(int i = 0; i <= n; i++) dp[i][0] = true;
        for(int i = 1; i <= n; i++)
        {
            for(int j = 1; j <= aim; j++)
            {
                dp[i][j] = dp[i - 1][j];
                if(j >= nums[i - 1])
                    dp[i][j] = dp[i][j] || dp[i - 1][j - nums[i - 1]];
            }
        }
        return dp[n][aim];
    }
};

空间优化后的算法代码：

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int n = nums.size(), sum =0;
        for(int e : nums) sum += e;
        if(sum % 2) return false;
        int aim = sum / 2;
        vector<bool>dp (aim + 1);
        dp[0] = true;
        for(int i = 1; i <= n; i++)
            for(int j = aim; j >= nums[i - 1]; j--)
                    dp[j] = dp[j] || dp[j - nums[i - 1]];
        return dp[aim];
    }
};

3 目标和

3.1 题目链接

494. 目标和

3.2 题目描述

给你一个非负整数数组 nums 和一个整数 target 。

向数组中的每个整数前添加 '+' 或 '-' ，然后串联起所有整数，可以构造一个 表达式 ：

例如，nums = [2, 1] ，可以在 2 之前添加 '+' ，在 1 之前添加 '-' ，然后串联起来得到表达式 "+2-1" 。

返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。

示例 1：

输入： nums = [1,1,1,1,1], target = 3
输出： 5
解释： 一共有 5 种方法让最终目标和为 3 。
-1 + 1 + 1 + 1 + 1 = 3
+1 - 1 + 1 + 1 + 1 = 3
+1 + 1 - 1 + 1 + 1 = 3
+1 + 1 + 1 - 1 + 1 = 3
+1 + 1 + 1 + 1 - 1 = 3

示例 2：

输入： nums = [1], target = 1
输出： 1

3.3 解法（动态规划）

算法思路：

本题可以直接⽤「暴搜」的⽅法解决。但是稍微⽤数学知识分析⼀下，就能转化成我们常⻅的「背包模型」的问题。
设我们最终选取的结果中，前⾯加 + 号的数字之和为 a ，前⾯加 - 号的数字之和为 b ，整个数组的总和为 sum ，于是我们有：
- a + b = sum
- a - b = target
上⾯两个式⼦消去 b 之后，可以得到 a = (sum + target) / 2
也就是说，我们仅需在 nums 数组中选择⼀些数，将它们凑成和为 (sum + target) / 2 即可。
问题就变成了 416. 分割等和⼦集这道题。
我们可以⽤相同的分析模式，来处理这道题。

状态表⽰：

dp[i][j] 表⽰：在前 i 个数中选，总和正好等于 j ，⼀共有多少种选法。
状态转移⽅程：
- ⽼规矩，根据「最后⼀个位置」的元素，结合题⽬的要求，我们有「选择」最后⼀个元素或者「不选择」最后⼀个元素两种策略：
  - i. 不选 nums[i] ：那么我们凑成总和 j 的总⽅案，就要看在前 i - 1 个元素中选，凑成总和为 j 的⽅案数。根据状态表⽰，此时 dp[i][j] = dp[i - 1][j] ；
  - ii. 选择 nums[i] ：这种情况下是有前提条件的，此时的 nums[i] 应该是⼩于等于 j 。
    - 因为如果这个元素都⽐要凑成的总和⼤，选择它就没有意义呀。那么我们能够凑成总和为 j 的⽅案数，就要看在前 i - 1 个元素中选，能否凑成总和为 j - nums[i] 。根据状态表⽰，此时 dp[i][j] = dp[i - 1][j - nums[i]]
- 综上所述，两种情况如果存在的话，应该要累加在⼀起。因此，状态转移⽅程为：
  - dp[i][j] = dp[i - 1][j]
  - if(nums[i - 1] <= j) dp[i][j] = dp[i][j] += dp[i - 1][j - nums[i - 1]]
初始化：
- 由于需要⽤到「上⼀⾏」的数据，因此我们可以先把第⼀⾏初始化。
- 第⼀⾏表⽰不选择任何元素，要凑成⽬标和 j 。只有当⽬标和为 0 的时候才能做到，因此第⼀⾏仅需初始化第⼀个元素 dp[0][0] = 1
填表顺序：

根据「状态转移⽅程」，我们需要「从上往下」填写每⼀⾏，每⼀⾏的顺序是「⽆所谓的」。
返回值：
- 根据「状态表⽰」，返回 dp[n][aim] 的值。
- 其中 n 表⽰数组的⼤⼩， aim 表⽰要凑的⽬标和。
空间优化：

所有的「背包问题」，都可以进⾏空间上的优化。
对于 01背包类型的，我们的优化策略是：
- i. 删掉第⼀维；
- ii. 修改第⼆层循环的遍历顺序即可。

3.4 C++算法代码：

优化前的算法代码：

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int sum = 0;
        for(int e : nums) sum += e;
        int aim = (sum + target) / 2;

        if(aim < 0 || (sum + target) % 2) return 0;
        int n = nums.size();
        vector<vector<int>> dp(n + 1, vector<int>(aim + 1));
        dp[0][0] = 1;
        for(int i = 1; i <= n; i++)
        {
            for(int j = 0; j <= aim; j++)
            {
                dp[i][j] = dp[i - 1][j];
                if(j >= nums[i - 1]) dp[i][j] += dp[i - 1][j - nums[i - 1]];
            }
        }
        return dp[n][aim];
    }
};

空间优化后的算法代码：

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int sum = 0;
        for(int e : nums) sum += e;
        int aim = (sum + target) / 2;

        if(aim < 0 || (sum + target) % 2) return 0;
        int n = nums.size();
        vector<int> dp (aim + 1);
        dp[0] = 1;
        for(int i = 1; i <= n; i++)
            for(int j = aim; j >= nums[i - 1]; j--)
                if(j >= nums[i - 1]) dp[j] += dp[j - nums[i - 1]];
        return dp[aim];
    }
};

4 最后一块石头的重量 II

4.1 题目链接

1049. 最后一块石头的重量 II

4.2 题目描述

有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。

每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：

如果 x == y，那么两块石头都会被完全粉碎；
如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。

最后，最多只会剩下一块 石头。返回此石头 最小的可能重量 。如果没有石头剩下，就返回 0。

示例 1：

输入： stones = [2,7,4,1,8,1]
输出： 1
解释：
组合 2 和 4，得到 2，所以数组转化为 [2,7,1,8,1]，
组合 7 和 8，得到 1，所以数组转化为 [2,1,1,1]，
组合 2 和 1，得到 1，所以数组转化为 [1,1,1]，
组合 1 和 1，得到 0，所以数组转化为 [1]，这就是最优值。

示例 2：

输入： stones = [31,26,33,21,40]
输出： 5

提示：

1 <= stones.length <= 30
1 <= stones[i] <= 100

4.3 解法（动态规划）

算法思路：

先将问题「转化」成我们熟悉的题型。
- 任意两块⽯头在⼀起粉碎，重量相同的部分会被丢掉，重量有差异的部分会被留下来。那就相当于在原始的数据的前⾯，加上「加号」或者「减号」，是最终的结果最⼩即可。也就是说把原始的⽯头分成两部分，两部分的和越接近越好。
- ⼜因为当所有元素的和固定时，分成的两部分越接近数组「总和的⼀半」，两者的差越⼩。
因此问题就变成了：在数组中选择⼀些数，让这些数的和尽量接近 sum / 2 ，如果把数看成物品，每个数的值看成体积和价值，问题就变成了「01 背包问题」。

状态表⽰：

dp[i][j] 表⽰在前 i 个元素中选择，总和不超过 j，此时所有元素的「最⼤和」。
状态转移⽅程：
- ⽼规矩，根据「最后⼀个位置」的元素，结合题⽬的要求，分情况讨论：
  - i. 不选 stones[i] ：那么我们是否能够凑成总和为 j ，就要看在前 i - 1 个元素中选，能否凑成总和为 j 。根据状态表⽰，此时 dp[i][j] = dp[i - 1][j] ；
  - ii. 选择 stones[i] ：这种情况下是有前提条件的，此时的 stones[i] 应该是⼩于等于j 。因为如果这个元素都⽐要凑成的总和⼤，选择它就没有意义呀。那么我们是否能够凑成总和为 j ，就要看在前 i - 1 个元素中选，能否凑成总和为 j - stones[i] 。根据状态表⽰，此时 dp[i][j] = dp[i - 1][j - stones[i]] + stones[i] 。
- 综上所述，我们要的是最⼤价值。因此，状态转移⽅程为：
  - dp[i][j] = dp[i - 1][j]
  - if(j >= stones[i]) dp[i][j] = dp[i][j] + dp[i - 1][j - stones[i]] + stones[i] 。
初始化：
- 由于需要⽤到上⼀⾏的数据，因此我们可以先把第⼀⾏初始化。
- 第⼀⾏表⽰「没有⽯⼦」。因此想凑成⽬标和 j ，最⼤和都是 0 。
填表顺序：

根据「状态转移⽅程」，我们需要「从上往下」填写每⼀⾏，每⼀⾏的顺序是「⽆所谓的」。
返回值：
- a. 根据「状态表⽰」，先找到最接近 sum / 2 的最⼤和 dp[n][sum / 2] ；
- b. 因为我们要的是两堆⽯⼦的差，因此返回 sum - 2 * dp[n][sum / 2] 。
空间优化：
- 所有的背包问题，都可以进⾏「空间」上的优化。
- 对于 01背包类型的，我们的优化策略是：
  - i. 删掉第⼀维；
  - ii. 修改第⼆层循环的「遍历顺序」即可。

4.4 C++算法代码：

优化前的算法代码：

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        int sum = 0;
        for(int e : stones) sum += e;
        int n = stones.size(), m = sum / 2;
        vector<vector<int>> dp(n + 1, vector<int>(m + 1));
        for(int i = 1; i <= n; i++)
        {
            for(int j = 0; j <= m; j++)
            {
                dp[i][j] = dp[i - 1][j];
                if(j >= stones[i - 1]) dp[i][j] = max(dp[i][j], dp[i- 1][j - stones[i - 1]] + stones[i - 1]);
            }
        }
        return sum - 2 * dp[n][m];
    }
};

空间优化后的算法代码:

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        int sum = 0;
        for(int e : stones) sum += e;
        int n = stones.size(), m = sum / 2;
        vector<int> dp (m + 1);
        for(int i = 1; i <= n; i++)
            for(int j = m; j >= stones[i - 1]; j--)
                dp[j] = max(dp[j], dp[j - stones[i - 1]] + stones[i - 1]);
        return sum - 2 * dp[m];
    }
};