01背包理论基础

01背包问题介绍

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

01背包问题可以使用回溯法进行暴力求解，不再进行详述。

举例说明：

背包最大重量为4。

物品为：

	重量	价值
物品0	1	15
物品1	3	20
物品2	4	30

问背包能背的物品最大价值是多少？

下面围绕该例子展开动态规划如何求解01背包问题。

二维dp数组解决01背包问题

根据动态规划五步曲来进行分析。

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

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

2. 确定递推公式

我们需要考虑一下如何才能推出dp[i][j]，其实就两种情况，遇到物品i的时候放入和遇到物品i的时候不放入。若不放入物品i，dp[i][j]就是dp[i - 1][j]，若放入物品i，dp[i][j]就是dp[i - 1][j - weight[i]] + value[i]。

所以递推公式为：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 3. dp数组如何初始化

首先如果背包的容量j为0的话，背包的总价值一定为零，即dp[i][0] = 0，其次由递推公式我们还可以看出，i是由i - 1推导出来的，所以我们还要初始化dp数组i为0的时候，即存放物品0的时候，各个容量的背包所能存放的总价值。其他位置全部初始为0即可。 4. 确定遍历顺序

我们可以根据递推公式确定遍历顺序，二维dp数组解决01背包问题遍历顺序较为随意。我们可以先遍历先遍历背包，再遍历物品。也可以先遍历物品，再遍历背包，先遍历物品的时候，可以选择从前到后遍历背包，也可以选择从后到前遍历背包。 5. 举例推导，不再进行展开

运行代码

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

    public static void testweightbagproblem(int[] weight, int[] value, int bagsize){
        int wlen = weight.length, value0 = 0;
        //定义dp数组：dp[i][j]表示背包容量为j时，前i个物品能获得的最大价值
        int[][] dp = new int[wlen + 1][bagsize + 1];
        //初始化：背包容量为0时，能获得的价值都为0
        for (int i = 0; i <= wlen; i++){
            dp[i][0] = value0;
        }
        //遍历顺序：先遍历物品，再遍历背包容量
        for (int i = 1; i <= wlen; i++){
            for (int j = 1; j <= bagsize; 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]);
                }
            }
        }
        //打印dp数组
        for (int i = 0; i <= wlen; i++){
            for (int j = 0; j <= bagsize; j++){
                System.out.print(dp[i][j] + " ");
            }
            System.out.print("\n");
        }
    }

一维dp数组（滚动数组）解决01背包问题

根据动态规划五步曲来进行分析。

1. 确定dp数组的含义

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

2. 递推公式 dp[j]同样是有两个选择，一个是不放入物品i，即取dp[j]本身，一个是放入物品i，即dp[j - weight[i]] + value[i]。

所以递推公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

3. 初始化dp数组

背包容量为0时，所背的最大物品容量为0，其他位置也都初始化成0就可以了。

4. 遍历顺序

一维dp数组解决背包问题的遍历顺序是非常重要的。我们必须先遍历物品，再遍历背包。在遍历背包的时候必须倒序进行遍历，以保证每个物品只会被放入一次。

5. 举例说明，不再展开

416.分割等和子集

题目链接：416. 分割等和子集

思路：使用01背包问题，只有确定了以下几点，才能够将01背包应用到这个问题上来。

• 背包的体积为sum / 2
• 背包要放入的商品（集合里的元素）重量为 元素的数值，价值也为元素的数值
• 背包如果正好装满，说明找到了总和为 sum / 2 的子集。
• 背包中每一个元素是不可重复放入。

来进行动态规划五步曲

1. dp[j] 表示背包的容量是j，最大可以凑成j的子集的总和为dp[j]
2. 递推公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i])
3. 初始化：dp[0] = 0,非0下标也都是0就可以。
4. 遍历顺序；物品（也就是数组从前到后遍历），背包容量需要倒序遍历
5. 举例证明

class Solution {
    public boolean canPartition(int[] nums) {
        // dp[j] 表示背包的容量是j，最大可以凑成j的子集的总和为dp[j]
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        if (sum % 2 != 0) return false;
        int[] dp = new int[sum / 2 + 1];
        // 递推公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i])
        // 初始化：dp[0] = 0,非0下标也都是0就可以。
        // 遍历顺序；物品（也就是数组从前到后遍历），背包容量需要倒序遍历
        for (int i = 0; i < nums.length; i++) {
            for (int j = dp.length - 1; j >= nums[i]; j--) {
                dp[j] = Math.max(dp[j], dp[j - nums[i]] + nums[i]);
            }
        }
        return dp[dp.length - 1] == sum / 2;
    }
}