【经典专题】从模板到本质——背包问题

算法定义

背包问题(Knapsack problem)是一种组合优化的NP完全问题。问题可以描述为：给定一组物品，每种物品都有自己的重量和价格，在限定的总重量内，我们如何选择，才能使得物品的总价格最高。

不想看定义？那么接着看下面的通俗栗子：

给定一个nums[]数组，再给定一个背包容量target，你能否用nums[]中的物品装满背包呢？

 
 

问题分类

首先，根据数组中的元素是否可以重复使用，背包问题分为：

❶ 0-1背包：数组中的元素不能重复使用
❷ 完全背包：数组中的元素可以重复使用

接着，根据题设的目的，背包问题又分为：

❶ 考虑顺序的组合问题
❷ 不考虑顺序的组合问题
❸ True/False问题
❹ 最大最小值问题

 
 

解题模板

幸运的是，背包问题有一套万用的模板，可以帮你解决99%的背包问题！

---

0-1背包

for (int num : nums) {
	for (int i = target; i >= num; i--) {
		// 状态转移
	}
}

完全背包

for (int num : nums) {
	for (int i = num; i <= target; i++) {
		// 状态转移
	}
}

---

组合问题

// 初始化
dp[0] = 1

// 状态转移
dp[i] += dp[i - num]

True/False问题

// 初始化
dp[0] = true

// 状态转移
dp[i] |= dp[i - num]

最大最小值问题

// 初始化
Arrays.fill(dp ,逻辑上可以取到的最大/最小值)
dp[0] = 0

// 状态转移
dp[i] = Math.max(dp[i], dp[i - num] + 1)
dp[i] = Math.min(dp[i], dp[i - num] + 1)

 
 

特殊情况

有一个上面的解题模板中没有提到的特殊情况：考虑顺序的组合问题/不考虑顺序的组合问题的区别。

// 不考虑顺序的组合问题
for (num)
	for (i)

// 考虑顺序的组合问题
for (i)
	for (num)

 
 

题目练习

Q1：硬币凑钱

给你一个整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。
请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0 。
假设每一种面额的硬币有无限个。
 
输入：amount = 5, coins = [1, 2, 5]
输出：4
解释：有四种方式可以凑成总金额：
5=5
5=2+2+1
5=2+1+1+1
5=1+1+1+1+1

class Solution {
    public int change(int amount, int[] coins) {
        // 完全背包
        // 不考虑顺序的组合问题
        int[] dp = new int[amount + 1];
        dp[0] = 1;
        for (int coin : coins) {
            for (int i = coin; i <= amount; i++) {
                dp[i] += dp[i - coin];
            }
        }
        return dp[amount];
    }
}

Q2：组合总和

给你一个由 不同 整数组成的数组 nums ，和一个目标整数 target 。请你从 nums 中找出并返回总和为 target
的元素组合的个数。顺序不同的序列被视作不同的组合。
 
输入：nums = [1,2,3], target = 4
输出：7
解释：(1, 1, 1, 1) (1, 1,2) (1, 2, 1) (1, 3) (2, 1, 1) (2, 2) (3, 1)

class Solution {
    public int combinationSum4(int[] nums, int target) {
        // 完全背包
        // 考虑顺序的组合问题
        int[] dp = new int[target + 1];
        dp[0] = 1;
        for (int i = 0; i <= target; i++) {
            for (int num : nums) {
                if (i - num >= 0) {
                    dp[i] += dp[i - num];
                }
            }
        }
        return dp[target];
    }
}

Q3：目标和

给你一个整数数组 nums 和一个整数 target 。
向数组中的每个整数前添加 ‘+’ 或 ‘-’ ，然后串联起所有整数，可以构造一个 表达式 ：
 
输入：nums = [1,1,1,1,1], target = 3
输出：5
解释：一共有 5 种方法让最终目标和为 3 。
-1 + 1 + 1 + 1 + 1 = 3
+1 - 1 + 1 + 1 + 1 = 3
+1 + 1 - 1 + 1 + 1 = 3
+1 + 1 + 1 - 1 + 1 = 3
+1 + 1 + 1 + 1 - 1 = 3

/*
 * 隐含的背包问题，下面是推导过程：
 * sum(+)-sum(-)=target
 * sum(+)-sum(-)+sum(+)+sum(-)=target+sum(+)+sum(-)
 * 2*sum(+)=target+sum
 * sum(+)=(target+sum)/2
 */
