一、01背包(每件物品最多只能用一次)
N个物品,容量是V的背包,每个物品体积vi,重量wi,每件物品最多只能用一次。求装进包的最大总价值。
DP问题:
- 状态表示
f
(
i
,
j
)
f(i,j)
f(i,j) (最终所求为
f
(
N
,
V
)
f(N,V)
f(N,V))
- 集合
- 所有选法
- 条件
- 只从前i个物品中选
- 总体积<=j
- 属性(最大价值、最小代价、元素数量)
- 集合
- 状态计算——集合的划分
二维
(1)状态f[i][j]
定义:前
i
i
i个物品,背包容量
j
j
j下的最优解(最大价值):
当前的状态依赖于之前的状态,可以理解为从初始状态f[0][0] = 0
开始决策,有 N 件物品,则需要 N 次决 策,每一次对第 i 件物品的决策,状态f[i][j]
不断由之前的状态更新而来。
(2)当前背包容量不够(j < v[i]
),没得选,因此前 i 个物品最优解即为前
i
−
1
i−1
i−1 个物品最优解:
对应代码:f[i][j] = f[i - 1][j]
。
(3)当前背包容量够,可以选,因此需要决策选与不选第 ii 个物品:
选:f[i][j] = f[i - 1][j - v[i]] + w[i]
。
不选:f[i][j] = f[i - 1][j]
。
我们的决策是如何取到最大价值,因此以上两种情况取 max()
。
#include<iostream>
#include<algorithm>
using namespace std;
const int N=1010;
int n,m;
int v[N],w[N];
int f[N][N];//f[i][j],j体积下前i个物品的最大价值
int main(){
cin>>n>>m;
for(int i=1;i<=n;i++) cin>>v[i]>>w[i];
//给f[][]初始化
//f[0][0~m]=0 但由于全局变量默认为0,不需单独初始化
for(int i=1;i<=n;i++)
for(int j=0;j<=m;j++)
{
//当前背包装不下第i个物品
if(j>=v[i]) f[i][j]=f[i-1][j];
//能装下,需进行决策是否选择第i个物品
else f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i]);
}
cout<<f[n][m]<<endl;
return 0;
}
一维优化
(1)状态f[j]
定义:N 件物品,背包容量j
下的最优解。
(2)注意枚举背包容量j
必须从m
开始,从大到小枚举。
(3)为什么一维情况下枚举背包容量需要逆序?在二维情况下,状态f[i][j]
是由上一轮i - 1
的状态得来的,f[i][j]
与f[i - 1][j]
是独立的。而优化到一维后,如果我们还是正序,则有f[较小体积]
更新到f[较大体积]
,则有可能本应该用第i-1
轮的状态却用的是第i
轮的状态。
(4)例如,一维状态第i轮对体积为 33 的物品进行决策,则f[7]由f[4]更新而来,这里的f[4]
正确应该是f[i - 1][4]
,但从小到大枚举j
这里的f[4]
在第i
轮计算却变成了f[i][4]
。当逆序枚举背包容量j时,我们求f[7]
同样由f[4]
更新,但由于是逆序,这里的f[4]
还没有在第i
轮计算,所以此时实际计算的f[4]
仍然是f[i - 1][4]
。
所以,状态转移方程为:f[j] = max(f[j], f[j - v[i]] + w[i]
。
#include<iostream>
#include<algorithm>
using namespace std;
const int N=1010;
int n,m;
int v[N],w[N];
int f[N];
int main(){
cin>>n>>m;
for(int i=1;i<=n;i++) cin>>v[i]>>w[i];
//给f[][]初始化
//f[0][0~m]=0 但由于全局变量默认为0,不需单独初始化
for(int i=1;i<=n;i++)
for(int j=m;j>=v[i];j--)//从大到小枚举所有体积
{
//f[j]=f[j];
//右边情况不一定存在
//if(j>=v[i])
f[j]=max(f[j],f[j-v[i]]+w[i]);
/*这个式子等价于 f[i][j]=max(f[i][j],f[i][j-v[i]]+w[i]),
但是应该为f[i-1][j-v[i]],所以从大到小枚举*/
}
cout<<f[m]<<endl;
return 0;
}
在一维状态下,少了i
件物品这个纬度,用外层for
循环,循环到第i
轮来表示。f[j]
就是指i
件物品的条件下背包容量为j
下的最大价值。
当循环结束后,外层循环了n
次,即到了n
件物品,而此时f[j]
就是所有物品背包容量j
下的最大价值。一维f[j]
等价于二维f[n][j]
。
优化输入
不必分开记录体积和价值,直接边输入边处理。
#include<iostream>
#include<algorithm>
using namespace std;
const int N=1010;
int n,m;
int f[N];
int main()
{
cin >> n >> m;
for(int i = 1; i <= n; i++) {
int v, w;
cin >> v >> w;
for(int j = m; j >= v; j--)
f[j] = max(f[j], f[j - v] + w);//读入新数据后即更新f[j]
}
cout << f[m] << endl;
return 0;
}
二、完全背包(每件物品可以用无限次)
朴素做法:
-
状态表示:
f[i][j]
- 集合:所有只考虑前i个物品,且总体积不大于j的所有选法
- 属性:Max
-
状态计算:集合的划分
可按照第
i
个物品选多少个来将f[i][j]
划分为若干个集合(0~k个)
当k=0,f[i][j]=f[i-1,j]
当取k时:
(1)去掉k
个物品i
(2)求Max,f[i-1,j-k*v[i]]
(3)再加回来k
个物品i
所以 f[i][j]=f[i-1,j-k*v[i]]+k*w[i]
以上两种情况合并,状态转移方程:f[i,j]=f[i-1,j-v[i*k]+w[i]*k]
#include<iostream>
#include<algorithm>
using namespace std;
const int N=1010;
int n,m;
int v[N],w[N];
int f[N][N];
int main(){
cin>>n>>m;
for(int i=1;i<=n;i++) cin>>v[i]>>w[i];
for(int i=1;i<=n;i++)//前i个物品
for(int j=0;j<=m;j++)//总体积不超过j
for(int k=0;k*v[i]<=j;k++)//枚举第i个物品的个数
f[i][j]=max(f[i][j],f[i-1][j-v[i]*k]+w[i]*k);
cout<<f[n][m]<<endl;
return 0;
}
优化
f[i,j]=f[i-1,j-v[i*k]+w[i]*k]
展开,取含0~n个第i个物品的价值最大值:
f[i,j]=Max(f[i-1,j],f[i-1,j-v]+w,f[i-1,j-2v]+2w,f[i-1,j-3v]+3w,...)
再将f[i,j-v]
展开
f[i,j-v]=Max( f[i-1.j-v], f[i-1,j-2v]+w, f[i-1,j-3v]+2w,...)
观察两式可发现:
Max(f[i-1,j-v]+w,f[i-1,j-2v]+2w,f[i-1,j-3v]+3w,...)
= Max(f[i-1.j-v],f[i-1,j-2v]+w,f[i-1,j-3v]+2w,...)+w
两式合并可得:
完全背包:f[i,j]=Max(f[i-1,j],f[i,j-v]+w)
(对比01背包:f[i,j]=Max(f[i-1,j],f[i-1,j-v]+w)
)
#include<iostream>
#include<algorithm>
using namespace std;
const int N=1010;
int n,m;
int v[N],w[N];
int f[N][N];
int main(){
cin>>n>>m;
for(int i=1;i<=n;i++) cin>>v[i]>>w[i];
for(int i=1;i<=n;i++)//前i个物品
for(int j=0;j<=m;j++){//总体积不超过j
f[i][j] = f[i-1][j];
if(j>=v[i]) f[i][j] = max(f[i][j],f[i][j-v[i]]+w[i]);
}
cout<<f[n][m]<<endl;
return 0;
}
最终优化:
#include<iostream>
#include<algorithm>
using namespace std;
const int N=1010;
int n,m;
int v[N],w[N];
int f[N];
int main(){
cin>>n>>m;
for(int i=1;i<=n;i++) cin>>v[i]>>w[i];
for(int i=1;i<=n;i++)//前i个物品
for(int j=v[i];j<=m;j++){//总体积不超过j
//这里的f[j-v[i]]就是指f[i][j-v[i]],是同一层,所以不需要倒着枚举
f[j] = max(f[j],f[j-v[i]]+w[i]);
}
cout<<f[m]<<endl;
return 0;
}
三、多重背包(每种物品数目不同)
朴素写法:
- 状态表示
f[i,j]
- 集合:所有只从前
i
个物品中选,且总体积不超过j
- 属性:
Max
- 集合:所有只从前
- 状态计算
按照i
类选的个数来划分集合
状态转移方程:f[i][j]=max(f[i-1][j-v[i]*k]+w[i]*k);k=0,1,2...s[i]
#include<iostream>
#include<algorithm>
using namespace std;
const int N=110;
int n,m;
int v[N],w[N],s[N];
int f[N][N];
int main(){
cin>>n>>m;
for(int i=1;i<=n;i++) cin>>v[i]>>w[i]>>s[i];
for(int i=1;i<=n;i++)//从1~n号物品
for(int j=0;j<=m;j++)//枚举容量
for(int k=0;k<=s[i]&&k*v[i]<=j;k++)//枚举第i个物品选多少个
f[i][j]=max(f[i][j],f[i-1][j-v[i]*k]+w[i]*k);
cout<<f[n][m]<<endl;
}
优化:
f[i,j] = max(f[i-1,j],f[i-1,j-v]+w,f[i-1,j-2v]+2w,...,f[i-1,j-sv]+sw)
f[i,j-v]=max( f[i-1,j-v], f[i-1,j-2v]+w,.., f[i-1,j-sv]+(s-1)w,f[i-1,j-(s+1v)]+sw)
//根据上两式无法直接求出,故无法用完全背包的优化方式直接优化
这里使用二进制的优化方式
例如:s=1023
将其按照1,2,4,8,512划分
即把s划分为若干组,每组最多只能选一次(类似于01背包)
则可以用这些划分表示出0~1023任意数字
原本需要枚举1024次,现只需枚举10次
再如s=200
1,2,4,8,16,32,64 这些可拼凑出0~127
故再补一个73即可拼凑出0~200
从特殊到一般:
若给出一个一般的s
1,2,4,8,...,2^k,c 显然有c<2^(k+1)
1,2,4,8,...,2^k可拼凑出0~2^(k+1)-1种的任意一个数
加上c可拼凑出c~s种的任意一个数
因为c<2^(k+1),所有以上两个区间合并后为[0,s]
s -> logs
时间复杂度:从NVS优化为NVlogS
有 N 种物品和一个容量是 V 的背包。
第 ii 种物品最多有 si 件,每件体积是vi,价值是 wi。
求解将哪些物品装入背包,可使物品体积总和不超过背包容量,且价值总和最大。
输出最大价值。输入格式
第一行两个整数,N,V,用空格隔开,分别表示物品种数和背包容积。
接下来有 N 行,每行三个整数 vi,wi,si,用空格隔开,分别表示第 i 种物品的体积、价值和数量。
输出格式
输出一个整数,表示最大价值。
数据范围
0<N≤1000
0<V≤2000
0<vi,wi,si≤2000提示:
本题考查多重背包的二进制优化方法。
输入样例
4 5 1 2 3 2 4 1 3 4 3 4 5 2
输出样例:
10
#include<iostream>
#include<algorithm>
using namespace std;
const int N=25000,M=2010;
int n,m;
int v[N],w[N];
int f[N];
int main(){
cin>>n>>m;
int cnt=0;//划分出来的数字个数
for(int i=1;i<=n;i++){
int a,b,s;
cin>>a>>b>>s;
int k=1;//每个划分的数
while(k<=s){//当s还可以继续划分
cnt++;
v[cnt]=a*k;//这个划分的总体积
w[cnt]=b*k;//这个划分的总质量
s-=k;
k*=2;//是2的乘方
}
if(s>0){//如果s无法被2的次方整分,仍有剩余,此时剩下的这个s相当于最后补上的c
cnt++;
v[cnt]=a*s;
w[cnt]=b*s;
}
}
n=cnt;//划分之后一共cnt组,即相当于01背包一共n个物品
//即把这些打包,最终看作01背包
//转化成了01背包
for(int i=1;i<=n;i++)
for(int j=m;j>=v[i];j--)
f[j]=max(f[j],f[j-v[i]]+w[i]);
cout<<f[m]<<endl;
return 0;
}
四、分组背包(n组物品,每组里最多只能选一个)
-
状态表示
f[i,j]
- 集合:所有只从前
i
个物品中选,且总体积不超过j
- 属性:集合中所有选法中的价值的最大值
- 集合:所有只从前
-
状态计算
枚举第i组物品选哪个or不选
#include<iostream>
#include<algorithm>
using namespace std;
const int N=110;
int n,m;
int v[N][N],w[N][N],s[N];
int f[N];
int main(){
cin>>n>>m;
for(int i=1;i<=n;i++){
cin>>s[i];
for(int j=0;j<s[i];j++)
cin>>v[i][j]>>w[i][j];
}
//状态转移时,如果用的有上一层的数据,则从大到小枚举,如果用的都是本层的,则从小到大枚举
for(int i=1;i<=n;i++)//枚举1~n组
for (int j = m; j >= 0; j -- )//先枚举体积,倒着枚举这样就不会被自己更新
for(int k=0;k<s[i];k++)//枚举第i组中的s[i]个物品
//这里与其他01背包有些不同,因为在枚举j的时候还没有枚举每一个数,故需特判
if(v[i][k]<=j)//这个物品体积足够小,可以选
f[j]=max(f[j],f[j-v[i][k]]+w[i][k]);
cout<<f[m]<<endl;
return 0;
}
参考:
https://www.acwing.com/solution/content/1374/