算法刷题day31|动态规划：1049. 最后一块石头的重量 II、494. 目标和、474. 一和零

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

本题其实就是尽量让石头分成重量相同的两堆，相撞之后剩下的石头最小，这样就化解成01背包问题了。

1.dp数组以及下标的含义：石头的重量是 stonesi，石头的价值也是 stonesi ，可以 "最多可以装的价值为 dpj" == "最多可以背的重量为dpj"

2.递推公式：dpj = max(dpj, dpj - stones\[i] + stonesi);

3.初始化： dpj中的j表示容量，就是所有石头的重量和。

提示中给出1 <= stones.length <= 30，1 <= stonesi <= 1000，所以最大重量就是30 * 1000 。

而我们要求的target其实只是最大重量的一半，所以dp数组开到15000大小就可以了。

dpj都初始化为0就可以了

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

那么分成两堆石头，一堆石头的总重量是dptarget，另一堆就是sum - dptarget。

在计算target的时候，target = sum / 2 因为是向下取整，所以sum - dptarget 一定是大于等于dptarget的。

那么相撞之后剩下的最小石头重量就是 (sum - dptarget) - dptarget。

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

494. 目标和

既然为target，那么就一定有 left组合 - right组合 = target。

left + right = sum，而sum是固定的。right = sum - left

公式来了， left - (sum - left) = target 推导出 left = (target + sum)/2 。

target是固定的，sum是固定的，left就可以求出来。

此时问题就是在集合nums中找出和为left的组合。

1.dp数组以及下标的含义：dpj 表示：填满j（包括j）这么大容积的包，有dpj种方法

2.递推公式

只要搞到numsi，凑成dpj就有dpj - nums\[i] 种方法。

例如：dpj，j 为5，

• 已经有一个1（numsi） 的话，有 dp4种方法 凑成 容量为5的背包。
• 已经有一个2（numsi） 的话，有 dp3种方法 凑成 容量为5的背包。
• 已经有一个3（numsi） 的话，有 dp2种方法 凑成 容量为5的背包
• 已经有一个4（numsi） 的话，有 dp1种方法 凑成 容量为5的背包
• 已经有一个5 （numsi）的话，有 dp0种方法 凑成 容量为5的背包

那么凑整dp5有多少方法呢，也就是把 所有的 dpj - nums\[i] 累加起来。

dpj += dpj - nums\[i];

3.初始化：dp0 一定要初始化为1，因为dp0是在公式中一切递推结果的起源，如果dp0是0的话，递推结果将都是0。

dpj其他下标对应的数值也应该初始化为0，从递推公式也可以看出，dpj要保证是0的初始值，才能正确的由dpj - nums\[i]推导出来。

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int S) {
        int sum = 0;
        for (int i = 0; i < nums.size(); i++) sum += nums[i];
        if (abs(S) > sum) return 0; // 此时没有方案
        if ((S + sum) % 2 == 1) return 0; // 此时没有方案
        int bagSize = (S + sum) / 2;
        vector<int> dp(bagSize + 1, 0);
        dp[0] = 1;
        for (int i = 0; i < nums.size(); i++) {
            for (int j = bagSize; j >= nums[i]; j--) {
                dp[j] += dp[j - nums[i]];
            }
        }
        return dp[bagSize];
    }
};

474. 一和零

这个背包有两个维度，一个是m 一个是n，而不同长度的字符串就是不同大小的待装物品。

1.dp数组（dp table）以及下标的含义：dpij：最多有i个0和j个1的strs的最大子集的大小为dpij。

2.递推公式

dpij 可以由前一个strs里的字符串推导出来，strs里的字符串有zeroNum个0，oneNum个1。

dpij 就可以是 dpi - zeroNumj - oneNum + 1。

dpij = max(dpij, dpi - zeroNumj - oneNum + 1);

3.初始化：因为物品价值不会是负数，初始为0，保证递推的时候dpij不会被初始值覆盖。

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        vector<vector<int>> dp(m + 1, vector<int> (n + 1, 0)); // 默认初始化0
        for (string str : strs) { // 遍历物品
            int oneNum = 0, zeroNum = 0;
            for (char c : str) {
                if (c == '0') zeroNum++;
                else oneNum++;
            }
            for (int i = m; i >= zeroNum; i--) { // 遍历背包容量且从后向前遍历！
                for (int j = n; j >= oneNum; j--) {
                    dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);
                }
            }
        }
        return dp[m][n];
    }
};