class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int sum = Arrays.stream(nums).sum();
        if (sum < target || ((sum + target) & 1) == 1) {
            return 0;
        }

        // 0-1背包
        // 不考虑顺序的组合问题
        int tmp = (sum + target) / 2;
        int[] dp = new int[tmp + 1];
        dp[0] = 1;
        for (int num : nums) {
            for (int i = tmp; i >= num; i--) {
                dp[i] += dp[i - num];
            }
        }
        return dp[tmp];
    }
}

Q4：分割等和子集

给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。
 
输入：nums = [1,5,11,5]
输出：true
解释：数组可以分割成 [1, 5, 5] 和 [11] 。

class Solution {
    public boolean canPartition(int[] nums) {
        int sum = Arrays.stream(nums).sum();
        if ((sum & 1) == 1) {
            return false;
        }
        int target = sum / 2;

        // 0-1背包
        // True/False问题
        boolean[] dp = new boolean[target + 1];
        dp[0] = true;
        for (int num : nums) {
            for (int i = target; i >= num; i--) {
                dp[i] |= dp[i - num];
            }
        }
        return dp[target];
    }
}

Q5：硬币凑钱2.0

给定不同面额的硬币 coins 和一个总金额amount。
编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。
你可以认为每种硬币的数量是无限的。
 
输入：coins = [1, 2, 5], amount = 11
输出：3
解释：11 = 5 + 5 + 1

class Solution {
    public int coinChange(int[] coins, int amount) {
        // 完全背包
        // 最大最小值问题
        int[] dp = new int[amount + 1];
        Arrays.fill(dp, amount + 1);
        dp[0] = 0;
        for (int coin : coins) {
            for (int i = coin; i <= amount; i++) {
                dp[i] = Math.min(dp[i], dp[i - coin] + 1);
            }
        }
        return dp[amount] == amount + 1 ? -1 : dp[amount];
    }
}

Q6：完全平方数

给定正整数 n，找到若干个完全平方数（比如 1, 4, 9, 16, …）使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。
 
完全平方数 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。
 
输入：n = 13
输出：2
解释：13 = 4 + 9

class Solution {
    public int numSquares(int n) {
        // 完全背包
        // 最大最小值问题
        int[] dp = new int[n + 1];
        Arrays.fill(dp ,100);
        dp[0] = 0;
        for (int num = 1; num <= 100; num++) {
            for (int i = num * num; i <= n; i++) {
                dp[i] = Math.min(dp[i], dp[i - num * num] + 1);
            }
        }
        return dp[n];
    }
}

 
 

原理深究

这里，我们将彻底弄明白上面遗留下的一个问题：为什么对于0-1背包和完全背包，for i 时候的顺序不同呢？具体地说，为什么一个是i++，一个是i–？

让我们回到最初的背包问题——一共有N件物品，第i（i从1开始）件物品的重量为w[i]，价值为v[i]。在总重量不超过背包承载上限W的情况下，能够装入背包的最大价值是多少？

这最初是一个二维DP问题。对于0-1背包和完全背包，dp[i][j]的含义有些许不同：

dp[i][j]表示将前i「件」物品装进限重为j的背包可以获得的最大价值（0-1背包）
dp[i][j]表示将前i「种」物品装进限重为j的背包可以获得的最大价值（完全背包）

明确了含义，不难想到状态转移方程：

dp[i][j] = max(dp[i−1][j], dp[i−1][j−w[i]]+v[i])	// 0-1背包
dp[i][j] = max(dp[i−1][j], dp[i][j−w[i]]+v[i]) 		// 完全背包

思考一下，上面两个状态转移方程不同的原因是什么？
很简单，对于0-1背包，第i个物品不能用；对于完全背包，第i个物品可以用。

下面，关键来了！

不难看出，上面的两个状态转移方程都可以通过滚动数组进行降维优化。滚动数组的本质是什么？在不影响其他状态转移的前提下，进行状态值的覆盖，从而复用了数组空间。

0-1背包和完全背包不同的 for i 顺序，正是因为0-1背包避免覆盖，而完全背包需要覆盖。

 
 

写在后面

最后，总结一下这类题目的解题流程吧！

1）拿到题目，判断它是不是背包问题，或者能否转化为背包问题；

2）判断背包问题种类。0-1背包/完全背包影响for循环，组合问题/TrueFalse问题/最大最小值问题影响状态转移方程；

3）如果是组合问题，多判断一下是否需要考虑顺序，这影响for循环的嵌套关系；

4）套用模板即可。

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

$END$