代码随想录算法训练营第四十三天【动态规划part05】 | 1049. 最后一块石头的重量 II、494. 目标和、474.一和零

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

题目链接：

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

求解思路：

等于把石头尽量分成重量相同的两堆

动规五部曲

1. 确定dp数组及其下标含义：容量为j的背包，最多能装下的最大重量为dp[j]
2. 确定递推公式：dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);
3. dp数组的初始化：重量不会是负数，全部初始化为0即可
4. 确定遍历顺序：先物品，再背包，且遍历背包要倒序
5. 举例推导dp数组：以[2,4,1,1]为例，如图。最后相撞后的结果为sum-2*dp[target]

代码：

class Solution {
public:
    int lastStoneWeightII(vector& stones) {
        int sum = 0;
        for (int i : stones) sum += i;
        int target = sum / 2;
        vector dp(target+1, 0);
        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 - 2*dp[target];
    }
};

494. 目标和

题目链接：

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

求解思路：

• 

等于求有多少种不同的组合方式，能组合成和为left的子集（装满这个背包有几种方法）

动规五部曲

1. dp数组及其下标含义：填满j（包括j）这么大容积的包，有dp[j]种方法
2. 确定递推公式：dp[j] += dp[j - nums[i]]，举例说明如下，凑整dp[5]的方法就是把所有的dp[j - nums[i]]累加
   • 已经有一个1（nums[i]） 的话，有 dp[4]种方法 凑成 容量为5的背包。
   • 已经有一个2（nums[i]） 的话，有 dp[3]种方法 凑成 容量为5的背包。
   • 已经有一个3（nums[i]） 的话，有 dp[2]中方法 凑成 容量为5的背包
   • 已经有一个4（nums[i]） 的话，有 dp[1]中方法 凑成 容量为5的背包
   • 已经有一个5 （nums[i]）的话，有 dp[0]中方法 凑成 容量为5的背包
3. 初始化：dp[0] = 1，dp[0]是递推结果的起源
4. 遍历顺序：先物品，再背包，背包要倒序
5. 举例推导dp数组：nums: [1, 1, 1, 1, 1]，target = 3，此时bagSize = 4，如图

代码：

class Solution {
public:
    int findTargetSumWays(vector& nums, int target) {
        int sum = 0;
        for (int i : nums) sum += i;
        // 两种特殊情况
        if (abs(target) > sum) return 0;
        if ((target + sum) % 2 == 1) return 0;
        int bagSize = (target + sum) / 2;
        // 填满j（包括j）这么大容积的包，有dp[j]种方法
        vector 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.一和零

题目链接：

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

求解思路：

动规五部曲

1. 确定dp数组及其下标含义：最多有i个0和j个1的strs的最大子集的大小为dp[i][j]
2. 递推公式：dp[i][j] 可以由前一个strs里的字符串推导出来，strs里的字符串有zeroNum个0，oneNum个1，则 dp[i][j] = dp[i - zeroNum][j - oneNum] + 1，注意和dp[i][j]本身比较，取较大的值；字符串的zeroNum和oneNum相当于物品的重量（weight[i]），字符串本身的个数相当于物品的价值（value[i]），即01背包问题，不过重量有两个维度
3. 初始化：物品价值不会为负数，因此全部初始化为0
4. 遍历顺序：先物品，后背包，背包倒序；注意物品是strs里的字符串，背包是题目中的m和n
5. 举例推导：以 ["10","0001","111001","1","0"]，m = 3，n = 3为例，如图

代码：

class Solution {
public:
    int findMaxForm(vector& strs, int m, int n) {
        // 初始化
        vector> dp(m+1, vector (n+1, 0));

        for (string str : strs){ // 遍历物品
            int one = 0, zero = 0;
            for (char c : str){
                if (c == '0') zero ++;
                else one++;
            }
            // 遍历背包（倒序遍历）
            for (int i = m; i >= zero; i--){
                for (int j = n; j >= one; j--){
                    dp[i][j] = max(dp[i][j], dp[i-zero][j-one] + 1);
                }
            }
        }
        return dp[m][n];
    }
};