代码随想录打卡-dp之背包问题

一、动规五部曲

1、确定dp数组以及下标的含义

2、确定递推公式

3、dp数组如何初始化

4、确定遍历顺序

5、举例推导dp数组

二、背包递推公式

2.1 能否装满背包（或最多装多少）

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

416.分割等和子集

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

注意点：

如果题目给的价值都是正整数那么非0下标都初始化为0就可以了，如果题目给的价值有负数，那么非0下标就要初始化为负无穷。

这样才能让dp数组在递推的过程中取得最大的价值，而不是被初始值覆盖了。

本题题目中 只包含正整数的非空数组，所以非0下标的元素初始化为0就可以了。

class Solution {
    public boolean canPartition(int[] nums) {
        int sum = 0;
        for(int num:nums){
            sum += num;
        }
        if(sum%2 != 0){
            return false;
        }
        int target = sum/2;
        int[] dp = new int[target+1];
        for(int i = 0;i<nums.length;i++){
            for(int j = target;j>=nums[i];j--){
                dp[j] = Math.max(dp[j],dp[j-nums[i]]+nums[i]);
            }
            if(dp[target] == target){
                return true;
            }
        }
        return dp[target]==target;
        
    }
}

class Solution {
    public int lastStoneWeightII(int[] stones) {
        //虽然本题说是返回“最小”可能重量
        //但进行问题转换，转换为分成两堆重量最相近的石头
        int sum = 0;
        for(int stone:stones){
            sum += stone;
        }
        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]);
            }
        }
        //背包容量为target，最多能装dp[target]
        //有两大堆dp[target],问的是两堆石块碰撞后剩余重量
        return sum-2*dp[target];
    }
}

2.2 装满背包有几种方法

递推公式：dp[j] += dp[ j-nums[i] ]

494.目标和

518.零钱兑换II

377.组合总和IV

57.爬楼梯

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        //数组和为sum，目标值为target
        //设一组成功的方法，数组加法的子集和为x，则减法的子集和为target-x
        //sum = x+[-(target-x)]
        //化简得 x = (sum+target)/2
        //将问题转换为找一个子集，和为x(理解成容量为x)
        int sum = 0;
        for(int num:nums){
            sum += num;
        }
        if((sum+target)%2 != 0){
            return 0;
        }
        //注意这里是target的绝对值，target可能是负数！
        if(sum<Math.abs(target)){
            return 0;
        }
        int bagSize = (target+sum)/2;
        int[] dp = new int[bagSize+1];
        dp[0] = 1;
        for(int i = 0;i<nums.length;i++){
            for(int j = bagSize;j>=nums[i];j--){
                //组合问题
                dp[j] += dp[j-nums[i]];
            }
        }
        return dp[bagSize];
    }
}

注意点：dp[0]一定要为1，dp[0] = 1是 递归公式的基础。如果dp[0] = 0 的话，后面所有推导出来的值都是0了。下标非0的dp[j]初始化为0，这样累计加dp[j - coins[i]]的时候才不会影响真正的dp[j]

class Solution {
    public int change(int amount, int[] coins) {
        //完全背包：无限使用
        //组合问题
        int[] dp = new int[amount+1];
        dp[0] = 1;
        for(int i = 0;i<coins.length;i++){
            for(int j = coins[i];j<=amount;j++){
                dp[j] += dp[j-coins[i]];
            }
        }
        return dp[amount];
    }
}

class Solution {
    public int combinationSum4(int[] nums, int target) {
        //组合问题：+=
        //完全背包：正序遍历
        //和顺序有关：外层背包、内层物品
        int[] dp = new int[target+1];
        dp[0] = 1;
        for(int i = 0;i<=target;i++){
            for(int j = 0;j<nums.length;j++){
                if(i>=nums[j]){
                    dp[i] += dp[i-nums[j]];
                }
            }
        }
        return dp[target];
    }
}

2.3 背包装满最大价值

递推公式：dp[j] = Math.max( dp[j],dp[ j-weight[i] ]+value[i] )

474.一和零

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){
            zeroNum = 0;
            oneNum = 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];
    }
}

2.4 装满背包所有物品的最小个数

322.零钱兑换

279.完全平方数

注意点：首先凑足总金额为0所需钱币的个数一定是0，那么dp[0] = 0;

              考虑到递推公式的特性，dp[j]必须初始化为一个最大的数，否则就会在min(dp[j - coins[i]] + 1, dp[j])比较的过程中被初始值覆盖。所以下标非0的元素都是应该是最大值。

class Solution {
    public int coinChange(int[] coins, int amount) {
        //完全背包：正序遍历
        //与顺序无关：内层背包，外层物品
        //最少：先初始化到最大值
        int max = Integer.MAX_VALUE;
        int[] dp = new int[amount+1];
        for(int i = 0;i<dp.length;i++){
            dp[i] = max;
        }
        dp[0] = 0;
        for(int i = 0;i<coins.length;i++){
            for(int j = coins[i];j<=amount;j++){
                if(dp[j-coins[i]]!=max){
                    dp[j] = Math.min(dp[j],dp[j-coins[i]]+1);
                }
            }
        }
        return dp[amount]==max?-1:dp[amount];
    }
}

注意点：根据题意，“物品”从1开始，而不是0！

class Solution {
    public int numSquares(int n) {
        //完全背包：正序遍历
        //与顺序无关：外层物品、内层背包
        //最少数量：初始化为最大值
        int[] dp = new int[n+1];
        int max = Integer.MAX_VALUE;
        for(int i = 0;i<=n;i++){
            dp[i] = max;
        }
        dp[0] = 0;
        //注意此处i从1开始，因为忽略0的平方
        for(int i = 1;i*i<=n;i++){
            for(int j = i*i;j<=n;j++){
                dp[j] = Math.min(dp[j],dp[j-i*i]+1);
            }
        }
        return dp[n];
    }
}