代码随想录第四十二天 | 0-1背包理论基础：二维dp矩阵 01背包，一维dp数组 01背包（滚动数组）（卡玛网 46题）；0-1背包的应用：分割等和子集（416）

1、0-1背包理论基础

背包问题分类

有n件物品和一个最多能背重量为w的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能用一次，求解将哪些物品装入背包里 物品价值总和 最大

暴力的解法
每一件物品其实只有两个状态，取或者不取，所以可以使用回溯法搜索出所有的情况，那么时间复杂度就是o(2ⁿ)，这里的n表示物品数量
暴力的解法是指数级别的时间复杂度。进而才需要动态规划的解法来进行优化
二维dp数组01背包

以下举例都围绕这个例子展开：
背包最大重量为4
物品0，1，2分别为：

重量	价值
1	15
3	20
4	30

问背包能背的物品最大价值

1.1 二维dp矩阵 01背包

动规五部曲：
1、确定dp数组以及下标的含义
对于背包问题，使用二维数组，即dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包（可以理解为当前容量为j），价值总和最大是多少

需要记录第一维的物品种类信息是因为需要把每种物品一件一件放进去试，而记录第二维的容量信息是因为需要判断是不是塞得进去，对于每种物品需要有多少空间是个动态的过程，所以也需要在一件一件放进去试的时候进行记录判断

2、确定递推公式
再回顾一下dp[i][j]的含义：从下标为[0-i]的物品里任意取，放进容量为j的背包（当前容量为j），价值总和最大值

那么可以有两个方向推出来dp[i][j]：
2.1 不放物品i：由dp[i - 1][j]推出，即背包容量（当前容量）为j，里面不放物品i的最大价值，此时dp[i][j]就是dp[i - 1][j]。(物品i无法放进背包中，所以背包内的价值依然和前面相同)

2.2 放物品i：由dp[i - 1][j - weight[i]]推出，dp[i - 1][j - weight[i]] 为背包容量为j - weight[i]的时候不放物品i的最大价值，那么dp[i - 1][j - weight[i]] + value[i] （物品i的价值），就是背包放物品i得到的最大价值
所以递归公式： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

3、dp数组如何初始化
关于初始化，一定要和dp数组的定义吻合
首先从dp[i][j]的定义出发，如果背包容量j为0的话，即dp[i][0]，无论是选取哪些物品，背包价值总和一定为0

状态转移方程 dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 可以看出i 是由 i-1 推导出来，那么i为0的时候就一定要初始化
当 j < weight[0]的时候，dp[0][j] 应该是 0，因为背包容量比编号0的物品重量还小
当j >= weight[0]时，dp[0][j] 应该是value[0]，因为背包容量放足够放编号0物品

代码初始化如下：

for (int j = 0 ; j < weight[0]; j++) {  // 当然这一步，如果把dp数组预先初始化为0了，这一步就可以省略，但很多同学应该没有想清楚这一点。
    dp[0][j] = 0;
}
// 正序遍历
for (int j = weight[0]; j <= bagweight; j++) {
    dp[0][j] = value[0];
}

此时dp数组初始化情况如图所示：

其实从递归公式： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 可以看出dp[i][j] 是由左上方数值推导出来了，那么 其他下标初始为什么数值都可以，因为都会被覆盖
初始-1，初始-2，初始100，都可以，但只不过一开始就统一把dp数组统一初始为0，更方便一些

如图：

最后初始化代码如下：

// 初始化 dp
vector<vector<int>> dp(weight.size(), vector<int>(bagweight + 1, 0));
for (int j = weight[0]; j <= bagweight; j++) {
    dp[0][j] = value[0];
}

4、确定遍历顺序
有两个遍历的维度：物品与背包重量
先遍历 物品还是先遍历背包重量呢？其实都可以，但是先遍历物品更好理解
那么先给出先遍历物品，然后遍历背包重量的代码

