代码随想录打卡第43天|1049. 最后一块石头的重量 II ；494. 目标和；474.一和零

总结

1049. 最后一块石头的重量 II ：dp[j]表示背包容量为j时，使得背包的价值尽可能大

494. 目标和：dp[j]表示背包容量为j时，有dp[j]种实现的方式；

474.一和零 ：dp[i][j]表示0的容量为i,1的容量为j时，装满m个0 和 n个1的最大背包dp[i][j]

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

关键点1：for循环，对数组求和，得到target=sum/2

关键点2：dp数组：dp[j]表示背包容量为j时，能获得的最大价值；

关键点3：dp数组初始化dp[0] = 0；因为dp[其它非0元素]要为一个较小值，后续才能在max中比较得到真实值，否则会覆盖真实值，所以dp[其它非0元素] = 0；所以，dp数组全部初始化为0；

关键点4：遍历顺序：先遍历物品，再遍历背包容量，背包要逆序遍历，不然会重复使用元素

关键点5：递归公式，因为本题按题意可理解为重量和价值相等，所以weight[i] = stones[i];value[i] = stones[i]

关键点6：最终，返回 sum - 2* 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 >> 1;

        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 - 2*dp[target];
    }
}

494. 目标和

关键点1：for循环，对数组求和，得到sum

关键点2：因为正数的集合+负数的集合 = sum；正数的集合-负数的集合 =target；两式联合得到正数的集合（size） = (sum + target)/2；

关键点3：dp数组：dp[j]表示背包容量为j时，有dp[j]种实现的方式；

关键点4：dp数组初始化dp[0] = 1，例如0，target = 0;dp[0] = 1；因为dp[其它非0元素]要为一个较小值，后续才能在max中比较得到真实值，否则会覆盖真实值，所以dp[其它非0元素] = 0；

关键点5：遍历顺序：先遍历物品，再遍历背包容量，背包要逆序遍历，不然会重复使用元素

关键点6：递归公式，dp[j] += dp[j-nums[i]];累加和

关键点6：最终，返回 dp[size]

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int sum = 0;
        for(int i = 0;i < nums.length;i++){
            sum += nums[i];
        }
        int size = (sum + target) >> 1;

        // 如果不能平分，则返回0
        int flag = (sum + target) % 2;
        if( flag != 0) return 0;

        // 如果target过大 sum将无法满足
        if(target < 0 && sum < -target) return 0;

        // 保证size为正数
        if(size < 0) size = -size;

        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：for循环，对数组求和，得到sum

关键点2：因为正数的集合+负数的集合 = sum；正数的集合-负数的集合 =target；两式联合得到正数的集合（size） = (sum + target)/2；

关键点3：dp数组：dp[i][j]示背包的两类容量分别为i,j时，装满m个0 和 n个1的最大背包dp[i][j]；

关键点4：dp[0][0] = 0,其它非0元素的也初始成0 ，避免覆盖问题

关键点5：遍历顺序：先遍历物品，再遍历背包容量，背包要逆序遍历，不然会重复使用元素

关键点6：遍历物品的方式：最外层for 循环得到此时的字符串，将字符串转为char[]，再用一层for循环遍历char[]，得到此时物品有多少的0，和多少个1，分别用x,y代表

 关键点7：递归公式，dp[i][j] = Math.max(dp[i][j],dp[i-x][j-y]+1); dp[i][j] 与 未装此时的物品 + 1两者的最大值

关键点8：最终，返回 dp[m][n] 

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        //  装满m个0 和 n个1的最大背包dp[i][j]
        int[][] dp = new int[m+1][n+1];
        // 初始化,dp[0][0] = 0,其它非0元素的也初始成0 ，避免覆盖问题
        for(String str:strs){
            int x = 0,y= 0;
            for(char c : str.toCharArray()){
                if(c == '0'){
                    x++;
                }else{
                    y++;
                }
            }

            for(int i = m;i >= x;i--){
                for(int j = n; j >= y;j--){
                    dp[i][j] = Math.max(dp[i][j],dp[i-x][j-y]+1);
                }
            }
        }
        return dp[m][n];

    }
}