01背包
有n件物品和⼀个最多能背重量为w 的背包。第i件物品的重量是weight[i],得到的价值是value[i] 。每件物品只能用一次,求解将哪些物品装入背包里物品价值总和最大。
这是标准的背包问题
举⼀个例⼦:
背包最大重量为4。
物品为:
问背包能背的物品最大价值是多少?
以下讲解和图示中出现的数字都是以这个例子为例。
⼆维dp数组01背包
1. 确定dp数组以及下标的含义
对于背包问题,有⼀种写法, 是使用⼆维数组,即dp[i][j] 表示从下标为[0-i]的物品里任意取,放进容量为j的背包,价值总和最大是多少。
2. 确定递推公式
再回顾⼀下 dp[i][j] 的含义:从下标为[0-i]的物品⾥任意取,放进容量为j的背包,价值总和最大是多少。
那么可以有两个方向推出来dp[i][j],
不放物品i:由dp[i - 1][j]推出,即背包容量为j,里面不放物品i的最大价值,此时dp[i][j]就是dp[i - 1][j]。(其 实就是当物品i的重量⼤于背包j的重量时,物品i无法放进背包中,所以背包内的价值依然和前面相同。)
放物品i:由dp[i - 1][j - weight[i]]推出,dp[i - 1][j - weight[i]] 为背包容量为j - weight[i]的时候不放物品i的最大价值,那么dp[i - 1][j - weight[i]] + value[i] (物品i的价值),就是背包放物品 i 得到的最大价值
所以递归公式: dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
3. dp数组如何初始化
关于初始化,⼀定要和dp数组的定义吻合,否则到递推公式的时候就会越来越乱。 首先从dp[i][j]的定义出发,如果背包容量j为0的话,即dp[i][0],无论是选取哪些物品,背包价值总和⼀定为0。如图:
在看其他情况。
状态转移方程 dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
可以看出i 是由 i-1 推导出来,那么i为0的 时候就⼀定要初始化。
dp[0][j],即:i为0,存放编号0的物品的时候,各个容量的背包所能存放的最大价值。
那么很明显当 j < weight[0]的时候,dp[0][j] 应该是 0,因为背包容量比编号0的物品重量还⼩。
当j >= weight[0]时,dp[0][j] 应该是value[0],因为背包容量放足够放编号0物品。
代码初始化如下
此时dp数组初始化情况如图所示:
dp[0][j] 和 dp[i][0] 都已经初始化了,那么其他下标应该初始化多少呢?
其实从递归公式: dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 可以看出dp[i][j] 是由左上⽅数值推 导出来了,那么 其他下标初始为什么数值都可以,因为都会被覆盖。
初始-1,初始-2,初始100,都可以! 但只不过⼀开始就统⼀把dp数组统⼀初始为0,更方便⼀些。
如图:
4. 确定遍历顺序
在如下图中,可以看出,有两个遍历的维度:物品与背包重量
那么问题来了,先遍历 物品还是先遍历背包重量呢?
其实都可以!! 但是先遍历物品更好理解。
以下代码为先遍历物品再遍历背包
为什么都可以的呢?
要理解递归的本质和递推的方向。
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
递归公式中可以看出dp[i][j]是靠dp[i-1][j]和dp[i - 1][j - weight[i]]推导出来的。
dp[i-1][j]和dp[i - 1][j - weight[i]] 都在dp[i][j]的左上角方向(包括正上方向),那么先遍历物品,再遍历背包的过程如图所示:
再来看看先遍历背包,再遍历物品呢,如图:
大家可以看出,虽然两个for循环遍历的次序不同,但是 dp[i][j] 所需要的数据就是左上角,根本不影响 dp[i][j] 公式 的推导!
但先遍历物品再遍历背包这个顺序更好理解。
其实背包问题⾥,两个for循环的先后循序是非常有讲究的,理解遍历顺序其实比理解推导公式难多了
5.打印dp数组
最后的ac代码
⼀维dp数组(滚动数组)
背包最⼤重量为4。
物品为:
问背包能背的物品最大价值是多少?
对于背包问题其实状态都是可以压缩的。
在使用⼆维数组的时候,递推公式:dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
其实可以发现如果把dp[i - 1]那⼀层拷贝到dp[i]上,表达式完全可以是:dp[i][j] = max(dp[i][j], dp[i][j - weight[i]] + value[i]);
与其把dp[i - 1]这⼀层拷贝到dp[i]上,不如只用⼀个⼀维数组了,只⽤dp[j](⼀维数组,也可以理解是⼀个滚动数组。
这就是滚动数组的由来,需要满足的条件是上⼀层,它可以重复利用,直接拷贝到当前层。
1. 确定dp数组的定义
在⼀维dp数组中,dp[j]表示:容量为j的背包,所背的物品价值可以最大为dp[j]
2. ⼀维dp数组的递推公式
dp[j]为 容量为j的背包所背的最大价值,那么如何推导dp[j]呢?
dp[j]可以通过dp[j - weight[i]]推导出来,dp[j - weight[i]]表示容量为j - weight[i]的背包所背的最⼤价值。
dp[j - weight[i]] + value[i] 表示 容量为 j - 物品 i 重量 的背包加上物品 i 的价值。(也就是容量为 j 的背包,放入物品 i 了之后的价值即:dp[j])
此时dp[j]有两个选择,⼀个是取自己dp[j]相当于⼆维dp数组中的dp[i-1][j],即不放物品i,⼀个是取dp[j - weight[i]] + value[i],即放物品i,指定是取最大的,毕竟是求最大价值, 所以递归公式为:
3. ⼀维dp数组如何初始化
关于初始化,⼀定要和dp数组的定义吻合,否则到递推公式的时候就会越来越乱。
dp[j]表示:容量为 j的背包,所背的物品价值可以最大为dp[j],那么dp[0]就应该是0,因为背包容量为0所背的物品 的最大价值就是0。
那么dp数组除了下标0的位置,初始为0,其他下标应该初始化多少呢?
看⼀下递归公式:dp[j] = max(dp[j], dp[j - weight[i]] + value[i])
dp数组在推导的时候⼀定是取价值最大的数,如果题目给的价值都是正整数那么非0下标,那都初始化为0就可以了。
这样才能让dp数组在递归公式的过程中取的最大的价值,而不会被初始值覆盖了。
那么我假设物品价值都是大于0的,所以dp数组初始化的时候,都初始为0就可以了。
4. ⼀维dp数组遍历顺序
代码如下:
这里大家发现和⼆维dp的写法中,遍历背包的顺序是不⼀样的!
⼆维dp遍历的时候,背包容量是从小到大,而⼀维dp遍历的时候,背包是从大到小。
为什么呢?
倒序遍历是为了保证物品i只被放入一次!
但如果⼀旦正序遍历了,那么物品0就会被重复加入多次!
举⼀个例子:物品0的重量weight[0] = 1,价值value[0] = 15
如果正序遍历
dp[1] = dp[1 - weight[0]] + value[0] = 15
dp[2] = dp[2 - weight[0]] + value[0] = 30
此时dp[2]就已经是30了,意味着物品0,被放入了两次,所以不能正序遍历。
为什么倒序遍历,就可以保证物品只放入一次呢?
倒序就是先算dp[2]
dp[2] = dp[2 - weight[0]] + value[0] = 15 (dp数组已经都初始化为0)
dp[1] = dp[1 - weight[0]] + value[0] = 15
因为动态规划是从前面的状态来推导出后面的状态,如果先推导后面的状态,这样就不会和之前取得状态重合,这样每种物品就只取⼀次了。
那么问题又来了,为什么⼆维dp数组历的时候不用倒序呢?
因为对于⼆维dp,dp[i][j]都是通过上⼀层即dp[i - 1][j]计算而来,本层的dp[i][j]并不会被覆盖!
再来看看两个嵌套for循环的顺序,代码中是先遍历物品嵌套遍历背包容量,那可不可以先遍历背包容量嵌套遍历物品呢?
不可以!
因为⼀维dp的写法,背包容量⼀定是要倒序遍历(原因上面已经讲了),如果遍历背包容量放在上⼀层,那么每个 dp[j]就只会放入⼀个物品,即:背包里只放入了⼀个物品。
倒序遍历的原因是,本质上还是⼀个对⼆维数组的遍历,并且右下角的值依赖上⼀层左上角的值,因此需要保证左边的值仍然是上一层的,从右向左覆盖。
所以⼀维dp数组的背包在遍历顺序上和⼆维其实是有很大差异的!
5. 打印dp数组
最后的ac代码
有依赖背包
概念
多个物品变成一个复合物品(互斥),每件复合物品不要和怎么要多种可能性展开
不能用01背包来解,但是非常重要的问题
有依赖的背包问题一般会有一定的限制条件,例如选择某一件的前提是选择了另一件物品, 选第 i 件物品,就必须选择第 j 件物品,保证不会循环引用。
一般我们称呼不依赖于别的物品的物品为主件,依赖于某主件的物品称为附件
对于包含一个主件 和若干个附件 的结合由以下可能性:
1、不要该主件
2、仅选择主件
3、选择主件再选择一个附件
4、选择主件再选择两个附件
............
n、选择主件再选择全部的附件
我们假设以下情况:
因此我们可以做出下表:
因此我们可以考虑一下的状态
1、不要该主件
2、仅选择主件
3、选择主件再选择一个附件
4、选择主件再选择两个附件
............
n、选择主件再选择全部的附件
我们要定义三个数组
bool king[ ] :表示 i 号商品是否是主件商品 (用于当遍历到 i 物品时,考虑是否要对其考虑附件)
int fans[ ] :表示 i 号商品有几个附件
int follow[ i ][ j ] :用于记录 i 号商品的附件的序号(如果没有附件,就是为空数组)
代码:
# include <stdio.h>
# include <string.h>
int n; //总金额
int m; //商品数量
int follow[100][2];
int king[100];
int fan[100];
int cost[100];
int val[100];
int dp[100];
int com()
{
int dp[m+1][n+1]; //dp[i][j] 表示0~i中只关心主商品,并且进行展开
//花费不超过 j 的最大价值
int p = 0; //上次展开的主商品编号
for (int i=1; i<=m; ++i)
{
if (king[i])
{
for (int j=0; j<n; ++j)
{
dp[i][j] = dp[p][j]; // 可能性1:不考虑主商品
if ( j >= cost[i]) // 可能性2:只考虑主商品
dp[i][j] = max(dp[i][j], dp[i][j-cost[i]] + val[i]);
int fan1; //如果有一个附件,编号给fan1,不然-1
int fan2; //如果有两个附件,编号给fan2,不然-1
if (fan[i] >= 1)
fan1 = fan[i][0];
else
fan1 = -1;
if (fan[i] >= 2)
fan2 = fan[i][1];
else
fan2 = -1;
if (fan1 != -1 && j-cost[i]-cost[fan1] >= 0) //可能性3:要主件和一个附件1
dp[i][j] = max(dp[i][j], dp[p][j-cost[i]-cost[fan1]] + val[fan1] + val[i]);
if (fan2 != -1 && j-cost[i]-cost[fan2] >= 0)//可能性4:要主件和一个附件2
dp[i][j] = max(dp[i][j], dp[p][j-cost[i]-cost[fan2]] + val[fan2] + val[i]);
if (fan2 != -1 && fan1 != -1 && j-cost[i]-cost[fan2]-cost[fan1] >= 0)//可能性5:要主件和两个附件
dp[i][j] = max(dp[i][j], dp[p][j-cost[i]-cost[fan2]-cost[fan1]] + val[fan2] + val[i] + val[fan1]);
}
p = i;
}
}
}
int main()
{
scanf("%d %d", &n, &m);
memset(fan, 0, sizeof(fan));
memset(king, 0, sizeof(king));
int v; //花费
int p; //重要度
int q; //归属
for (int i=1; i<=m; ++i)
{
scanf("%d %d %d", &v, &p, &q);
cost[i] = v;
val[i] = v * p;
if (q == 0)
king[i] = 0;
else
king[i] = 1;
if (q != 0)
{
follow[q][fan[q]] = i;
fan[q]++;
}
}
int ans;
ans = com();
}