代码随想录算法训练营第四十二天|01背包问题、01背包问题——滚动数组、416. 分割等和子集

01背包问题

文档讲解 ： 代码随想录 - 01背包问题
状态：再次回顾。

01背包

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

动态规划五部曲：

1. 确定dp数组（dp table）以及下标的含义
   dp[i]的定义为：从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。

2. 确定递推公式
   dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

3. dp数组如何初始化

   // 初始化 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. 确定遍历顺序
   先遍历背包，再遍历物品。（二维dp数组两者换顺序也可以）

5. 举例推导dp数组:
   对应的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();
}

01背包问题——滚动数组

文档讲解 ： 代码随想录 - 01背包问题——滚动数组
状态：再次回顾。

动态规划五部曲：

1. 确定dp数组（dp table）以及下标的含义
   dp[i]的定义为：容量为j的背包，所背的物品价值可以最大为dp[j]。

2. 确定递推公式
   dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

3. dp数组如何初始化
   假设物品价值都是大于0的，所以dp数组初始化的时候，都初始为0

4. 确定遍历顺序
   先遍历物品，再遍历背包。（不可以换顺序！）

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

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

代码：

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. 分割等和子集

文档讲解 ： 代码随想录 - 416. 分割等和子集
状态：再次回顾。

思路

套用01背包：

• 背包的体积为sum / 2
• 背包要放入的商品（集合里的元素）重量为 元素的数值，价值也为元素的数值
• 背包如果正好装满，说明找到了总和为sum / 2 的子集。
• 背包中每一个元素是不可重复放入。

动态规划五部曲：

1. 确定dp数组（dp table）以及下标的含义
   dp[i]的定义为：容量为j的背包，所背的物品价值最大可以为dp[j]。

2. 确定递推公式
   dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

3. dp数组如何初始化
   假设物品价值都是大于0的，所以dp数组初始化的时候，都初始为0

4. 确定遍历顺序
   先遍历物品，再遍历背包。（不可以换顺序！）

   // 开始 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数组:
   用例1，输入[1,5,11,5] 为例，如图：
   
   最后dp[11] == 11，说明可以将这个数组分割成两个子集，使得两个子集的元素和相等。

本题代码：

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数组大小为一个常数，但是大常数