算法：背包问题<一>

1. 背包问题简介

1.1 背包问题的定义

背包问题：背包问题是线性 DP 问题中一类经典而又特殊的模型。背包问题可以描述为：给定一组物品，每种物品都有自己的重量、价格以及数量。再给定一个最多能装重量为 W 的背包。现在选择将一些物品放入背包中，请问在总重量不超过背包载重上限的情况下，能装入背包的最大价值总和是多少？

根据物品限制条件的不同，背包问题可分为：0-1 背包问题、完全背包问题、多重背包问题、分组背包问题，以及混合背包问题等。

1.2 背包问题的暴力解题思路

背包问题的暴力解题思路比较简单。假设有 n 件物品。我们先枚举出这 n 件物品所有可能的组合。然后再判断这些组合中的物品是否能放入背包，以及是否能得到最大价值。这种做法的时间复杂度是 O(2ⁿ)。

背包问题暴力解法的时间复杂度是指数级别的，我们可以利用动态规划算法减少一下时间复杂度。

下面我们来讲解一下如何使用动态规划方法解决各种类型的背包问题。

2. 0-1 背包问题

0-1 背包问题：有 n 件物品和有一个最多能装重量为 W 的背包。第 i 件物品的重量为 weight[i]，价值为 value[i]，每件物品有且只有 1 件。请问在总重量不超过背包载重上限的情况下，能装入背包的最大价值是多少？

2.1 0-1 背包问题基本思路

0-1 背包问题的特点：每种物品有且仅有 1 件，可以选择不放入背包，也可以选择放入背包。

思路 1：动态规划 + 二维基本思路

1.划分阶段

按照物品的序号、当前背包的载重上限进行阶段划分。

2.定义状态

定义状态 dp[i] [w]表示为：前 i 件物品(此处不包括 i )放入一个最多能装重量为 w 的背包中，可以获得的最大价值。

状态 dp[i] [w] 是一个二维数组，其中第一维代表「当前正在考虑的物品」，第二维表示「当前背包的载重上限」，二维数组值表示「可以获得的最大价值」。

3.状态转移方程

对于「将前 i 件物品放入一个最多能装重量为 w 的背包中，可以获得的最大价值」这个子问题，如果我们只考虑第 i−1 件物品（前 i 件物品中最后一件物品）的放入策略（放入背包和不放入背包两种策略）。则问题可以转换为一个只跟前 i−1件物品相关的问题。

第 i−1件物品不放入背包：问题转换为「前 i−1 件物品放入一个最多能装重量为 w 的背包中，可以获得的最大价值」为 dp[i−1] [w]。
第 i−1 件物品放入背包：问题转换为「前 i−1件物品放入一个最多能装重量为 w−weight[i−1]的背包中，可以获得的最大价值」为 dp[i−1] [w−weight[i−1]]，再加上「放入的第 i−1件物品的价值」为 value[i−1]，则此时可以获得的最大价值为 dp[i−1] [w−weight[i−1]]+value[i−1]。

接下来我们再来考虑一下第 i−1 件物品满足什么条件时才能考虑是否放入背包，并且在什么条件下一定不能放入背包。

如果当前背包的载重不足时（即 w<weight[i−1]）：第 i−1件物品一定不能放入背包，此时背包的价值 dp[i] [w]仍为 dp[i−1] [w]时的价值，即 dp[i] [w]=dp[i−1] [w]。
如果当前背包的载重足够时（即 w≥weight[i−1]）：第 i−1件物品可以考虑放入背包，或者不放入背包，此时背包的价值取两种情况下的最大值，即 dp[i] [w]=max{dp[i−1] [w],dp[i−1] [w−weight[i−1]]+value[i−1]}。

则状态转移方程为：

4.初始条件

如果背包载重上限为 0，则无论选取什么物品，可以获得的最大价值一定是 0，即 dp[i] [0]=0,0≤i≤size。
无论背包载重上限是多少，前 0 件物品所能获得的最大价值一定为 0，即 dp[0] [w]=0,0≤w≤W。

5.最终结果

根据我们之前定义的状态，dp[i] [w]表示为：前 i 件物品放入一个最多能装重量为 w 的背包中，可以获得的最大价值。则最终结果为 dp[size] [W]，其中 size为物品的件数，W 为背包的载重上限。

思路 1：代码

 public int zeroOnePackMethod1(int[] weight, int[] value, int W) {
        int size = weight.length;
        int[][] dp = new int[size + 1][W + 1];

        // 枚举前 i 种物品
        for (int i = 1; i <= size; i++) {
            // 枚举背包装载重量
            for (int w = 0; w <= W; w++) {
                // 第 i - 1 件物品装不下
                if (w < weight[i - 1]) {
                    // dp[i][w] 取「前 i - 1 件物品装入载重为 w 的背包中的最大价值」
                    dp[i][w] = dp[i - 1][w];
                } else {
                    // dp[i][w] 取「前 i - 1 件物品装入载重为 w 的背包中的最大价值」与「前 i - 1 件物品装入载重为 w - weight[i - 1] 的背包中，再装入第 i - 1 物品所得的最大价值」两者中的最大值
                    dp[i][w] = Math.max(dp[i - 1][w], dp[i - 1][w - weight[i - 1]] + value[i - 1]);
                }
            }
        }

        return dp[size][W];
}

