1、0-1背包
Acwing链接
题目描述:
有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。
第 i 件物品的体积是 vi,价值是 wi。
求解将哪些物品装入背包,可使这些物品的总体积不超过背包容量,且总价值最大。
输出最大价值。
输入格式
第一行两个整数,N,V,用空格隔开,分别表示物品数量和背包容积。
接下来有 N 行,每行两个整数 vi,wi,用空格隔开,分别表示第 i 件物品的体积和价值。
输出格式
输出一个整数,表示最大价值。
数据范围
0<N,V≤1000
0<vi,wi≤1000
题解:
(1)、DFS暴力搜索
#include <iostream>
using namespace std;
int n, m, res = 0;
const int N = 1010;
int v[N], w[N];
void DFS(int index, int sumV, int sumW){
//从第index号物品开始选择,当前背包的重量是sumV,体积是sumW
if (sumV > m) return ;//当前重量已经超过了背包的最大容量,直接返回
if (index == n){
res = max(res, sumW);
return;
}
//对于每种物品而言,都有选和不选这两个方法
DFS(index+1, sumV, sumW); //不选第index号物品
DFS(index+1, sumV+v[index], sumW+w[index]); //选第index号物品
}
int main(){
cin>>n>>m;
for (int i = 0; i < n; i++) cin>>v[i]>>w[i];
DFS(0, 0, 0);
cout<<res<<endl;
return 0;
}
算法的时间复杂度是O(2^n),空间复杂度是O(n+m),当n<= 30时,可以使用这种方法
(2)DFS+剪枝
在选第index号物品时,我们可以先判断当前物品加入背包之后,是否会超过背包的最大容量,如果超过则不加入
#include <iostream>
using namespace std;
int n, m, res = 0;
const int N = 1010;
int v[N], w[N];
void DFS(int index, int sumV, int sumW){
if (index == n){
res = max(res, sumW);
return;
}
//对于每种物品而言,都有选和不选这两个方法
DFS(index+1, sumV, sumW); //不选第index号物品
if (sumV + v[index] <= m) //只有物品加入背包之后,不会超过背包的最大容量,才选第index号物品
DFS(index+1, sumV+v[index], sumW+w[index]);
}
int main(){
cin>>n>>m;
for (int i = 0; i < n; i++) cin>>v[i]>>w[i];
DFS(0, 0, 0);
cout<<res<<endl;
return 0;
}
虽然和之前的DFS相比,做了剪枝减少了很多不必要的判断,但当n = 100时,还是会发生超时,那么就只能用到下面的动态规划了
(3)动态规划(Dynamic Programming,简称 DP)
我们采用dp[i][j]来表示选择前i件物品,最大容量为j能够获得的最大价值
(1)边界情况
当不放物品,即背包的容量为0时,能够获得的价值也是0
for (int i = 0; i <= n; i++) dp[i][0] = 0;
//背包中没有物品
for (int i = 0; i <= m; i++) dp[0][j] = 0
//不选任何一个物品
#include <iostream>
#include <algorithm>
using namespace std;
int n, m;
const int N = 1010;
int dp[N][N], v[N], w[N];
int main(){
cin>>n>>m;
for (int i = 1; i <= n; i++) cin>>v[i]>>w[i];
//边界情况的预处理
for (int i = 0; i <= m; i++) dp[0][i] = 0;
for (int i = 0; i <= n; i++) dp[i][0] = 0;
for (int i = 1; i <= n; i++){
for (int j = 1; j <= m; j++){
//状态转移方程:dp[i][j] = max(dp[i-1][j], dp[i-1][j-v[i]] + w[i])
//dp[i-1][j]表示在前i-1件物品中选择,并且容量不超过j能获得的最大价值
//dp[i-1][j-v[i]]+w[i]表示,选择第i件物品,再加上在前i-1件物品中容量不超过j-v[i]能够获得的最大价值
dp[i][j] = dp[i-1][j];
if (v[i] <= j) dp[i][j] = max(dp[i-1][j], dp[i-1][j-v[i]] + w[i]);
}
}
cout<<dp[n][m]<<endl;
return 0;
}
算法的时间复杂度O(n * m),空间复杂度O(n * m),主要是开辟的dp数组是n*m的一个二维数组
dp[i][j]只和他上一行的两个数有关,和上一行之前的数没有关系,所有可以使用滚动数组来对空间进行优化
int dp[N];
for (int i = 1; i <= n; i++){
for (int j = m; j >= v[i]; j--)
dp[j] = max(dp[j], dp[j-v[i]]+w[i]);
//注意这里j是从大到小枚举,因为dp[i][j] = max(dp[i-1][j], dp[i-1][j-v[i]] + w[i]);
//如果从小到大进行枚举,dp[j-v[i]]实际上表示的是dp[i][j-v[i]]
}
2、完全背包
题目链接
题目描述:
有 N 种物品和一个容量是 V 的背包,每种物品都有无限件可用。
第 i 种物品的体积是 vi,价值是 wi。
求解将哪些物品装入背包,可使这些物品的总体积不超过背包容量,且总价值最大。
输出最大价值。
输入格式
第一行两个整数,N,V,用空格隔开,分别表示物品种数和背包容积。
接下来有 N 行,每行两个整数 vi,wi,用空格隔开,分别表示第 i 种物品的体积和价值。
输出格式
输出一个整数,表示最大价值。
数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 5
输出样例:
10
题解:
状态转移方程:
dp[i][j] = max(dp[i-1][j], dp[i-1][j-v[i]], dp[i-1][j-2v[i]]+2w[i]…dp[i-1][j-kv[i]]+kw[i])
#include <iostream>
using namespace std;
int n, m;
const int N = 1010;
int v[N], w[N], dp[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++){
for (int j = 1; j <= m; j++){
for (int k = 0; k*v[i] <= j; k++)
dp[i][j] = max(dp[i][j], dp[i-1][j - k * v[i]] + k * w[i]);
//dp[i][j] = max(dp[i-1][j], dp[i-1][j-v[i]], dp[i-1][j-2v[i]]+2w[i]....dp[i-1][j-kv[i]]+kw[i])
//背包容量是有限的,这里假设最多能装k件i号物品
}
}
cout<<dp[n][m];
return 0;
}
算法的时间复杂度是O(n * m * k),空间复杂度O(n * m)
优化:
dp[i , j ] = max( dp[i-1,j] , dp[i-1,j-v]+w , dp[i-1,j-2v]+2w , dp[i-1,j-3v]+3w , …)
dp[i , j-v]= max( dp[i-1,j-v] , dp[i-1,j-2v] + w , dp[i-1,j-3v]+2*w , …)
由上两式,可得出如下递推关系:
dp[i][j]=max(dp[i,j-v]+w , dp[i-1][j])
#include <iostream>
using namespace std;
int n, m;
const int N = 1010;
int v[N], w[N], dp[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++){
for (int j = 1; j <= m; j++){
if (j < v[i])
dp[i][j] = dp[i-1][j];//第i件物品放不下
if (j >= v[i])
//算法优化之后的状态转移方程dp[i][j] = max(dp[i-1][j], dp[i][j-v[i]] + w[i])
dp[i][j] = max(dp[i-1][j], dp[i][j-v[i]]+w[i]);
}
}
cout<<dp[n][m];
return 0;
}
利用滚动数组对空间进行进一步优化:
这里和0-1背包的优化有点不同,0-1背包中为了需要用到上一行的dp[i-1][j]和dp[i-1][j-v[i]]
所以j是从大到小进行枚举的,防止dp[i][j-v[i]]被覆盖
但这里的dp[i][j] = max(dp[i-1][j], dp[i][j-v[i]] + w)
需要用到上一行的数,和当前行左边的数,所以是从小到大进行枚举
#include <iostream>
using namespace std;
int n, m;
const int N = 1010;
int v[N], w[N], dp[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++){
for (int j = v[i]; j <= m; j++){
dp[j] = max(dp[j], dp[j-v[i]] + w[i]);
}
}
cout<<dp[m];
return 0;
}
3、多重背包问题
多重背包问题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
题解
多重背包问题和0-1背包问题的区别在于物品的数量是固定的,第i件物品的数量是s[i]
dp[i][j] = max(dp[i-1][j], dp[i-1][j-v[i]]+w[i], dp[i-1][j-2v[i]]+2w[i]…dp[i-1][j-kv[i]]+kw[i])
其中0<= k <= s[i]
#include <iostream>
#include <algorithm>
using namespace std;
int n, m;
const int N = 110;
int v[N], w[N], s[N];
int dp[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++){
for (int j = 1; j <= m; j++){
for (int k = 0; k <= s[i] && k * v[i] <= j; k++)
dp[i][j] = max(dp[i][j], dp[i-1][j-k*v[i]]+k*w[i]);
}
}
cout<<dp[n][m];
return 0;
}
算法的时间复杂度为O(nms),空间复杂度O(n*m)
(2)多重背包问题 II
多重背包II
问题描述和多重背包I的描述一致,区别在于输入的大小:
0<N≤1000
0<V≤2000
0<vi,wi,si≤2000
如果采用上一题的做法,根据题目所给的数据范围毫无疑问会产生超时
这里需要用到二进制优化:
参考题解
4、分组背包
分组背包
问题描述
有 N 组物品和一个容量是 V 的背包。
每组物品有若干个,同一组内的物品最多只能选一个。
每件物品的体积是 vij,价值是 wij,其中 i 是组号,j 是组内编号。
求解将哪些物品装入背包,可使物品总体积不超过背包容量,且总价值最大。
输出最大价值。
输入格式
第一行有两个整数 N,V,用空格隔开,分别表示物品组数和背包容量。
接下来有 N 组数据:
每组数据第一行有一个整数 Si,表示第 i 个物品组的物品数量;
每组数据接下来有 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
dp[i][j]表示在前i组物品中,容量不超过j能够获得的最大价值
dp[i][j] = max(dp[i-1][j], dp[i-1][j-v[i][k]]+w[i][k])
其中1 <= k <= s[i]
#include <iostream>
#include <algorithm>
using namespace std;
int n, m;
const int N = 110;
int dp[N][N], v[N][N], w[N][N];
int s[N];
int main(){
cin>>n>>m;
for (int i = 1; i <= n; i++){
cin>>s[i];
for (int j = 1; j <= s[i]; j++)
cin>>v[i][j]>>w[i][j];
}
dp[0][0] = 0;
for (int i = 1; i <= n; i++){
for (int j = 0; j <= m; j++){
dp[i][j] = dp[i-1][j];
for (int k = 1; k <= s[i]; k++){
if (j >= v[i][k])
dp[i][j] = max(dp[i][j], dp[i-1][j-v[i][k]]+w[i][k]);
}
}
}
cout<<dp[n][m];
return 0;
}