代码随想录算法训练营day42｜01.背包问题，01.背包问题-滚动数组，416. 分割等和子集

01.背包问题-二维

背包理论基础01背包

1. dp数组及其下标的含义：dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少；

2. 递推公式：

• 不放物品i(放不进)：由 dp[i-1][j] 推出。此时 dp[i] = dp[i-1][j]；
• 放物品i：由 dp[i-1][j-weight[i]]推出。dp[i-1][j-weight[i]]为背包容量为j-weight[i]不放物品i时的最大价值，那么dp[i-1][j-weight[i]]+value[i]就是放入物品i时的最大价值。

由此可知，dp[i][j] = Math.max(dp[i-1][j],dp[i-1][j-weight[i]]+value[i]);

3. 初始化：dp[i][0] = 0（背包容量为0时，无论选取哪些物品，背包价值总和一定为0）；对于dp[0][j]来说，当weight[0]>j时，dp[0][j]=0，当weight[0]<=j时，dp[0][j]=value[0]；

4. 遍历顺序：先遍历物品，再遍历背包（更好理解）；或者先遍历背包，再遍历物品；

测试代码：

public static void main(String[] args){
        int[] weight = {1,3,4};
        int[] value = {15,20,30};
        int size = 4;
        testWeightBagProblem(weight,value,size);
    }

    public static void testWeightBagProblem(int[] weight, int[] value, int size){
        int num = weight.length;
        int[][] dp = new int[num+1][size+1];
        for(int i=0;i<=num;i++){//初始化
            dp[i][0] = 0;
        }
        for(int i=1;i<=num;i++){
            for(int j=1;j<=size;j++){
                if(j<weight[i-1]){//放不进
                    dp[i][j] = dp[i-1][j];
                }else{
                    dp[i][j] = Math.max(dp[i-1][j],dp[i-1][j-weight[i-1]]+value[i-1]);
                }
            }
        }
        for(int i=0;i<=num;i++){
            for(int j=0;j<=size;j++){
                System.out.print(dp[i][j]+" ");
            }
            System.out.println();
        }
    }
}

01.背包问题-滚动数组

背包理论基础01背包-一维dp数组-滚动数组

滚动数组需满足的条件：上一层可以重复利用，直接拷贝到当前层。

1. dp数组定义：dp[i]表示，容量为j的背包，所背的物品价值最大可以是dp[j]。

2. 递推公式：dp[j] 可以由 dp[j - weight[i]] 推出。dp[j - weight[i]] 表示容量为 j - weight[i] 的背包所背的最大价值，dp[j - weight[i]] + value[i] 表示容量为「j - 物品i重量」的背包的价值加上「物品i」的价值。也就是说，容量为j的背包，放入物品i之后的价值即dp[j]。

由此可得，dp[j] = Math.max(dp[j], dp[j-weight[i]]+value[i]);

3. 初始化：dp[0]=0；如果题目给的物品价值都是正整数，非零下标初始化为0即可。

4. 遍历顺序：先从小到大遍历物品i，范围[0,weight.length]；再从大到小遍历背包j，范围[weight[i],j]；倒序遍历，每次取得状态不会和之前取得状态重合，可以保证物品i只放入一次！

public class test {
    public static void main(String[] args){
        int[] weight = {1,3,4};
        int[] value = {15,20,30};
        int size = 4;
        testWeightBagProblem(weight,value,size);
    }
    public static void testWeightBagProblem(int[] weight, int[] value, int size){
        int num = weight.length;
        int[] dp = new int[size+1];
        for(int i=0;i<num;i++){//初始化
            for(int j=size;j>=weight[i];j--){
                dp[j]=Math.max(dp[j],dp[j-weight[i]]+value[i]);
            }
        }
        for(int j=0;j<=size;j++){
            System.out.print(dp[j]+" ");
        }
    }
}

416. 分割等和子集

力扣

思路：背包问题

1. 背包的体积：sum/2；背包要放入的商品重量及价值：元素的数值；当背包刚好装满时，说明找到了总和为 sum/2 的子集；背包中每一个元素不可重复放入。

2. dp数组及其下标含义：容量为j的背包，所背的物品价值可以最大为dp[j]；

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

4. 初始化：dp[0]=0；若物品价值都是正整数，其他下标初始化为0即可；若物品价值有负数，其他下标初始化为负无穷；

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

class Solution {
    public boolean canPartition(int[] nums) {
        int n = nums.length;
        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<n; i++){
            for(int j=target; j>=nums[i]; j--){
                //物品i的重量是nums[i]，其价值也是nums[i]
                dp[j] = Math.max(dp[j], dp[j-nums[i]] + nums[i]);
            }
        }
        return dp[target] == target;
    }
}