// weight数组的大小 就是物品个数
for(int i = 1; i < weight.size(); i++) { // 遍历物品
    for(int j = 0; 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][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 递归公式中可以看出dp[i][j]是靠dp[i-1][j]和dp[i - 1][j - weight[i]]推导出来的
dp[i-1][j]和dp[i - 1][j - weight[i]] 都在dp[i][j]的左上角方向（包括正上方向），那么先遍历物品，再遍历背包 以及 先遍历背包，再遍历物品（一样）的过程如图所示：

虽然两个for循环遍历的次序不同，但是dp[i][j]所需要的数据就是左上角，不影响dp[i][j]公式的推导
其实背包问题里，两个for循环的先后循序是非常有讲究的，理解遍历顺序其实比理解推导公式难多了

5、举例推导dp数组
来看一下对应的dp数组的数值，如图：

做动态规划的题目，最好的过程就是自己在纸上举一个例子把对应的dp数组的数值推导一下，然后在动手写代码
卡码网 46题 练习

根据思路写代码

#include 
using namespace std;

int n, bagV;

void solve() {
    std::vector<int> weight(n, 0);
    vector<int> value(n, 0);
    for(int i = 0; i < n; i++) {
        cin >> weight[i];
    }
    for(int i = 0; i < n; i++) {
        cin >> value[i];
    }
    vector<vector<int>> dp(n, vector<int>(bagV + 1, 0));
    for(int j = weight[0]; j <= bagV; j++) {
        dp[0][j] = value[0];
    }
    for(int i = 1; i < n; i++) {
        for(int j = 0; j <= bagV; 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]);
            }
        }
    }
    cout << dp[n - 1][bagV];
}

int main() {
    while(cin >> n >> bagV) {
       solve();
    }
    return 0;
}

代码随想录代码如下：

//二维dp数组实现
#include 
using namespace std;

int n, bagweight;// bagweight代表行李箱空间
void solve() {
    vector<int> weight(n, 0); // 存储每件物品所占空间
    vector<int> value(n, 0);  // 存储每件物品价值
    for(int i = 0; i < n; ++i) {
        cin >> weight[i];
    }
    for(int j = 0; j < n; ++j) {
        cin >> value[j];
    }
    // dp数组, dp[i][j]代表行李箱空间为j的情况下,从下标为[0, i]的物品里面任意取,能达到的最大价值
    vector<vector<int>> dp(weight.size(), vector<int>(bagweight + 1, 0));

    // 初始化, 因为需要用到dp[i - 1]的值
    // j < weight[0]已在上方被初始化为0
    // j >= weight[0]的值就初始化为value[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 = 0; j <= bagweight; j++) { // 遍历行李箱容量
            // 如果装不下这个物品,那么就继承dp[i - 1][j]的值
            if (j < weight[i]) dp[i][j] = dp[i - 1][j];
            // 如果能装下,就将值更新为 不装这个物品的最大值 和 装这个物品的最大值 中的 最大值
            // 装这个物品的最大值由容量为j - weight[i]的包任意放入序号为[0, i - 1]的最大值 + 该物品的价值构成
            else dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
        }
    }
    cout << dp[weight.size() - 1][bagweight] << endl;
}

int main() {
    while(cin >> n >> bagweight) {
        solve();
    }
    return 0;
}

1.2 二维dp矩阵：总结

除了推导公式，还有如何初始化和遍历顺序上

1.3 一维dp数组（滚动数组） 01背包

滚动数组就是把二维dp降为一维dp
第一遍代码，出错，因为一维数组需要避免重复加一件物品，这里没有避免所以会出错（后面会通过遍历顺序解决）

#include 
using namespace std;

int n, bagV;

void solve() {
    std::vector<int> weight(n, 0);
    vector<int> value(n, 0);
    for(int i = 0; i < n; i++) {
        cin >> weight[i];
    }
    for(int i = 0; i < n; i++) {
        cin >> value[i];
    }
    vector<int> dp(bagV + 1, 0);
    for(int i = 0; i < n; i++) {
        for(int j = 0; j <= bagV; j++) {
            if(j >= weight[i]) {
                dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
                //但是一维数组需要避免重复加一件物品，这里没有避免所以会出错
            }
        }
    }
    cout << dp[bagV];
}

int main() {
    while(cin >> n >> bagV) {
       solve();
    }
    return 0;
}

回看例子：
背包最大重量为4
物品0，1，2分别为：

重量	价值
1	15
3	20
4	30

问背包能背的物品最大价值

对于背包问题其实状态都是可以压缩的
在使用二维数组的时候，递推公式：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
其实可以发现如果把dp[i - 1]那一层拷贝到dp[i]上，表达式完全可以是：dp[i][j] = max(dp[i][j], dp[i][j - weight[i]] + value[i]);
与其把dp[i - 1]这一层拷贝到dp[i]上，不如只用一个一维数组了，只用dp[j]（一维数组，也可以理解是一个滚动数组）
这就是滚动数组的由来，需要满足的条件是上一层可以重复利用，直接拷贝到当前层

动规五部曲分析如下：
1、确定dp数组的定义
在一维dp数组中，dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]

