题目链接
超级无敌蒟蒻和y总学习第二弹.jpg
01背包问题
有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。
第 ii 件物品的体积是 vi,价值是 wi。
求解将哪些物品装入背包,可使这些物品的总体积不超过背包容量,且总价值最大。
输出最大价值。
输入格式
第一行两个整数,N,V,用空格隔开,分别表示物品数量和背包容积。
接下来有 N 行,每行两个整数 vi,wi,用空格隔开,分别表示第 ii 件物品的体积和价值。
输出格式
输出一个整数,表示最大价值。
数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 5
输出样例:
8
理解背包很关键就是自己模拟一次过程,我自己写的太丑了就不上图片了,模拟一遍样例就啥都明白了
二维dp[i][j]表示放i个物品体积为j的最大价值
#include<iostream>
using namespace std;
const int N = 1010;
int n ,m;
int dp[N][N];
int v[N],w[N];
int main()
{
cin >> n >> m;
for(int i = 1; i <= n; ++i)
cin >> w[i] >> v[i];
int res = 0;
for (int i = 1; i <= n; ++i)
{
for(int j = 0; j <= m; ++j)
{
dp[i][j] = dp[i - 1][j];
if (j >= w[i])
dp[i][j] = max(dp[i][j],dp[i - 1][j - w[i]] + v[i]);
}
}
for(int i = 0; i <= m; ++i)
res = max(res,dp[n][i]);
cout << res;
return 0;
}
压缩,一维,dp[j]表示体积小于等于j的最大价值
#include<iostream>
using namespace std;
const int N = 1010;
int n ,m;
int dp[N];
int v[N],w[N];
int main()
{
cin >> n >> m;
for(int i = 1; i <= n; ++i)
cin >> w[i] >> v[i];
for(int i = 1; i <= n; ++i)
for(int j = m; j >= w[i]; --j)
dp[j] = max(dp[j],dp[j - w[i]] + v[i]);
cout << dp[m];
return 0;
}
其中dp[m]就是最大值因为表达的意思为小于等于m的最大值
如果要求正好体积为j时的最大值,则只将dp[0]符至为0,别的赋值为-INF即可,因为这样dp[j]只能由0推导而来
完全背包问题
有 N 种物品和一个容量是 V 的背包,每种物品都有无限件可用。
第 i 种物品的体积是 vi,价值是 wi。
求解将哪些物品装入背包,可使这些物品的总体积不超过背包容量,且总价值最大。
输出最大价值。
输入格式
第一行两个整数,N,V,用空格隔开,分别表示物品种数和背包容积。
接下来有 N 行,每行两个整数 vi,wi,用空格隔开,分别表示第 ii 种物品的体积和价值。
输出格式
输出一个整数,表示最大价值。
数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 5
输出样例:
10
每个物品无限也就是可以在选完一次的状态下继续选,也就相当于f[i][j] = max(f[i][j],f[ i ][j - v] + w);
#include<iostream>
using namespace std;
const int N = 1010;
int n,m;
int f[N];
int main()
{
cin >> n >> m;
for(int i = 0;i < n; ++i)
{
int v,w;
cin >> v >> w;
for(int j = v; j <= m; ++j)
f[j] = max(f[j],f[j-v] + w);
}
cout << f[m];
return 0;
}
多重背包问题 I
有 N 种物品和一个容量是 V 的背包。
第 i种物品最多有 si 件,每件体积是 vi,价值是 wi。
求解将哪些物品装入背包,可使物品体积总和不超过背包容量,且价值总和最大。
输出最大价值。
输入格式
第一行两个整数N,V,用空格隔开,分别表示物品种数和背包容积。
接下来有 N 行,每行三个整数 vi,wi,si,用空格隔开,分别表示第 i 种物品的体积、价值和数量。
输出格式
输出一个整数,表示最大价值。
数据范围
0<N,V≤100
0<vi,wi,si≤100
输入样例
4 5
1 2 3
2 4 1
3 4 3
4 5 2
输出样例:
10
再多加一层判断枚举个数即可
#include<iostream>
using namespace std;
const int N = 110;
int f[N];
int main()
{
int n,m,v,w,s;
cin >> n >> m;
for (int i = 0; i < n;++i)
{
cin >> v >> w >> s;
for(int j = m;j >= v; --j)
for(int k = 1; k <= s && k * v <= j; ++k)
f[j] = max(f[j],f[j - k * v] + k*w);
}
cout << f[m];
return 0;
}
多重背包问题 II
有 N 种物品和一个容量是 V 的背包。
第 i种物品最多有 si 件,每件体积是 vi,价值是 wi。
求解将哪些物品装入背包,可使物品体积总和不超过背包容量,且价值总和最大。
输出最大价值。
输入格式
第一行两个整数N,V,用空格隔开,分别表示物品种数和背包容积。
接下来有 N 行,每行三个整数 vi,wi,si,用空格隔开,分别表示第 ii 种物品的体积、价值和数量。
输出格式
输出一个整数,表示最大价值。
数据范围
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
数据范围增大,三重循环达到4x10^9,是不可行的
1的思想是把所有可能的物品都加进的物品栏,比如i的1倍,两倍等等,把s个分成了s份
s种情况可以用 l o g 2 s log_2s log2s 上取整得到
取完log之后是1000x2000x11 = 2x10^7,是可以接受的
10 可以分为1,2,4,3这4种情况
1,2,4可以得到0-7,加上一个3就可以得到0-10,而且不超过10
比如 1,2,10 那么
1,2
2,4,
4,8
3,6 这4个物品可以组成10个1,2物品的所有情况,从而就变成了01背包问题
如果说这么枚举最佳答案比如没选1,2选了3,6,而按Ⅰ种方法选1,2,那会不会就不对了,当然不是3,6看成1,2+2,4啊,感觉这个问题转不过来之前很头疼,转过来之后感觉很傻2333
Ⅰ的方法是一下吃饱,而Ⅱ是吃好几次填缝的操作
#include <vector>
#include <iostream>
using namespace std;
const int N = 2020;
int n,m;
int f[N];
int main()
{
vector<pair<int,int>> goods;
cin >> n >> m;
for(int i = 0; i < n; ++i)
{
int v, w, s;
cin >> v >> w >> s;
for (int k = 1; k <= s; k <<= 1)
{
s -= k;
goods.push_back({v * k,w * k});
}
if (s > 0)
goods.push_back({v * s,w * s});
}
for (auto good : goods)
for (int i = m; i >= good.first; --i)
f[i] = max(f[i],f[i - good.first] + good.second);
cout << f[m];
return 0;
}
多重背包问题 III
有 N 种物品和一个容量是 V 的背包。
第 i 种物品最多有 si 件,每件体积是 vi,价值是 wi。
求解将哪些物品装入背包,可使物品体积总和不超过背包容量,且价值总和最大。
输出最大价值。
输入格式
第一行两个整数,N,V (0<N≤1000, 0<V≤20000),用空格隔开,分别表示物品种数和背包容积。
接下来有 N 行,每行三个整数 vi,wi,si,用空格隔开,分别表示第 i 种物品的体积、价值和数量。
输出格式
输出一个整数,表示最大价值。
数据范围
0<N≤1000
0<V≤20000
0<vi,wi,si≤20000
提示
本题考查多重背包的单调队列优化方法。
输入样例
4 5
1 2 3
2 4 1
3 4 3
4 5 2
输出样例:
10
通过单调队列优化来提升速度
首先第一个特点是:状态只会从背包容量对物体体积求余相等的状态转移过来
当物品体积为v = 2时,背包容量为j = 0时
后续j+v = 2,j+2v = 4等状态都是从j%v == 0的状态转移过来的,也就是图中绿色的只会从绿色的状态转移过来
图片来自
用一个单调队列维护这些块,保存其中的最大值即可
如何算两个绿色块之间的价值:两块的距离除以物品体积v就是放入的物品数量,在乘价值w就是这些物品的价值,在加上上一层状态值即可
普通的单调队列中数的值是不变化的,所以相对大小关系是稳定的,而背包中,每一个绿色块都比前一个绿色快多一个物品的价值w,所以在维护单调队列时比较大小要减去每个块增加的物品价值,方法:
每个块减去距初始情况t(这个情况下t = 0)多出的v,也就是(j - t) / v * w
用单调队列的维护则对于每个物品只会把每个体积处理一次,所以时间复杂度是O(nm)
#include <cstring>
#include <iostream>
using namespace std;
const int N = 20010;
int n,m;
int pre[N],f[N],q[N];//上一层状态,队列(存放下标),当前层状态
int main()
{
cin >> n >> m;
for (int i = 0; i < n; ++i)
{
int v,w,s;
//pre = f[i - 1]保存上一层状态
memcpy(pre,f,sizeof(f));
cin >> v >> w >> s;
for (int j = 0; j < v; ++j) //枚举余数
{
int hh = 0, tt = -1; //头,尾
for (int k = j; k <= m; k += v)//枚举体积
{
//目前位置距离队列头超过s,也就是物品数量,将队头出队
if (hh <= tt && (k - q[hh]) / v > s) ++hh;
//比较目前位置与队尾值,如果队尾小于等于当前价值则队尾出队
while(hh <= tt && pre[q[tt]] - (q[tt] - j)/v*w <= pre[k] - (k-j)/v*w)
--tt;
//插入当前值
q[++tt] = k;
//更新答案,当前值到队头的距离
if (hh <= tt)
f[k] = max(f[k],pre[q[hh]] + (k - q[hh]) / v * w);
}
}
}
cout << f[m] << endl;
return 0;
}
混合背包问题
有 N 种物品和一个容量是 V 的背包。
物品一共有三类:
- 第一类物品只能用1次(01背包);
- 第二类物品可以用无限次(完全背包);
- 第三类物品最多只能用 si 次(多重背包);
每种体积是 vi,价值是 wi。
求解将哪些物品装入背包,可使物品体积总和不超过背包容量,且价值总和最大。
输出最大价值。
输入格式
第一行两个整数,N,V,用空格隔开,分别表示物品种数和背包容积。
接下来有 N 行,每行三个整数vi,wi,si,用空格隔开,分别表示第 i 种物品的体积、价值和数量。
- si=−1 表示第 ii 种物品只能用1次;
- si=0 表示第 ii 种物品可以用无限次;
- si>0 表示第 ii 种物品可以使用 si 次;
输出格式
输出一个整数,表示最大价值。
数据范围
0<N,V≤1000
0<vi,wi≤1000
−1≤si≤1000
输入样例
4 5
1 2 -1
2 4 1
3 4 0
4 5 2
输出样例:
8
把物品按照01背包和完全背包分类即可,多重背包利用二进制优化转化成01背包
#include<vector>
#include<iostream>
using namespace std;
const int N = 1010;
int n,m;
int f[N];
struct thing{
int king;
int v,w;
};
vector<thing> things;
int main(){
cin >> n >> m;
for(int i = 0; i < n; ++i){
int v,w,s;
cin >> v >> w >> s;
if(s < 0) things.push_back({-1,v,w}); //01背包
else if(s == 0) things.push_back({0,v,w}); //完全背包
else{
for (int k = 1; k <= s; k <<= 1){ //多重背包
s -= k;
things.push_back({-1,k * v, k * w});
}
if(s > 0)
things.push_back({-1,s * v, s * w});
}
}
for(auto thing : things){
if(thing.king < 0) //01背包
for(int j = m; j >= thing.v; --j)
f[j] = max(f[j],f[j - thing.v] + thing.w);
else //完全背包
for(int j = thing.v; j <= m; ++j)
f[j] = max(f[j],f[j - thing.v] + thing.w);
}
cout << f[m] << endl;
return 0;
}
二维费用的背包问题
有 N 件物品和一个容量是 V 的背包,背包能承受的最大重量是 M。
每件物品只能用一次。体积是 vi,重量是 mi,价值是 wi。
求解将哪些物品装入背包,可使物品总体积不超过背包容量,总重量不超过背包可承受的最大重量,且价值总和最大。
输出最大价值。
输入格式
第一行两个整数,N,V,M,用空格隔开,分别表示物品件数、背包容积和背包可承受的最大重量。
接下来有 N 行,每行三个整数 vi,mi,wi,用空格隔开,分别表示第 i 件物品的体积、重量和价值。
输出格式
输出一个整数,表示最大价值。
数据范围
0<N≤1000
0<V,M≤100
0<vi,mi≤100
0<wi≤1000
输入样例
4 5 6
1 2 3
2 4 4
3 4 5
4 5 6
输出样例:
8
多一种状态用f[i][j]表示体积为i重量为j的最大价值,因为是01背包问题,所以从体积重量最大开始枚举
#include<iostream>
using namespace std;
const int N = 110;
int n,v,m;
int f[N][N];
int main(){
cin >> n >> v >> m;
for(int i = 0; i < n; ++i){
int vi,mi,wi;
cin >> vi >> mi >> wi;
for(int j = v; j >= vi; --j){
for(int k = m; k >= mi; --k){
f[j][k] = max(f[j][k],f[j - vi][k - mi] + wi);
}
}
}
cout << f[v][m] << endl;
return 0;
}
分组背包问题
有 N 组物品和一个容量是 V 的背包。
每组物品有若干个,同一组内的物品最多只能选一个。
每件物品的体积是 vij,价值是 wij,其中 i 是组号,j 是组内编号。
求解将哪些物品装入背包,可使物品总体积不超过背包容量,且总价值最大。
输出最大价值。
输入格式
第一行有两个整数 N,V,用空格隔开,分别表示物品组数和背包容量。
接下来有 N 组数据:
- 每组数据第一行有一个整数 Si,表示第 ii 个物品组的物品数量;
- 每组数据接下来有 Si 行,每行有两个整数 vij,wij,用空格隔开,分别表示第 i 个物品组的第 j 个物品的体积和价值;
输出格式
输出一个整数,表示最大价值。
数据范围
0<N,V≤100
0<Si≤100
0<vij,wij≤100
输入样例
3 5
2
1 2
2 4
1
3 4
1
4 5
输出样例:
8
分组背包是一个特殊的多重背包
分组背包的一组相当于多重背包中的一个物品,一组中的不同物品可以想象成多重背包中k个物品打包而成,一次只能选一个打包完成的物品
所以加一重循环判断选择一组中哪个物品即可
#include<iostream>
using namespace std;
const int N = 110;
int n,m;
int f[N],v[N],w[N];
int main(){
cin >> n >> m;
for(int i = 0; i < n; ++i){
int s;
cin >> s;
for(int k = 0; k < s; ++k)
cin >> v[k] >> w[k];
for(int j = m; j >= 0; --j)
for(int t = 0; t < s; ++t){ //一组中的哪个物品
if(j - v[t] >= 0) //注意一下体积不超界
f[j] = max(f[j],f[j - v[t]] + w[t]);
}
}
cout << f[m] << endl;
return 0;
}
有依赖的背包问题
有 N 个物品和一个容量是 V 的背包。
物品之间具有依赖关系,且依赖关系组成一棵树的形状。如果选择一个物品,则必须选择它的父节点。
如下图所示:
如果选择物品5,则必须选择物品1和2。这是因为2是5的父节点,1是2的父节点。
每件物品的编号是 i,体积是 vi,价值是 wi,依赖的父节点编号是 pi。物品的下标范围是 1…N。
求解将哪些物品装入背包,可使物品总体积不超过背包容量,且总价值最大。
输出最大价值。
输入格式
第一行有两个整数 N,V,用空格隔开,分别表示物品个数和背包容量。
接下来有 N 行数据,每行数据表示一个物品。
第 i 行有三个整数 vi,wi,pi,用空格隔开,分别表示物品的体积、价值和依赖的物品编号。
如果 pi=−1,表示根节点。 数据保证所有物品构成一棵树。
输出格式
输出一个整数,表示最大价值。
数据范围
1≤N,V≤100
1≤vi,wi≤100
父节点编号范围:
- 内部结点: 1≤pi≤N;
- 根节点 pi=−1;
输入样例
5 7
2 3 -1
2 2 1
3 5 1
4 7 2
3 6 2
输出样例:
11
用f[i][j]表示以i为根节点体积为j时子树的最大价值
树形dp+分组背包问题
分组就是以i节点下的所有子节点
#include<cstring>
#include<iostream>
using namespace std;
const int N = 110;
int e[N],ne[N],h[N],idx;
int n,m;
int v[N],w[N],f[N][N];
void add(int a,int b){
e[idx] = b,ne[idx] = h[a],h[a] = idx++;
}
void dfs(int u){
for(int i = h[u]; i != -1; i = ne[i]){//枚举物品
int son = e[i];
dfs(son);
//从大到小枚举体积,因为有依赖想选子节点必须选根节点,则提前一步将根节点的体积预留出来
for(int j = m - v[u]; j >= 0; --j)
for(int k = 0; k <= j; ++k) //枚举分组
//u为根节点,减去子节点的体积k,加上以子节点为根节点体积为k的最大价值
f[u][j] = max(f[u][j], f[u][j - k] + f[son][k]);
}
//将给根节点预留出来的体积填回去
for(int i = m; i >= v[u]; --i) f[u][i] = f[u][i - v[u]] + w[u];
//不够放根节点物品的最大价值为0
for(int i = 0; i < v[u]; ++i) f[u][i] = 0;
}
int main(){
memset(h,-1,sizeof(h));
cin >> n >> m;
int root;
for(int i = 1; i <= n; ++i){
int p;
cin >> v[i] >> w[i] >> p;
if (p == -1) root = i;
else add(p,i);
}
dfs(root);
cout << f[root][m] << endl;
return 0;
}
背包问题求方案数
有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。
第 i 件物品的体积是 vi,价值是 wi。
求解将哪些物品装入背包,可使这些物品的总体积不超过背包容量,且总价值最大。
输出 最优选法的方案数。注意答案可能很大,请输出答案模 10^9+7 的结果。
输入格式
第一行两个整数,N,V,用空格隔开,分别表示物品数量和背包容积。
接下来有 N 行,每行两个整数 vi,wi,用空格隔开,分别表示第 ii 件物品的体积和价值。
输出格式
输出一个整数,表示 方案数 模 10^9+7 的结果。
数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 6
输出样例:
2
设置一个数组g[j],表示体积为j时有多少种表示方法初始g[0] = 0
f数据除0外初始化为负无穷,f[i]表示体积正好为i时的最大价值
#include<cstring>
#include<iostream>
using namespace std;
const int N = 1010;
int mod = 1e9 + 7;
int f[N],g[N];
int n,m;
int main(){
cin >> n >> m;
memset(f,0xc0,sizeof(f));
f[0] = 0;
g[0] = 1;
for(int i = 0; i < n; ++i){
int v,w;
cin >> v >> w;
for(int j = m; j >= v; --j){
int t = max(f[j],f[j - v] + w);
int s = 0;
if (t == f[j]) s += g[j]; //不放体积大
if (t == f[j -v] + w) s += g[j - v];//放体积大,注意两种情况可能相等
g[j] = s % mod;
f[j] = t;
}
}
int maxn = 0;
for(int i = 0; i <= m; ++i) maxn = max(maxn,f[i]);//找到最大值
int res = 0;
for(int i = 0; i <= m; ++i){
if(f[i] == maxn)
res = (res + g[i]) % mod;
}
cout << res << endl;
return 0;
}
背包问题求具体方案
有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。
第 i 件物品的体积是 vi,价值是 wi。
求解将哪些物品装入背包,可使这些物品的总体积不超过背包容量,且总价值最大。
输出 字典序最小的方案。这里的字典序是指:所选物品的编号所构成的序列。物品的编号范围是 1…N。
输入格式
第一行两个整数,N,V,用空格隔开,分别表示物品数量和背包容积。
接下来有 N 行,每行两个整数 vi,wi,用空格隔开,分别表示第 ii 件物品的体积和价值。
输出格式
输出一行,包含若干个用空格隔开的整数,表示最优解中所选物品的编号序列,且该编号序列的字典序最小。
物品编号范围是 1…N。
数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 6
输出样例:
1 4
可以求出最佳答案后反推取的物品
要求输出字典序最小,将f[i][j]定义为从第i个元素到最后一个元素总容量为j的最优解,f[1][m]记录最大值,从前往后分析即可
#include<iostream>
using namespace std;
const int N = 1010;
int f[N][N];
int n,m;
int v[N],w[N];
int main(){
cin >> n >> m;
for(int i = 1; i <= n; ++i)
cin >> v[i] >> w[i];
for(int i = n; i >= 1; --i){ //要求字典序最小,从后往前枚举,这样可以从f[1][m]逆推
for(int j = 0; j <= m; ++j){
f[i][j] = f[i + 1][j];
if(j >= v[i])
f[i][j] = max(f[i][j],f[i + 1][j - v[i]] + w[i]);
}
}
int vol = m;
for(int i = 1; i <= n; ++i)
//当前最大值是取了第i个物品得到的
if(vol >= v[i] && f[i][vol] == f[i + 1][vol - v[i]] + w[i]){
cout << i << ' ';
vol -= v[i];
}
return 0;
}