思路 1：复杂度分析

时间复杂度：O(n×W)，其中 n 为物品数量，W 为背包的载重上限。
空间复杂度：O(n×W)。

2.2 0-1 背包问题滚动数组优化

根据之前的求解过程可以看出：当我们依次处理前 1∼n件物品时，「前 i 件物品的处理结果」只跟「前 i−1 件物品的处理结果」，而跟之前更早的处理结果没有太大关系。

也就是说在状态转移的过程中，我们只用到了当前行（第 i 行）的 dp[i] [w]以及上一行（第 i−1 行）的 dp[i−1] [w]、dp[i−1] [w−weight[i−1]]。

所以我们没必要保存所有阶段的状态，只需要保存上一阶段的所有状态和当前阶段的所有状态就可以了，这样使用两个一维数组分别保存相邻两个阶段的所有状态就可以实现了。即：用 dp[0] [w]保存原先 dp[i−1] [w] 的状态，用 dp[1] [w]保存当前 dp[i] [w]的状态。

其实我们还可以进一步进行优化，我们只需要使用一个一维数组 dp[w]保存上一阶段的所有状态，采用使用「滚动数组」的方式对空间进行优化（去掉动态规划状态的第一维）。

思路 2：动态规划 + 滚动数组优化

1.划分阶段

按照当前背包的载重上限进行阶段划分。

2.定义状态

定义状态 dp[w] 表示为：将物品装入最多能装重量为 w 的背包中，可以获得的最大价值。

3.状态转移方程

4.初始条件

无论背包载重上限为多少，只要不选择物品，可以获得的最大价值一定是 0，即 dp[w]=0,0≤w≤W。

5.最终结果

根据我们之前定义的状态， dp[w]表示为：将物品装入最多能装重量为 w 的背包中，可以获得的最大价值。则最终结果为 dp[W]，其中 W 为背包的载重上限。

思路 2：代码

 public int zeroOnePackMethod2(int[] weight, int[] value, int W) {
        int size = weight.length;
        int[] dp = new int[W + 1];

        // 枚举前 i 种物品
        for (int i = 1; i <= size; i++) {
            // 逆序枚举背包装载重量（避免状态值错误）
            for (int w = W; w >= weight[i - 1]; w--) {
                // dp[w] 取「前 i - 1 件物品装入载重为 w 的背包中的最大价值」与「前 i - 1 件物品装入载重为 w - weight[i - 1] 的背包中，再装入第 i - 1 物品所得的最大价值」两者中的最大值
                dp[w] = Math.max(dp[w], dp[w - weight[i - 1]] + value[i - 1]);
            }
        }

        return dp[W];
}

思路 2：复杂度分析

时间复杂度：O(n×W)，其中 n 为物品数量，W 为背包的载重上限。
空间复杂度：O(W)。

2.3 0-1 背包问题的应用

2.3.1 题目链接

416. 分割等和子集 - 力扣open in new window

2.3.2 题目大意

描述：给定一个只包含正整数的非空数组 nums。

要求：判断是否可以将这个数组分成两个子集，使得两个子集的元素和相等。

说明：

1≤nums.length≤200。
1≤nums[i]≤100。

示例：

示例 1：

1
2
3

输入：nums = [1,5,11,5]
输出：true
解释：数组可以分割成 [1, 5, 5] 和 [11]。

示例 2：

1
2
3

输入：nums = [1,2,3,5]
输出：false
解释：数组不能分割成两个元素和相等的子集。

2.3.3 解题思路

思路 1：动态规划

1.划分阶段

按照当前背包的载重上限进行阶段划分。

2.定义状态

定义状态 dp[w]表示为：从数组 nums 中选择一些元素，放入最多能装元素和为 w 的背包中，得到的元素和最大为多少。

3.状态转移方程

4.初始条件

无论背包载重上限为多少，只要不选择物品，可以获得的最大价值一定是 0，即 dp[w]=0,0≤w≤W。

5.最终结果

思路 1：代码

public int zeroOnePackMethod2(int[] weight, int[] value, int W) {
        int size = weight.length;
        int[] dp = new int[W + 1];

        // 枚举前 i 种物品
        for (int i = 1; i <= size; i++) {
            // 逆序枚举背包装载重量（避免状态值错误）
            for (int w = W; w >= weight[i - 1]; w--) {
                // dp[w] 取「前 i - 1 件物品装入载重为 w 的背包中的最大价值」与「前 i - 1 件物品装入载重为 w - weight[i - 1] 的背包中，再装入第 i - 1 物品所得的最大价值」两者中的最大值
                dp[w] = Math.max(dp[w], dp[w - weight[i - 1]] + value[i - 1]);
            }
        }

        return dp[W];
    }
public boolean canPartition(int[] nums) {
        int sumNums = Arrays.stream(nums).sum();
        if ((sumNums & 1) == 1) {
            return false;
        }

        int target = sumNums / 2;
        return zeroOnePackMethod2(nums, nums, target) == target;
}

思路 1：复杂度分析

时间复杂度：O(n×target)，其中 n 为数组 nums 的元素个数，target是整个数组元素和的一半。
空间复杂度：O(target)。