2、一维dp数组的递推公式
**dp[j]**为 容量为j的背包所背的最大价值，那么如何推导dp[j]呢？
dp[j]可以通过dp[j - weight[i]]推导出来，dp[j - weight[i]]表示容量为j - weight[i]的背包所背的最大价值
dp[j - weight[i]] + value[i] 表示 容量为 j - 物品i重量 的背包 加上 物品i的价值（也就是容量为j的背包，放入物品i了之后的价值即：dp[j]）

此时dp[j]有两个选择，一个是取自己dp[j] 相当于 二维dp数组中的dp[i-1][j]，即不放物品i，一个是取dp[j - weight[i]] + value[i]，即放物品i，指定是取最大的，毕竟是求最大价值

所以递归公式为：
dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

3、一维dp数组如何初始化
关于初始化，一定要和dp数组的定义吻合
dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]，那么dp[0]就应该是0，因为背包容量为0所背的物品的最大价值就是0
那么dp数组除了下标0的位置，初始为0，其他下标应该初始化多少呢？

看一下递推公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
dp数组在推导的时候一定是取价值最大的数，如果题目给的价值都是正整数那么非0下标都初始化为0就可以了，这样才能让dp数组在递归公式的过程中取的最大的价值，而不是被初始值覆盖了
那么我假设物品价值都是大于0的，所以dp数组初始化的时候，都初始为0就可以了

4、一维dp数组遍历顺序（第一遍代码出错的地方）
二维dp遍历的时候，背包容量是从小到大，而一维dp遍历的时候，背包是从大到小
倒序遍历是为了保证物品i只被放入一次！如果一旦正序遍历了，那么物品0就会被重复加入多次

举一个例子：物品0的重量weight[0] = 1，价值value[0] = 15
如果正序遍历
dp[1] = dp[1 - weight[0]] + value[0] = 15
dp[2] = dp[2 - weight[0]] + value[0] = 30
此时dp[2]就已经是30了，意味着物品0，被放入了两次，所以不能正序遍历

为什么倒序遍历，就可以保证物品只放入一次呢？
倒序就是先算dp[2]
dp[2] = dp[2 - weight[0]] + value[0] = 15 （dp数组已经都初始化为0）
从这里就可以看出为什么倒序只加一次了，因为递推公式是加前面的值（dp[2 - weight[0]] ）而这个前面的值因为还没有在本次被处理过（即判断是否取这个物品）所以不会出现重复加入的情况
dp[1] = dp[1 - weight[0]] + value[0] = 15
所以从后往前循环，每次取得状态不会和之前取得状态重合，这样每种物品就只取一次了

为什么二维dp数组遍历的时候不用倒序呢？
因为对于二维dp，dp[i][j]都是通过上一层即dp[i - 1][j]计算而来，本层的dp[i][j]并不会被覆盖
再来看看两个嵌套for循环的顺序，代码中是先遍历物品嵌套遍历背包容量，那可不可以先遍历背包容量嵌套遍历物品呢？
不可以！

因为一维dp的写法，背包容量一定是要倒序遍历（原因上面已经讲了），如果遍历背包容量放在上一层，那么每个dp[j]就只会放入一个物品，即：在本次处理中，只考虑背包里是否放入了某一个物品
倒序遍历的原因是，本质上还是一个对二维数组的遍历，并且右下角的值依赖上一层左上角的值，因此需要保证左边的值仍然是上一层的，从右向左覆盖

5、举例推导dp数组
一维dp，分别用物品0，物品1，物品2 来遍历背包，最终得到结果如下：

使用倒序来解决同一件物品重复加入背包的问题

#include 
using namespace std;

int n, bagV;

void solve() {
    std::vector<int> weight(n, 0);
    vector<int> value(n, 0);
    for(int i = 0; i < n; i++) {
        cin >> weight[i];
    }
    for(int i = 0; i < n; i++) {
        cin >> value[i];
    }
    vector<int> dp(bagV + 1, 0);
    for(int i = 0; i < n; i++) {
        for(int j = bagV; j >= 0; j--) {
            if(j >= weight[i]) {
                dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
                //但是一维数组需要避免重复加一件物品，这里没有避免所以会出错
            }
        }
    }
    cout << dp[bagV];
}

int main() {
    while(cin >> n >> bagV) {
       solve();
    }
    return 0;
}

代码随想录代码如下

// 一维dp数组实现
#include 
#include 
using namespace std;

