代码随想录算法训练营day43｜1049. 最后一块石头的重量 II ，494. 目标和，474.一和零

扭一扭.

已于 2022-12-07 13:02:29 修改

阅读量162

点赞数

文章标签：算法

于 2022-12-07 12:25:11 首次发布

本文链接：https://blog.csdn.net/weixin_52121600/article/details/128213922

版权

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

力扣

思路：

1. 尽量让石头分成重量相同的两堆，使相撞后剩下的石头最小；物品重量价值均为stone[i]；

2. dp数组及其下标含义：dp[j]表示容量为j的背包，可以背的最大重量为dp[j]；

3. 递推公式：dp[j] = Math.max(dp[j],dp[j-stone[i]]+stone[i]);

4. 初始化：最大容量（重量）为所有石头的重量的一半。遍历得到总重量sum，target = sum/2。因为重量不会是负数，所以dp[j]=0；

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

6. 最后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(int[] stones) {
        int sum=0;
        for(int i=0;i<stones.length;i++){
            sum+=stones[i];
        }
        int target = sum/2;
        int[] dp = new int[target+1];
        for(int i=0;i<stones.length;i++){
            for(int j=target;j>=stones[i];j--){
                dp[j] = Math.max(dp[j],dp[j-stones[i]]+stones[i]);
            }
        }
        return sum-dp[target]-dp[target];
    }
}

494. 目标和

力扣

思路：

1. 假设加法对应的数的总和为x，那么减法对应的树的总和就是sum-x；由于target = x - (sum-x)，所以 x = (target+sum)/2；此时问题可以转化为，装满容量为x的背包，有几种方式；

x 就是bagSize；当target的绝对值>sum，或者target+sum为奇数时，均return 0；

为什么是01背包问题？因为每个物品只用1次；

2. dp数组及其下标的含义：dp[j] 表示填满容量为 j 的包，有 dp[j] 种方式；

3. 递推公式：只要有nums[i]，凑成dp[j]就有dp[j-nums[i]]的方式；dp[j]+=dp[j-nums[i]]【组合类问题的公式都是类似这种】

4. 初始化：dp[0] = 1【dp[0] 一定要初始化为1，因为dp[0]是在公式中一切递推结果的起源，如果dp[0]是0的话，递归结果将都是0】；其他下标初始化为0；

5. 遍历顺序：nums 放在外循环，target 放在内循环，且内循环倒序；

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int sum = 0;
        for(int n:nums) sum += n;
        int size = (sum+target)/2;//也是加数的和
        if((sum+target)%2==1 || sum<Math.abs(target)) return 0;
        int[] dp = new int[size+1];
        dp[0] = 1;
        for(int i=0;i<nums.length;i++){
            for(int j=size;j>=nums[i];j--){
                dp[j]+=dp[j-nums[i]];
            }
        }
        return dp[size];
    }
}

474.一和零

力扣

思路：

1. strs数组里的元素就是物品，每个物品都是1个（不同长度的字符串就是不同长度的待装物品）；字符串的 zeroNum 和 oneNum 相当于物品的重量（weight[i]），字符串本身的个数相当于物品的价值（value[i])，m和n相当于是两个维度的背包；因此，本题其实是01背包问题；

2. dp数组及其下标含义：dp[i][j]代表最多有i个0和j个1的strs的最大子集的大小为dp[i][j]；

3. 递推公式：dp[i][j]可以由前一个strs里的字符串推导出来，dp[i][j] = dp[i - zeroNum][j - oneNum] + 1。遍历过程中取dp[i][j]的最大值，因此递推公式：dp[i][j] = Math.max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);

4. 初始化：01背包的dp数组初始化为0即可。

5. 遍历顺序：外层for循环字符串（物品），内层for循环m和n（背包容量）

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int[][] dp = new int[m+1][n+1];
        int zeroNum, oneNum;
        for(String str:strs){
            oneNum = 0;
            zeroNum = 0;
            for(char ch:str.toCharArray()){
                if(ch=='0'){
                    zeroNum++;
                }else{
                    oneNum++;
                }
            }
            for(int i=m;i>=zeroNum;i--){//从后往前遍历背包容量
                for(int j=n;j>=oneNum;j--){
                    dp[i][j] = Math.max(dp[i][j],dp[i-zeroNum][j-oneNum]+1);
                }
            }
        }
        return dp[m][n];
    }
}