代码随想录---01背包问题

01背包问题的基础一：

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

dp二维数组01背包：动态规划五部曲：

第一步：

确定dp数组的含义：dp[i][j] 是表示从下标[0-i]的物品中任意取，放入容量为j的背包中，价值总和是多少。

第二步：

确定递推公式：dp[i][j]的含义是从下标[0-i] 的物品中任意选取，放进容量为j的背包中，得到的价值总和是多少。

dp[i][j]可以由两个方向得来：

不放物品i:

由dp[i - 1][j]推出，即背包容量为j，里面不放物品i的最大价值，此时dp[i][j]就是dp[i - 1][j]。(其实就是当物品i的重量大于背包j的重量时，物品i无法放进背包中，所以被背包内的价值依然和前面相同。)放不进取物品i。

放物品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的价值），就是背包放物品i得到的最大价值。

递推公式：dp[i][j]=max(dp[i-1][j],dp[i-1][j-weight[i]] +values[i])

第三步：初始化dp数组

dp数组的第一行和第一列是需要初始化的。第一行背包重量不为0的那个点；初始化为第一个物品的重量，第一列初始化为0。

第四步：先遍历物品再遍历背包重量。也可以先遍历背包重量，再遍历物品。

第五步：递推dp数组。

public class 背包问题_01 {

    public static void main(String[] args) {

        int [] weight={1,3,4};// 每个物品的重量；
        int [] value={15,20,30}; //每个物品的价值
        int bagsize=4;//背包容量；
        testWeight_Bag(weight,value,bagsize);
    }


    public static void testWeight_Bag(int [] weight,int [] value ,int bagsize){
        //确定dp[][] ,初始化的数组就是全是0
        int[][] dp=new int[weight.length][bagsize+1];  //多一列，因为要从0开始，把背包的为0的重量也加入进来

        //确定递推公式 dp[i][j]=max(dp[i-1][j],dp[i-1][j-weight[i]] + value[i])
        //初始dp
        for (int j=weight[0];j<=bagsize;j++){
            dp[0][j]=value[0]; //给第一行赋值，赋值是第一个物品的价值；
        }
        
        //确定遍历顺序；
        for (int i=1;i< weight.length;i++){

            //背包的容量：
            for (int j=1;j<=bagsize;j++){
                if (j< weight[i]){
                    //如果背包的容量小于第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]);
                }
            }
        }
        //打印dp
        System.out.println("背包问题打印dp数组：");
        for (int i=0;i< weight.length;i++){

            for (int j=0;j<=bagsize;j++){
                System.out.print(dp[i][j] + "\t"); //加入制表符；
            }
            System.out.println("\n");
        }

    }
}

背包问题打印dp数组：
0	15	15	15	15	

0	15	15	20	35	

0	15	15	20	35	

01背包问题基础二：

一维dp数组（滚动数组）

对于背包问题其实状态都是可以压缩的。

在使用二维数组的时候，递推公式：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

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

其实可以发现如果把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]（一维数组，也可以理解是一个滚动数组）。

动规五部曲分析如下：

• 确定dp数组的定义

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

• 一维dp数组的递推公式

dp[j]可以通过dp[j - weight[i]]推导出来，dp[j - weight[i]]表示容量为j - weight[i]的背包所背的最大价值。

此时dp[j]有两个选择，一个是取自己dp[j] 相当于 二维dp数组中的dp[i-1][j]，即不放物品i，一个是取dp[j - weight[i]] + value[i]，即放物品i，指定是取最大的，毕竟是求最大价值，

dp[j]=max(dp[j],dp[j-weight[i]] + value[i]);

• 一维dp数组如何初始化

关于初始化，一定要和dp数组的定义吻合，否则到递推公式的时候就会越来越乱。

dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]，那么dp[0]就应该是0，因为背包容量为0所背的物品的最大价值就是0。

dp数组在推导的时候一定是取价值最大的数，如果题目给的价值都是正整数那么非0下标都初始化为0就可以了。

• 遍历顺序：先遍历物品，然后遍历背包，而且背包的遍历顺序是倒叙的。这样才能保证每个物品只能使用一次。

遍历背包的容量需要倒叙，因为这样不会重复利用前面的数据。

for(int i = 0; i < weight.size(); i++) { // 遍历物品
    for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
        dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

    }
}

• 推导遍历数组的数据

public class 背包问题_02 {
    public static void main(String[] args) {
        int [] weight={1,3,4};// 每个物品的重量；
        int [] value={15,20,30}; //每个物品的价值
        int bagsize=4;//背包容量；
        testWeight_Bag(weight,value,bagsize);

    }

    public static void testWeight_Bag(int [] weight,int [] value,int bagsize){
        int weight_len= weight.length;
        //定义的数组，初始化就是0
        int [] dp=new int[bagsize+1];

        //顺序遍历先遍历物品，再倒叙遍历背包；
       for (int i=0;i<weight_len;i++){

           for (int j=bagsize;j>=weight[i];j--){

                dp[j]=Math.max(dp[j],dp[j-weight[i]] + value[i]);
           }
       }
        //打印dp数组
        for (int j = 0; j <= bagsize; j++){
            System.out.print(dp[j] + " ");
        }
    }
}