int main() {
    // 读取 M 和 N
    int M, N;
    cin >> M >> N;

    vector<int> costs(M);
    vector<int> values(M);

    for (int i = 0; i < M; i++) {
        cin >> costs[i];
    }
    for (int j = 0; j < M; j++) {
        cin >> values[j];
    }

    // 创建一个动态规划数组dp，初始值为0
    vector<int> dp(N + 1, 0);

    // 外层循环遍历每个类型的研究材料
    for (int i = 0; i < M; ++i) {
        // 内层循环从 N 空间逐渐减少到当前研究材料所占空间
        for (int j = N; j >= costs[i]; --j) {
            // 考虑当前研究材料选择和不选择的情况，选择最大值
            dp[j] = max(dp[j], dp[j - costs[i]] + values[i]);
        }
    }

    // 输出dp[N]，即在给定 N 行李空间可以携带的研究材料最大价值
    cout << dp[N] << endl;

    return 0;
}

2、0-1背包的应用

2.1 leetcode 416：分割等和子集

第一遍代码尝试用贪心是错误的，因为不是说他加一起等于和的一半 这个加一起一定是连续的，比如[2,2,1,1]，明显可以，但是2+2超了

用贪心解决，总和大小为sum / 2（妙）
都不能整除自然不是了，因为后面sum / 2会向下取整所以必须先判断
用贪心，从大到小，看看能不能加到sum / 2

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = 0;//用贪心解决，总和大小为sum / 2（妙）
        for(int i = 0; i < nums.size(); i++) {
            sum += nums[i];
        }
        if(sum % 2 != 0) {
            return false;//都不能整除自然不是了，因为后面sum / 2会向下取整所以必须先判断
        }
        //用贪心，从大到小，看看能不能加到sum / 2
        sort(nums.begin(), nums.end());//默认升序
        int sum2 = 0;
        for(int i = nums.size() - 1; i >= 0; i--) {
            if(sum2 < sum / 2) {
                sum2 += nums[i];
            }
            else if(sum2 == sum / 2) {
                return true;
            }
            else {
                return false;
            }
        }
        return false;
    }
};

所以发现需要使用回溯一个个试，但是超时了

class Solution {
public:
    bool getSum(int target, vector<int>& nums, int curSum, int curPos) {
        if(curSum == target) return true;
        if(curPos == nums.size()) return false;
        for(int i = curPos; i < nums.size(); i++) {
            curSum += nums[i];
            if(getSum(target, nums, curSum, i + 1)) return true;
            else {
                curSum -= nums[i];
            }
        }
        return false;
    }
    bool canPartition(vector<int>& nums) {
        int sum = 0;//用回溯解决，和大小为sum / 2
        for(int i = 0; i < nums.size(); i++) {
            sum += nums[i];
        }
        if(sum % 2 != 0) {
            return false;//都不能整除自然不是了，因为后面sum / 2会向下取整所以必须先判断
        }
        //用回溯，从大到小，看看能不能加到sum / 2
        return getSum(sum / 2, nums, 0, 0);
    }
};

思路
这道题目是要找是否可以将这个数组分割成两个子集，使得两个子集的元素和相等
那么只要找到集合里能够出现 sum / 2 的子集总和，就算是可以分割成两个相同元素和子集了
本题是可以用回溯暴力搜索出所有答案的，但第一遍代码最后超时了，放弃回溯，直接上01背包吧

0-1背包问题，大家都知道，有N件物品和一个最多能背重量为W 的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大（之前是不知道怎么把价值总和最大转化为刚好能装到sum / 2）

背包问题有多种背包方式，常见的有：01背包、完全背包、多重背包、分组背包和混合背包等等
要注意题目描述中商品是不是可以重复放入，即一个商品如果可以重复多次放入是完全背包，而只能放入一次是01背包，写法还是不一样的
要明确本题中我们要使用的是01背包，因为元素我们只能用一次

回归主题：首先，本题要求集合里能否出现总和为 sum / 2 的子集
那么来一一对应一下本题，看看背包问题如何来解决
只有确定了如下四点，才能把01背包问题套到本题上来
1、背包的体积为sum / 2
2、背包要放入的商品（集合里的元素）重量为 元素的数值，价值也为元素的数值
3、背包如果正好装满，说明找到了总和为 sum / 2 的子集
4、背包中每一个元素是不可重复放入
以上分析完，我们就可以套用01背包，来解决这个问题了

