代码随想录第四十二天——分割等和子集，最后一块石头的重量II

01 背包

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

二维dp数组解法

1. 确定dp数组以及下标的含义
   dp[i][j] 表示从下标为 0-i 的物品里任意取，放进容量为j的背包，价值总和最大是多少
2. 确定递推公式
   两个方向推出dp[i][j]：

• 不放物品i：由dp[i - 1][j]推出，即背包容量为j，里面不放物品i的最大价值，此时dp[i][j]就是dp[i - 1][j]。(当物品i的重量大于背包j的重量时，物品i无法放进背包中，背包内的价值和前面相同。)
• 放物品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得到的最大价值。
  所以递归公式： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i])

3. 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]);

    }
}

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

一维dp数组解法：滚动数组

1. 确定dp数组以及下标的含义
   dp[j] ：表示容量为 j 的背包，所背的物品价值可以最大为 dp[j]
2. 确定递推公式
   两个方向推出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数组都初始为0。

vector<int> dp(bagWeight + 1, 0)

4. 确定遍历顺序
   只能先遍历物品，后遍历背包，并且背包的遍历需要倒序遍历

• 先物品后背包的原因：一维dp的背包容量一定是倒序遍历，如果遍历背包容量放在上一层，那么每个dp[j]就只会放入一个物品，即背包里只放入了一个物品。
• 倒序遍历的原因：本质上还是一个对二维数组的遍历，并且右下角的值依赖上一层左上角的值，因此需要保证左边的值仍然是上一层的，所以需要从右向左覆盖，否则前面的值会对后面的值产生干扰。

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

leetcode 416. 分割等和子集

题目链接：分割等和子集
把01背包问题套到本题上来：

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

1. 确定dp数组以及下标的含义
   dp[j] ：dp[j]表示 背包总容量（所能装的总重量）是j，放进物品后，背的最大重量为dp[j]。如果背包容量为target， dp[target]就是装满背包之后的重量，所以 当 dp[target] == target的时候，背包就装满了。
2. 确定递推公式
   背包里放入数值，物品i的重量是nums[i]，其价值也是nums[i]
   所以递归公式： dp[j] = max(dp[j], dp[j - nums[i]] + nums[i])
3. dp数组初始化
   从dp[j]的定义看，dp[0]一定是0。如果题目给的价值都是正整数那么非0下标都初始化为0，如果题目给的价值有负数，那么非0下标就要初始化为负无穷。这样才能让dp数组在递推的过程中取得最大的价值，而不是被初始值覆盖了。本题只包含正整数的非空数组，所以非0下标的元素初始化为0。

//每个数组中的元素不会超过 100，数组的大小不会超过200
//总和不会大于20000，背包最大只需要其中一半，所以取10001大小
vector<int> dp(10001, 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数组
   dp[j]的数值一定是小于等于j的。如果dp[j] == j ，集合中的子集总和正好可以凑成总和j。
   
   dp[11] == 11，说明可以将数组分割成两个子集，使得两个子集的元素和相等。

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = 0;
        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数组大小是一个常数，但是是大常数

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

题目链接：最后一块石头的重量
本题就是尽量让石头分成重量相同的两堆，相撞之后剩下的石头最小，这样就化解成01背包问题了
dp[j]：dp[j]表示容量（其实就是重量）为j的背包，最多可以背最大重量为dp[j]
递推公式：dp[j] = max(dp[j], dp[j - stones[i]] + stones[i])
dp[target]里是容量为target的背包所能背的最大重量。那么分成两堆石头，一堆石头的总重量是dp[target]，另一堆就是sum -dp[target]。计算target = sum / 2 因为是向下取整，所以sum - dp[target] 一定是大于等于dp[target]的。
所以相撞之后剩下的最小石头重量就是 (sum - dp[target]) - dp[target]

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