代码随想录Day30动态规划：背包问题二维_背包问题一维_416分割等和子集

背包问题二维

题目：小明是一位科学家，他需要参加一场重要的国际科学大会，以展示自己的最新研究成果。他需要带一些研究材料，但是他的行李箱空间有限。这些研究材料包括实验设备、文献资料和实验样本等等，它们各自占据不同的空间，并且具有不同的价值。小明的行李空间为 N，问小明应该如何抉择，才能携带最大价值的研究材料，每种研究材料只能选择一次，并且只有选与不选两种选择，不能进行切割。

第一行包含两个正整数，第一个整数 M 代表研究材料的种类，第二个正整数 N，代表小明的行李空间。6 1

第二行包含 M 个正整数，代表每种研究材料的所占空间。 2 2 3 1 5 2

第三行包含 M 个正整数，代表每种研究材料的价值。 2 3 1 5 4 3

链接：https://kamacoder.com/problempage.php?pid=1046

标准背包问题：有n件物品和一个最多能背重量为w 的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。

比如说背包最大容量为4。物品0,1,2的重量为1,3,4，价值为15,20,30

动规五部曲：
1 确定dp数组以及下标的含义

dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。

第一行的解释：背包容量为0，放不下物品0，此时背包里的价值为0。背包容量为1，可以放下物品0，此时背包里的价值为15.背包容量为2，依然可以放下物品0，此时背包里的价值为15。

第二行的解释：背包容量为 0，放不下物品0 或者物品1，此时背包里的价值为0。背包容量为 1，只能放下物品0，背包里的价值为15。背包容量为 2，只能放下物品0，背包里的价值为15。背包容量为 3，上一行同一状态，背包只能放物品0，这次也可以选择物品1了，背包可以放物品1 或者物品0，物品1价值更大，背包里的价值为20。背包容量为 4，上一行同一状态，背包只能放物品0，这次也可以选择物品1了，背包可以放下物品0 和物品1，背包价值为35。

2 确定递归公式

以dp[1][4]的状态来举例：有两种情况：放物品1还是不放物品1

不放物品i：背包容量为j，里面不放物品i的最大价值是dp[i - 1][j]。

放物品i：背包空出物品i的容量后，背包容量为j - weight[i]，dp[i - 1][j - weight[i]] 为背包容量为j - weight[i]且不放物品i的最大价值，那么dp[i - 1] [j - weight[i] ] + value[i] （物品i的价值），就是背包放物品i得到的最大价值。

3 dp数组如何初始化

首先从dp[i][j]的定义出发，如果背包容量j为0的话，即dp[i][0]，无论是选取哪些物品，背包价值总和一定为0。

i 是由 i-1 推导出来，那么i为0的时候就一定要初始化。dp[0][j]即i为0，存放编号0的物品的时候，各个容量的背包所能存放的最大价值。

当 j < weight[0]的时候，dp[0][j] 应该是 0，因为背包容量比编号0的物品重量还小。

当j >= weight[0]时，dp[0][j] 应该是value[0]，因为背包容量放足够放编号0物品。

java 复制代码

for (int i = 1; i < weight.size(); i++) {  // 当然这一步，如果把dp数组预先初始化为0了，这一步就可以省略，但很多同学应该没有想清楚这一点。
    dp[i][0] = 0;
}
// 正序遍历
for (int j = weight[0]; j <= bagweight; j++) {
    dp[0][j] = value[0];
}

4 确定遍历顺序

先遍历物品更好理解。

5 举例推导dp数组

java 复制代码

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        int n=scanner.nextInt();
        int bagweight=scanner.nextInt();

        int[] weight=new int[n];
        int[] value=new int[n];
        for(int i=0;i<n;++i){
            weight[i]=scanner.nextInt();
        }
        for(int j=0;j<n;++j){
            value[j]=scanner.nextInt();
        }

        int[][] dp=new int[n][bagweight+1];
        for(int j=weight[0];j<=bagweight;j++){//初始化[0][j]
            dp[0][j]=value[0];
        }

        for(int i=1;i<n;i++){
            for(int j=0;j<=bagweight;j++){
                if(j<weight[i]){
                    dp[i][j]=dp[i-1][j];
                }else{
                    dp[i][j]=Math.max(dp[i-1][j],dp[i-1][j-weight[i]]+value[i]);
                }
            }
        }

        System.out.println(dp[n-1][bagweight]);
    }
}