动规五部曲分析如下：
1、确定dp数组以及下标的含义
01背包中，dp[j] 表示： 容量为j的背包，所背的物品价值最大可以为dp[j]
本题中每一个元素的数值既是重量，也是价值，套到本题，dp[j]表示 背包总容量（所能装的总重量）是j，放进物品后，背的东西的最大重量为dp[j]
那么如果背包容量为target， dp[target]就是尽可能装满 背包之后的重量，所以 当 dp[target] == target 的时候，背包就装满了

装不满的时候，拿输入数组 [1, 5, 11, 5]，举例， dp[7] 只能等于 6，因为 只能放进 1 和 5
而dp[6] 就可以等于6了，放进1 和 5，那么dp[6] == 6，说明背包装满了

2、确定递推公式
01背包的递推公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
本题，相当于背包里放入数值，那么物品i的重量是nums[i]，其价值也是nums[i]，所以递推公式：dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);

3、dp数组如何初始化
在01背包，一维dp如何初始化，已经讲过，从dp[j]的定义来看，首先dp[0]一定是0
如果题目给的价值都是正整数那么非0下标都初始化为0就可以了，如果题目给的价值有负数，那么非0下标就要初始化为负无穷，这样才能让dp数组在递推的过程中取得最大的价值，而不是被初始值覆盖了

本题题目中 只包含正整数的非空数组，所以非0下标的元素初始化为0就可以了
代码如下：

// 题目中说：每个数组中的元素不会超过 100，数组的大小不会超过 200
// 总和不会大于20000，背包最大只需要其中一半，所以10001大小就可以了
vector<int> dp(10001, 0);

4、确定遍历顺序
如果使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历

代码如下：

// 开始 01背包
for(int i = 0; i < nums.size(); i++) {
    for(int j = target; j >= nums[i]; j--) { // 每一个元素一定是不可重复放入，所以从大到小遍历
        dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
    }
}

5、举例推导dp数组
dp[j]的数值一定是小于等于j的
如果dp[j] == j 说明，集合中的子集总和正好可以凑成总和j

用例1，输入[1,5,11,5] 为例，如图：

最后dp[11] == 11，说明可以将这个数组分割成两个子集，使得两个子集的元素和相等

根据思路自己写代码：
使用的递推公式是dp[j] = max(dp[j], max(dp[j - 1], dp[j - nums[i]] + nums[i]));也过了，但其实dp[j]就包含了不放入该物品的情况，所以想着通过dp[j - 1]考虑不放入该物品的情况是想多了，代码随想录的递推公式与之前的一维数组的背包一致：dp[j] = max(dp[j], dp[j - weight[i]] + value[i])

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = 0;
        for(int i = 0; i < nums.size(); i++) {
            sum += nums[i];
        }
        if(sum % 2 != 0) {
            return false;//都不能整除自然不是了，因为后面sum / 2会向下取整所以必须先判断
        }
        //用01背包，从大到小，看看能不能加到sum / 2
        vector<int> dp(sum + 1, 0);
        for(int i = 0; i < nums.size(); i++) {
            for(int j = sum; j >= nums[i]; j--) {//注意这里循环的下限是nums[i]
                dp[j] = max(dp[j], max(dp[j - 1], dp[j - nums[i]] + nums[i]));
            }
        }
        if(dp[sum / 2] == sum / 2) {
            return true;
        }
        return false;
    }
};

代码随想录C++代码如下：

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = 0;

        // dp[i]中的i表示背包内总和
        // 题目中说：每个数组中的元素不会超过 100，数组的大小不会超过 200
        // 总和不会大于20000，背包最大只需要其中一半，所以10001大小就可以了
        vector<int> dp(10001, 0);
        for (int i = 0; i < nums.size(); i++) {
            sum += nums[i];
        }
        // 也可以使用库函数一步求和
        // int sum = accumulate(nums.begin(), nums.end(), 0);
        if (sum % 2 == 1) return false;
        int target = sum / 2;

        // 开始 01背包
        for(int i = 0; i < nums.size(); i++) {
            for(int j = target; j >= nums[i]; j--) { // 每一个元素一定是不可重复放入，所以从大到小遍历
                dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
            }
        }
        // 集合中的元素正好可以凑成总和target
        if (dp[target] == target) return true;
        return false;
    }
};

时间复杂度：O(n²)
空间复杂度：O(n)，虽然dp数组大小为一个常数，但是大常数

2.2 leetcode 416：总结

这道题目就是一道01背包应用类的题目，需要我们拆解题目，然后套入01背包的场景
01背包相对于本题，主要要理解，题目中物品是nums[i]，重量是nums[i]，价值也是nums[i]，背包体积是sum/2