代码随想录day42|动态规划 01背包问题416. 分割等和子集

 

目录

二维dp数组01背包

一维dp数组（滚动数组） 

题目：416. 分割等和子集

题目链接：https://leetcode.cn/problems/partition-equal-subset-sum/

---

背包问题分类如图：

 背包问题就是将物品放入背包中，求背包的最大价值

大致做法是：把容量为j的背包分割成0到j的各个背包，然后，我们可以先遍历物品，再挨个遍历背包，如果背包容量小于物品尺寸，则当前背包的最大价值和等于不装物品i的背包的最大价值和。反之，如果背包容量大于等于物品尺寸，则当前背包的最大价值=max（拿物品i之前的背包的最大价值总和+当前物品的价值，不拿当前物品i的背包的最大价值总和)

例子：

背包最大重量为4。

物品为：

	重量	价值
物品0	1	15
物品1	3	20
物品2	4	30

问背包能背的物品最大价值是多少？

二维dp数组01背包

1.dp数组的含义

定义dp[i][j]为从物品0-i中任取，放进容量为j的背包中，背包的最大价值总和

2.递推公式

当遍历到物品i时，当前状态dp[i][j]和拿不拿物品i有关

• 如果不拿物品i，则有dp[i][j]=dp[i-1][j]
• 如果拿物品i，则有dp[i][j]=dp[i-weight[i]]+value[i]

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

3.dp数组初始化

如果背包的容量为0， 则放不进任何物品，背包最大价值总和为0，即dp[i][0]=0。

由状态转移方程dp[i][j]=max(dp[i-1][j],dp[i-weight[i]]+value[i])我们知道i是由i-1推导出来的，因此我们需要初始化i=0的情况，dp[0][j]：在存放物品0的时候，各个容量的背包所能存放的最大价值。

我们知道当背包容量小于物品尺寸的时候，即j<weight[0]的时候，dp[0][j]=0,如果背包容量大于等于物品时，即j>=weight[0]，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]);

    }
}

先遍历背包，后遍历物品：

// weight数组的大小 就是物品个数
for(int j = 0; j <= bagweight; j++) { // 遍历背包容量
    for(int i = 1; i < weight.size(); i++) { // 遍历物品
        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]);
    }
}

5.举例推导dp数组

具体测试代码如下：

void test_2_wei_bag_problem1() {
    vector<int> weight = {1, 3, 4};
    vector<int> value = {15, 20, 30};
    int bagweight = 4;

    // 二维数组
    vector<vector<int>> dp(weight.size(), vector<int>(bagweight + 1, 0));

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

    // 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]);

        }
    }

    cout << dp[weight.size() - 1][bagweight] << endl;
}

int main() {
    test_2_wei_bag_problem1();
}

一维dp数组（滚动数组） 

例子：

背包最大重量为4。

物品为：

	重量	价值
物品0	1	15
物品1	3	20
物品2	4	30

问背包能背的物品最大价值是多少？

1.dp数组的含义

dp[j]表示容量为j的背包所能背的最大价值总和。

2.递推公式

dp[j]=max(dp[j],dp[j-weight[i]]+value[i])

3.dp数组的初始化

可以直接在定义dp数组的同时，全部初始化为0

4.遍历顺序

先遍历物品，在遍历背包（从后往前遍历，防止一个物品拿多次）

5.举例推导dp数组

 具体测试代码如下：

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

    // 初始化
    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]);
        }
    }
    cout << dp[bagWeight] << endl;
}

int main() {
    test_1_wei_bag_problem();
}

题目：416. 分割等和子集

题目链接：https://leetcode.cn/problems/partition-equal-subset-sum/

 给你一个 只包含正整数 的 非空 数组 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

思路：可以先将数组中所有元素的和sum求出来，然后定义一个容量为sum/2的背包，看能不能将背包装满。

1.dp数组的含义

dp[j]表示容量为j的背包，最大可以凑成j的子集总和为dp[j],也就是装满背包的价值总和

2.递推公式

dp[j]=max(dp[j],dp[j-nums[i]]+nums[i])

3.dp数组初始化

从dp[j]的定义来看，首先dp[0]一定是0。

如果如果题目给的价值都是正整数那么非0下标都初始化为0就可以了，如果题目给的价值有负数，那么非0下标就要初始化为负无穷。

4.遍历顺序

先遍历物品，在遍历背包（从后往前遍历）

5.举例推导dp数组

具体代码实现如下： 

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^2)
空间复杂度：O(n)，虽然dp数组大小为一个常数，但是大常数