提示:DDU,供自己复习使用。欢迎大家前来讨论~
动态规划Part05
完全背包理论基础
有N件物品和一个最多能背重量为W的背包。第i件物品的重量是weight[i],得到的价值是value[i] 。每件物品都有无限个(也就是可以放入背包多次),求解将哪些物品装入背包里物品价值总和最大。
完全背包和01背包问题唯一不同的地方就是,每种物品有无限件。
01背包和完全背包唯一不同就是体现在遍历顺序上,所以本文就不去做动规五部曲了,直接针对遍历顺序经行分析!
正序遍历(物品可以使用无限次),倒序遍历(物品每次只能使用一次)
01背包的核心代码:
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]);
}
}
我们知道01背包内嵌的循环是从大到小遍历,为了保证每个物品仅被添加一次。
完全背包核心代码:
完全背包的物品是可以添加多次的,所以要从小到大去遍历,即:
// 先遍历物品,再遍历背包
for(int i = 0; i < weight.size(); i++) { // 遍历物品
for(int j = weight[i]; j <= bagWeight ; j++) { // 遍历背包容量
dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
}
}
下面给出一个例子,便于理解两种背包的解法:
初始数据
- 物品重量
weight = {1, 2, 3, 4}
- 物品价值
value = {10, 21, 30, 43}
- 背包容量
bagWeight = 5
01背包问题解法:
动态规划数组初始化
我们首先初始化一个动态规划数组 dp
,其大小为背包容量加1(因为容量从0开始),初始值都为0。
vector<int> dp(bagWeight + 1, 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]);
}
}
详细步骤
我们逐步分析代码的执行过程:
初始 dp
数组
dp = [0, 0, 0, 0, 0, 0]
遍历物品1 (重量1, 价值10)
- 容量5:
dp[5] = max(0, dp[4] + 10) = max(0, 0 + 10) = 10
- 容量4:
dp[4] = max(0, dp[3] + 10) = max(0, 0 + 10) = 10
- 容量3:
dp[3] = max(0, dp[2] + 10) = max(0, 0 + 10) = 10
- 容量2:
dp[2] = max(0, dp[1] + 10) = max(0, 0 + 10) = 10
- 容量1:
dp[1] = max(0, dp[0] + 10) = max(0, 0 + 10) = 10
更新后的 dp
数组:
dp = [0, 10, 10, 10, 10, 10]
遍历物品2 (重量2, 价值21)
- 容量5:
dp[5] = max(10, dp[3] + 21) = max(10, 10 + 21) = 31
- 容量4:
dp[4] = max(10, dp[2] + 21) = max(10, 10 + 21) = 31
- 容量3:
dp[3] = max(10, dp[1] + 21) = max(10, 10 + 21) = 31
更新后的 dp
数组:
dp = [0, 10, 10, 31, 31, 31]
遍历物品3 (重量3, 价值30)
- 容量5:
dp[5] = max(31, dp[2] + 30) = max(31, 10 + 30) = 41
- 容量4:
dp[4] = max(31, dp[1] + 30) = max(31, 10 + 30) = 41
- 容量3:
dp[3] = max(31, dp[0] + 30) = max(31, 0 + 30) = 31
更新后的 dp
数组:
dp = [0, 10, 31, 31, 41, 41]
遍历物品4 (重量4, 价值43)
- 容量5:
dp[5] = max(41, dp[1] + 43) = max(41, 10 + 43) = 53
- 容量4:
dp[4] = max(41, dp[0] + 43) = max(41, 0 + 43) = 43
更新后的 dp
数组:
dp = [0, 10, 31, 31, 41, 53]
结论
最终,dp[5]
的值是53,这意味着在背包容量为5的情况下,我们可以通过选择一些物品组合得到最大价值53。
为什么倒序遍历
倒序遍历的目的是确保在计算 dp[j]
时,dp[j - weight[i]]
还没有被当前物品 i
影响。这样,我们可以确保每次计算都是基于没有包含当前物品的最优解。
通过这个例子,你可以看到倒序遍历是如何确保每个物品只被计算一次,并且每次计算都是基于正确的子问题。
完全背包解法:
动态规划数组初始化
我们同样初始化一个动态规划数组 dp
,其大小为背包容量加1(因为容量从0开始),初始值都为0。
cpp
vector<int> dp(bagWeight + 1, 0);
代码逻辑
完全背包问题的代码逻辑是两层循环:
- 外层循环遍历每个物品。
- 内层循环从当前物品的重量开始,一直遍历到背包的最大容量。
cpp
for(int i = 0; i < weight.size(); i++) { // 遍历物品
for(int j = weight[i]; j <= bagWeight; j++) { // 遍历背包容量
dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
}
}
详细步骤
我们逐步分析代码的执行过程:
初始 dp
数组
dp = [0, 0, 0, 0, 0, 0]
遍历物品1 (重量1, 价值10)
- 容量1:
dp[1] = max(0, dp[0] + 10) = max(0, 0 + 10) = 10
- 容量2:
dp[2] = max(0, dp[1] + 10) = max(0, 10 + 10) = 20
- 容量3:
dp[3] = max(0, dp[2] + 10) = max(0, 20 + 10) = 30
- 容量4:
dp[4] = max(0, dp[3] + 10) = max(0, 30 + 10) = 40
- 容量5:
dp[5] = max(0, dp[4] + 10) = max(0, 40 + 10) = 50
更新后的 dp
数组:
dp = [0, 10, 20, 30, 40, 50]
遍历物品2 (重量2, 价值21)
- 容量2:
dp[2] = max(20, dp[0] + 21) = max(20, 0 + 21) = 21
- 容量3:
dp[3] = max(30, dp[1] + 21) = max(30, 10 + 21) = 31
- 容量4:
dp[4] = max(40, dp[2] + 21) = max(40, 21 + 21) = 42
- 容量5:
dp[5] = max(50, dp[3] + 21) = max(50, 31 + 21) = 52
更新后的 dp
数组:
dp = [0, 10, 21, 31, 42, 52]
遍历物品3 (重量3, 价值30)
- 容量3:
dp[3] = max(31, dp[0] + 30) = max(31, 0 + 30) = 31
- 容量4:
dp[4] = max(42, dp[1] + 30) = max(42, 10 + 30) = 42
- 容量5:
dp[5] = max(52, dp[2] + 30) = max(52, 21 + 30) = 52
更新后的 dp
数组:
dp = [0, 10, 21, 31, 42, 52]
遍历物品4 (重量4, 价值43)
- 容量4:
dp[4] = max(42, dp[0] + 43) = max(42, 0 + 43) = 43
- 容量5:
dp[5] = max(52, dp[1] + 43) = max(52, 10 + 43) = 53
更新后的 dp
数组:
dp = [0, 10, 21, 31, 43, 53]
结论
最终,dp[5]
的值是53,这意味着在背包容量为5的情况下,我们可以通过选择一些物品组合得到最大价值53。
为什么正序遍历
在完全背包问题中,正序遍历的原因是我们需要确保在计算 dp[j]
时,dp[j - weight[i]]
表示的是包含当前物品多次的最优解。由于物品可以被无限次选取,我们从当前物品的重量开始,逐步增加容量,每次都尝试放入更多的当前物品,直到不能再放入为止。
通过这个例子,你可以看到正序遍历是如何确保每个物品可以被多次选取,并且每次计算都是基于包含当前物品多次的最优解。
完整的C++代码:
// 先遍历物品,在遍历背包
void test_CompletePack() {
vector<int> weight = {1, 3, 4};
vector<int> value = {15, 20, 30};
int bagWeight = 4;
vector<int> dp(bagWeight + 1, 0);
for(int i = 0; i < weight.size(); i++) { // 遍历物品
for(int j = weight[i]; j <= bagWeight; j++) { // 遍历背包容量
dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
}
}
cout << dp[bagWeight] << endl;
}
int main() {
test_CompletePack();
}
小结:
对于纯完全背包问题,其for循环的先后循环是可以颠倒的!
本质上是,无论你何种遍历顺序,都依赖于当前位置左侧和上侧的数据,只要两层都是正序遍历,那么左侧和上侧肯定都已经得到更新(有值),就能求当前位置的值。
二、题目
题目一:518.零钱兑换II
解题思路:
这是一道典型的背包问题,一看到钱币数量不限,就知道这是一个完全背包。
但本题和纯完全背包不一样,纯完全背包是凑成背包最大价值是多少,而本题是要求凑成总金额的物品组合个数!
注意题目描述中是凑成总金额的硬币组合数,为什么强调是组合数呢?
例如示例一:
5 = 2 + 2 + 1
5 = 2 + 1 + 2
这是一种组合,都是 2 2 1。
如果问的是排列数,那么上面就是两种排列了。
组合不强调元素之间的顺序,排列强调元素之间的顺序。(区别排列数)
动规五步曲
来分析如下:
- 确定dp数组以及下标的含义
dp[j]:凑成总金额j的货币组合数为dp[j]
- 确定递推公式
dp[j] 就是所有的dp[j - coins[i]](考虑coins[i]的情况)相加。
所以递推公式:dp[j] += dp[j - coins[i]];
这个递推公式,求装满背包有几种方法,公式都是:dp[j] += dp[j - nums[i]];
- dp数组如何初始化
在动态规划中,特别是在处理硬币找零问题或类似的组合问题时,dp[0]
的初始化为1具有特定的意义。这个初始化是问题定义的一部分,它基于一个重要的假设:能够凑成总金额为0的组合数为1。这个假设是合理的,因为“不使用任何硬币凑成金额0”本身就是一种有效的组合方式。
为什么 dp[0]
要初始化为1?
-
基础情况:在很多问题中,尤其是涉及到组合计数的问题,
dp[0]
表示凑成总金额(或总价值、总重量等)为0的方案数。在这种情况下,只有一种方式可以达到这个目标,即不使用任何物品或硬币。因此,dp[0] = 1
表示存在一种方式可以凑成0的总金额。 -
递归公式的基石:在动态规划的递推过程中,
dp[0]
作为基准值,确保了递归公式的正确性。例如,在硬币找零问题中,如果dp[j]
表示凑成金额j
的方案数,那么dp[0] = 1
确保了递归公式dp[j] = dp[j] + dp[j - coin]
在j
为0时是有效的。 -
表示一种选择:
dp[0] = 1
也可以理解为,对于任何金额j
,总有一种选择是“不使用任何硬币”,这种选择是有效的,且是唯一的。 -
确定遍历顺序
本题中我们是外层for循环遍历物品(钱币),内层for遍历背包(金钱总额),还是外层for遍历背包(金钱总额),内层for循环遍历物品(钱币)呢?
完全背包的两个for循环的先后顺序都是可以的, 但本题就不行了!
因为纯完全背包求得装满背包的最大价值是多少,和凑成总和的元素有没有顺序没关系,即:有顺序也行,没有顺序也行!
而本题要求凑成总和的组合数,元素之间明确要求没有顺序。
所以纯完全背包是能凑成总和就行,不用管怎么凑的。
本题是求凑出来的方案个数,且每个方案个数是为组合数。
那么本题,两个for循环的先后顺序可就有说法了。
我们先来看 外层for循环遍历物品(钱币),内层for遍历背包(金钱总额)的情况。
代码如下:
for (int i = 0; i < coins.size(); i++) { // 遍历物品
for (int j = coins[i]; j <= amount; j++) { // 遍历背包容量
dp[j] += dp[j - coins[i]];
}
}
假设:coins[0] = 1,coins[1] = 5。
那么就是先把1加入计算,然后再把5加入计算,得到的方法数量只有{1, 5}这种情况。而不会出现{5, 1}的情况。
所以这种遍历顺序中dp[j]里计算的是组合数!
如果把两个for交换顺序,代码如下:
for (int j = 0; j <= amount; j++) { // 遍历背包容量
for (int i = 0; i < coins.size(); i++) { // 遍历物品
if (j - coins[i] >= 0) dp[j] += dp[j - coins[i]];
}
}
背包容量的每一个值,都是经过 1 和 5 的计算,包含了{1, 5} 和 {5, 1}两种情况。
此时dp[j]里算出来的就是排列数!
建议动手把这两种方案的dp数组数值变化打印出来,对比看一看!(实践出真知)
- 举例推导dp数组
输入: amount = 5, coins = [1, 2, 5] ,dp状态图如下:
最后红色框dp[amount]为最终结果。
以上分析完毕,C++代码如下:
class Solution {
public:
int change(int amount, vector<int>& coins) {
vector<int> dp(amount + 1, 0);
dp[0] = 1;
for (int i = 0; i < coins.size(); i++) { // 遍历物品
for (int j = coins[i]; j <= amount; j++) { // 遍历背包
dp[j] += dp[j - coins[i]];
}
}
return dp[amount];
}
};
- 时间复杂度: O(mn),其中 m 是amount,n 是 coins 的长度
- 空间复杂度: O(m)
小结:
本题的递推公式,和目标和类似,而难点在于遍历顺序!
在求装满背包有几种方案的时候,认清遍历顺序是非常关键的。
如果求组合数就是外层for循环遍历物品,内层for遍历背包。
如果求排列数就是外层for遍历背包,内层for循环遍历物品。
题目三:377. 组合总和 Ⅳ
377. 组合总和 Ⅳ:求排列数
解题思路:
本题题目描述说是求组合,但又说是可以元素相同顺序不同的组合算两个组合,其实就是求排列!
弄清什么是组合,什么是排列很重要。
组合不强调顺序,(1,5)和(5,1)是同一个组合。
排列强调顺序,(1,5)和(5,1)是两个不同的排列。
但其本质是本题求的是排列总和,而且仅仅是求排列总和的个数,并不是把所有的排列都列出来。
如果本题要把排列都列出来的话,只能使用回溯算法爆搜。
动规五部曲分析如下:
- 确定dp数组以及下标的含义
dp[i]: 凑成目标正整数为i的排列个数为dp[i]
- 确定递推公式
dp[i](考虑nums[j])可以由 dp[i - nums[j]](不考虑nums[j]) 推导出来。
因为只要得到nums[j],排列个数dp[i - nums[j]],就是dp[i]的一部分。
求装满背包有几种方法,递推公式一般都是dp[i] += dp[i - nums[j]];
本题也一样。
- dp数组如何初始化
因为递推公式dp[i] += dp[i - nums[j]]的缘故,dp[0]要初始化为1,这样递归其他dp[i]的时候才会有数值基础。
至于dp[0] = 1 有没有意义呢?
其实没有意义,所以我也不去强行解释它的意义了,因为题目中也说了:给定目标值是正整数! 所以dp[0] = 1是没有意义的,仅仅是为了推导递推公式。
至于非0下标的dp[i]应该初始为多少呢?
初始化为0,这样才不会影响dp[i]累加所有的dp[i - nums[j]]。
- 确定遍历顺序
个数可以不限使用,说明这是一个完全背包。
得到的集合是排列,说明需要考虑元素之间的顺序。
本题要求的是排列,那么这个for循环嵌套的顺序可以有说法了。
如果求组合数就是外层for循环遍历物品,内层for遍历背包。
如果求排列数就是外层for遍历背包,内层for循环遍历物品。
如果把遍历nums(物品)放在外循环,遍历target的作为内循环的话,举一个例子:计算dp[4]的时候,结果集只有 {1,3} 这样的集合,不会有{3,1}这样的集合,因为nums遍历放在外层,3只能出现在1后面!
所以本题遍历顺序最终遍历顺序:target(背包)放在外循环,将nums(物品)放在内循环,内循环从前到后遍历。
- 举例来推导dp数组
用示例中的例子推导一下:
如果代码运行处的结果不是想要的结果,就把dp[i]都打出来,看看和我们推导的一不一样。
以上分析完毕,C++代码如下:
class Solution {
public:
int combinationSum4(vector<int>& nums, int target) {
vector<int> dp(target + 1, 0);
dp[0] = 1;
for (int i = 0; i <= target; i++) { // 遍历背包
for (int j = 0; j < nums.size(); j++) { // 遍历物品
if (i - nums[j] >= 0 && dp[i] < INT_MAX - dp[i - nums[j]]) {
dp[i] += dp[i - nums[j]];
}
}
}
return dp[target];
}
};
- 时间复杂度: O(target * n),其中 n 为 nums 的长度
- 空间复杂度: O(target)
C++测试用例有两个数相加超过int的数据,所以需要在if里加上dp[i] < INT_MAX - dp[i - num]。
题目四:70. 爬楼梯(进阶版)
- 爬楼梯(第八期模拟笔试)
问题描述
- 你正在爬楼梯,总共有
n
阶台阶。 - 每次你可以爬1到
m
个台阶。 - 需要计算出爬到楼顶的不同方法数。
解题思路:
这是一个经典的动态规划问题——爬楼梯问题的一个变种,这个问题可以用完全背包问题的解法来解决。
- 定义状态:定义
dp[i]
为爬到第i
阶台阶的方法数。 - 状态转移:对于每一阶台阶
i
(从1到n
),你可以从之前的1到m
阶台阶跳到这一阶。因此,dp[i]
可以从dp[i-1]
,dp[i-2]
, …,dp[i-m]
转移而来。 - 初始化:
dp[0] = 1
,表示有1种方法爬到地面(即不爬),这是基础情况。 - 计算顺序:从小到大计算
dp[i]
的值,因为计算dp[i]
需要依赖于之前台阶的方法数。 - 最终结果:
dp[n]
就是爬到第n
阶台阶的方法数。
问题难点
- 与传统的爬楼梯问题(通常每次只能爬1或2个台阶)不同,这个问题允许你每次爬1到
m
个台阶,增加了问题的复杂性。
动规五部曲分析如下:
- 确定dp数组以及下标的含义
dp[i]:爬到有i个台阶的楼顶,有dp[i]种方法。
- 确定递推公式
递推公式一般都是dp[i] += dp[i - nums[j]];
本题,dp[i]有几种来源,dp[i - 1],dp[i - 2],dp[i - 3] 等等,即:dp[i - j]
那么递推公式为:dp[i] += dp[i - j]
- dp数组如何初始化
既然递归公式是 dp[i] += dp[i - j],那么dp[0] 一定为1,dp[0]是递归中一切数值的基础所在,如果dp[0]是0的话,其他数值都是0了。
下标非0的dp[i]初始化为0,因为dp[i]是靠dp[i-j]累计上来的,dp[i]本身为0这样才不会影响结果
- 确定遍历顺序
这是背包里求排列问题,即:1、2 步 和 2、1 步都是上三个台阶,但是这两种方法不一样!
所以需将target放在外循环,将nums放在内循环。
每一步可以走多次,这是完全背包,内循环需要从前向后遍历。
- 举例来推导dp数组
本题和377. 组合总和 Ⅳ几乎是一样的。
以上分析完毕,C++代码如下:
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
while (cin >> n >> m) {
vector<int> dp(n + 1, 0);
dp[0] = 1;
for (int i = 1; i <= n; i++) { // 遍历背包
for (int j = 1; j <= m; j++) { // 遍历物品
if (i - j >= 0) dp[i] += dp[i - j];
}
}
cout << dp[n] << endl;
}
}
- 时间复杂度: O(n * m)
- 空间复杂度: O(n)
代码中m表示最多可以爬m个台阶,代码中把m改成2就是 力扣:70.爬楼梯的解题思路。
总结
完全背包理论
-
无限使用:每种物品可以无限使用,没有数量限制。
-
状态转移:当前物品的价值是之前所有价值的累加,即
dp[j] += dp[j - weight[i]]
,表示加上当前物品后的新价值。 -
循环顺序:通常从小到大遍历物品和背包容量,确保每次计算时使用的是未包含当前物品的旧价值。