Day 43 动态规划 5

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

代码随想录

1.  思路

这道题如果转化成，将石头的总重分成两堆，探究以一半重量为袋子，最多能装的重量，这样一个问题，就是一个标准的01背包。

但有两个假设需要证实：

（1）半分相减的结果，可以通过石头撞击的方法实现

可以用归纳收敛的方法证明。每次将两堆石头分组撞击，石头数量肯定会减少，总重量也会减少。这样不断撞击，最后会剩下0或1块石头，由于消失的重量都是因为撞击消失的，所以剩下的重量就是半分相减的结果。

（2）如果遇到总重量为奇数的情况，半分时向下取整，得到的结果和向上取整一致

可以用分类讨论的方法证明。如果总重2n+1可以拆分为n和n+1，n+1这一组进行背包填充结果比n这一组好的唯一情况，就是背包价值之和为n+1（不然的话，价值之和<=n，也可以让n成为背包获得相同的结果），这种情况下另一堆石头的重量就是n，它可以被n这个背包获得结果。因此，不论如何，n（向下取整）获得的结果和向上取整一致。

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. 目标和

代码随想录

1. 思路

（1）转化背包问题：

如果符号为+的部分总和为a，则符号为-的部分总和为sum-a，则a-(sum-a)=2a-sum，为target，因此a=(sum+target)/2。因此，问题转化为，寻找所有求和为(sum+target)/2的可能组合数量。注意这里并不是寻找最大可能取值，而是总数量。

之前的背包问题，其实可以做一个泛化。它的原理就是，尝试n个物品，在一定限制条件下的最优化。方法就是，每次尝试加入一个新的元素，并根据背包的所有可能限制，判断是否加入这个物品。而判断标准需要根据实际最优化目标来判断。

（2）dp数组含义以及dp数组更新标准：

这里需要求总数，因此最优化目标变成了sum，因此dp数组的含义为0-i个物品在限制为j的条件下最多的组合。更新标准为：

dp[j] = dp[j]+dp[j-nums[i]]

含义为，0-i个物品在j限制下所有的可能方法个数，等于0-i-1（没放入i物品）的所有方法，加上放入i物品后，可能的所有方法。

（3）dp数组遍历顺序：

外层正序，内层倒序

（4）dp数组初始化方法

dp[0]的含义为，0这个元素在限制为0的情况下有多少种情况。这其实有点类似于0/0，可以定义为nan，也可以定义为1。这里我们发现，后续所有的情况需要在第一个元素上累加，所以将其定义为1更有意义。

（5）遍历顺序

内层倒叙，外层正序

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. 一和零

https://programmercarl.com/0474.一和零.html#思路

1. 思路

（1）背包问题转换

这道题是很明显的01背包问题，也就是有限的元素，每个元素只能用1次。但这道题比较难的地方为，有两个维度的限制。

因此，背包问题应该被扩充为两个维度。在之前，仅存的维度是背包的大小，隐藏的维度是每个新的元素。这道题中背包有两个维度，因此一个维度是0的限制，另一个是1的限制。

（2）dp数组定义以及更新方式

dp[i][j]数组代表有0-i个0和0-j个1，所能拥有的最大子集大小。

更新方式为：dp[i][j] = max(dp[i][j], dp[i-nums0][j-nums1]+1)

这里从背包问题的泛化形式来理解。最新的子集大小，是不放入新元素的最大子集大小，和放入新元素后，能产生的最大子集大小进行比较，产生的结果。

（3）dp数组的初始化

在没有0和1的情况下，可以组成的最大子集大小是0，因此初始化为0。

回顾一下，在第一个元素遍历的时候，只要自己的weight小于边界，就+1。因为从后向前遍历，所以结果体现为一个分段函数，在左上取0，右下取1，边界是第一个元素中0和1的个数。

（4）遍历顺序：

两个维度从后向前。

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