背包问题——“0-1背包”，“完全背包”（这样讲，还能不会？）


    //0-1背包 二维测试代码
    /**
     * @param weight 物品重量
     * @param value 物品价值
     * @param maxWeight 背包最大容量
     * @return
     */
    public int dynamic1(int[] weight, int[] value, int maxWeight) {
        int len = weight.length;//物品数量
        int[][] dp = new int[len][maxWeight + 1];
        //初始化
        for(int i = 0; i <= maxWeight; i++) {
            if(i >= weight[0]) {
                dp[0][i] = value[0];
            }
        }
        for(int i = 1; i < len; i++) { //物品
            for(int j = 0; j <= maxWeight; 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]);
                }
            }
        }
        return dp[len - 1][maxWeight];
    }


    public static void main(String[] args) {
        Test3 test3 = new Test3();
        int[] weight = {1, 3, 4};
        int[] value = {15, 20, 30};
        test3.dynamic1(weight, value, 4);
    }

一维dp：


    /**
     * 0-1背包 一维测试
     * @param weight 物品重量
     * @param value 物品价值
     * @param maxWeight 背包最大容量
     * @return
     */
    public int dynamic2(int[] weight, int[] value, int maxWeight) {
        int len = weight.length;//物品数量
        int[] dp = new int[maxWeight + 1];
        //初始化
        for(int i = 0; i < len; i++) { //物品
            for(int j = maxWeight; j >= weight[i]; j--) {
                dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);
            }
        }
        return dp[maxWeight];
    }


    public static void main(String[] args) {
        Test3 test3 = new Test3();
        int[] weight = {1, 3, 4};
        int[] value = {15, 20, 30};
        test3.dynamic2(weight, value, 4);
    }

1.6、练习

建议三刷：

二、完全背包

2.1、完全背包解决问题

给你 i 个物品，每个物品都具有两个属性（价值value[ i ]和重量weight[ i ]），将他们放入容量为 j 的背包中（可以重复放入同一个物品），怎么放才能让背包的价值最大？

2.2、与0-1背包的区别

1. 在转移方程上，几乎没有差别；

2. 在定义dp数组上，一个是可以重复取物品，一个不可以重复取物品；

3. 对于问题“装满背包，有几种方法”这个问题上，遍历顺序上（先遍历背包还是物品？），很有考究，后文有详细讲到

4. 背包容量的遍历顺序上，无论是二维还是一维，都和0-1背包是相反的；

总的来讲，0-1背包装物品，是不可以重复装同一个物品，而完全背包，是可以重复装一个物品；

Ps：在完全背包的问题中，建议直接使用一维的dp数组，好理解，也省去了很多不必要的步骤

2.3、测试代码

二维dp：


    /**
     * 完全背包 二维测试代码
     * @param weight 物品重量
     * @param value 物品价值
     * @param maxWeight 背包最大容量
     * @return
     */
    public int dynamic(int[] weight, int[] value, int maxWeight) {
        int len = weight.length;//物品数量
        int[][] dp = new int[len][maxWeight + 1];
        //初始化
        for(int i = weight[0]; i <= maxWeight; i++) {
            dp[0][i] = dp[0][i - 1] + value[0];
        }
        for(int i = 1; i < len; i++) { //物品
            for(int j = maxWeight; j >= 0; 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]);
                }
            }
        }
        return dp[len - 1][maxWeight];
    }

    public static void main(String[] args) {
        Test3 test3 = new Test3();
        int[] weight = {1, 3, 4};
        int[] value = {15, 20, 30};
        test3.dynamic2(weight, value, 4);
    }

一维dp：


    /**
     * 完全背包 一维测试代码
     * @param weight 物品重量
     * @param value 物品价值
     * @param maxWeight 背包最大容量
     * @return
     */
    public int dynamic4(int[] weight, int[] value, int maxWeight) {
        int len = weight.length;//物品数量
        int[] dp = new int[maxWeight + 1];
        //初始化
        for(int i = 0; i < len; i++) { //物品
            for(int j = weight[i]; j <= maxWeight; j++) { //背包
                dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);
            }
        }
        return dp[maxWeight];
    }

    public static void main(String[] args) {
        Test3 test3 = new Test3();
        int[] weight = {1, 3, 4};
        int[] value = {15, 20, 30};
        test3.dynamic4(weight, value, 4);
    }

2.4、拓展问题：装满背包有几种方法？

这是一个拓展的问题，问题就是：装满背包有几种方法？

对于这类问题通解：

dp定义：从前 i 个商品中任取，装满容量为 j 的背包，有dp[ i ]种方法；

dp方程：dp[ j ] = dp[ j ] + dp[ j - weight[ i ] ]；

怎么理解？

不用想太复杂，当前背包装满的方法，就两种情况，一种是装第 i 个物品，一种是不装第 i 个物品；

求当前背包装满的方法数，就是装与不装第 i 个商品方法的总和；（这里的不装即使指，不装第 i 个物品，通过装满之前背包的方法（物品）来装满背包，所以就是dp[ j ]，用的方法一样，所以不变）;

2.5、排列与组合

上文中提到，完全背包在“装满背包，有几种方法”这个问题上，“先遍历背包还是先遍历物品？”十分有讲究，那么这个顺序有什么区别呢？往下看

2.5.1、组合

        //组合
        for(int i = 0; i < len; i++) { //物品
            for(int j = weight[i]; j <= maxWeight; j++) { //背包
                dp[i] = dp[i] + dp[i - weight[j]];
            }
        }

先遍历物品再遍历背包，得到的就是一个组合数，也就是说，不需要考虑顺序；例如得到的方法中，一组数是[1, 3, 4]，那么就不可能出现另一组数据为[3, 1, 4]；

先遍历物品再遍历背包，就出现了以上情况，为什么？

因为我们每次是拿到物品1，然后遍历一次背包，拿到物品2，再遍历一次背包......

你就可以发现他是一个有序的过程，不会出现先拿物品2，再拿物品1的情况！

更通俗来讲：先遍历物品的时候相当于是先把这个物品放进去了然后再看其他的能不能放进去，所以不会出现逆序。

2.5.2、排列

        //排列
        for(int j = 0; j <= maxWeight; j++) { //背包
            for(int i = 0; i < len; i++) { //物品
                if(i >= weight[j]) {
                    dp[i] = dp[i] + dp[i - weight[j]];
                }
            }
        }

先遍历背包再遍历物品，得到的就是一个排列数，需要考虑顺序，例如得到的方法中，一组数是[1, 3, 4]，那么就需要考虑出现另一组数据为[3, 1, 4]的情况；