背包问题一维

还是上题，对于背包问题其实状态都是可以压缩的。在使用二维数组的时候，递推公式：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 其实可以发现如果把dp[i - 1]那一层拷贝到dp[i]上，表达式完全可以是：dp[i][j] = max(dp[i][j], dp[i][j - weight[i]] + value[i]);

与其把dp[i - 1]这一层拷贝到dp[i]上，不如只用一个一维数组了，只用dp[j]（一维数组，也可以理解是一个滚动数组）。这就是滚动数组的由来，需要满足的条件是上一层可以重复利用，直接拷贝到当前层。

动规五部曲分析如下：
1 确定dp数组的定义

在一维dp数组中，dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]。

2 一维dp数组的递推公式

二维dp数组的递推公式为dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

一维的在上面递推公式的基础上，去掉i这个维度就好。递推公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

dp[j]为容量为j的背包所背的最大价值。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]有两个选择，一个是取自己dp[j] 相当于二维dp数组中的dp[i-1][j]，即不放物品i，一个是取dp[j - weight[i]] + value[i]，即放物品i，指定是取最大的，毕竟是求最大价值。

3 一维dp数组如何初始化

dp[0]就应该是0，因为背包容量为0所背的物品的最大价值就是0。

那么dp数组除了下标0的位置，初始为0，其他下标应该初始化多少呢？看一下递归公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]); dp数组在推导的时候一定是取价值最大的数，如果题目给的价值都是正整数那么非0下标都初始化为0就可以了。这样才能让dp数组在递归公式的过程中取的最大的价值，而不是被初始值覆盖了。

4 一维dp数组遍历顺序

一维dp遍历的时候，背包是从大到小。为什么呢？倒序遍历是为了保证物品i只被放入一次。但如果一旦正序遍历了，那么物品0就会被重复加入多次。

5 举例推导dp数组

java 复制代码

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        int n=scanner.nextInt();
        int bagweight=scanner.nextInt();

        int[] weight=new int[n];
        int[] value=new int[n];
        for(int i=0;i<n;++i){
            weight[i]=scanner.nextInt();
        }
        for(int j=0;j<n;++j){
            value[j]=scanner.nextInt();
        }

        int[] dp=new int[bagweight+1];
        for(int i=0;i<n;i++){
            for(int j=bagweight;j>=weight[i];j--){
                dp[j]=Math.max(dp[j],dp[j-weight[i]]+value[i]);
            }
        }

        System.out.println(dp[bagweight]);
        scanner.close();
    }
}

416分割等和子集

题目：给你一个只包含正整数的非空数组 nums。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

示例 1：输入：nums = [1,5,11,5]，输出：true

解释：数组可以分割成 [1, 5, 5] 和 [11] 。

链接：https://leetcode.cn/problems/partition-equal-subset-sum/

本题的本质是，能否把容量为 sum / 2的背包装满。

既有一个只能装重量为 sum / 2 的背包，商品为数字，这些数字能不能把这个背包装满。

那每一件商品是数字的话，对应的重量和价值是多少呢？一个数字只有一个维度，即重量等于价值。当数字可以装满承载重量为 sum / 2 的背包的背包时，这个背包的价值也是 sum / 2。那么这道题就是装满承载重量为 sum / 2 的背包，价值最大是多少？如果最大价值是 sum / 2，说明正好被商品装满了。

动规五部曲：
1 确定dp数组以及下标的含义

背包中dp[j] 表示容量为j的背包，所背的物品价值最大可以为dp[j]。

如果背包所载重量为target， dp[target]就是装满背包之后的总价值，所以当 dp[target] == target 的时候，背包就装满了。

2 确定递推公式

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

3 dp数组如何初始化

dp[0]=0，其他非0下标的元素初始化为0就可以了。

4 确定遍历顺序

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

5 举例推导dp数组

java 复制代码

class Solution {
    public boolean canPartition(int[] nums) {
        if(nums.length==0 || nums==null) return false;

        int sum=0;
        for(int i:nums){
            sum=sum+i;
        }
        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;
    }
}

小结

416做完，我在想我遇到背包问题能不能认出来。。。。