四种常见背包问题整理
四种常见背包问题包括：① 最优装配 ② 部分背包问题 ③ 01背包问题 ④ 完全背包问题
① 最优装配
给出 n 个物体，重量分别为 wi，使总重量不超过容量 C 的情况下选择尽量多的物体。
这种背包问题很简单，只要求数量多就可以，因此我们对重量进行排序贪心选择就好。
参考代码：
#include<iostream>
#include<algorithm>
using namespace std;
int *stuff;
// 最优装配
int getResult(int n, int c){
int cnt = 0;
int sum = 0;
for(int i = 0; i < n; i++){
sum += stuff[i];
if(sum <= c) cnt++;
else break;
}
return cnt;
}
int main(){
int n, c;
while(cin >> n >> c){
stuff = new int[n];
for(int i = 0; i < n; i++){
cin >> stuff[i];
}
sort(stuff, stuff+n);
int cnt = getResult(n, c);
cout << cnt << endl;
delete[] stuff;
}
return 0;
}
② 部分背包问题
有 n 个物体，重量分别为 wi，价值为 vi，在总重量不超过容量 C 的情况下让总价值最高，
每个物体可以只取走一部分，若取走部分物体则价值也会等比例减少。
这种背包问题也比较简单，可以定义一个变量 rate 表示各个物体的性价比，
性价比最高的物体先拿走，如果可以整个物体都拿走则直接拿走，若不能整个拿走就拿走部分。
参考代码：
#include<iostream>
#include<algorithm>
using namespace std;
struct STUFF {
int weight;
int price;
double rate; // 性价比
bool operator < (STUFF other) const {
return rate > other.rate;
}
}*stuffs;
// 部分背包问题
double getResult(int n, int c){
double sum = 0;
for(int i = 0; i < n; i++){
// 可以整个拿走就直接拿走
if(c >= stuffs[i].weight){
sum += stuffs[i].price;
c -= stuffs[i].weight;
}
else{
// 不能直接拿走就拿部分
sum += stuffs[i].price*1.0*c/stuffs[i].weight;
break;
}
}
return sum;
}
int main(){
int n, c;
while(cin >> n >> c){
stuffs = new STUFF[n];
for(int i = 0; i < n; i++){
cin >> stuffs[i].weight >> stuffs[i].price;
stuffs[i].rate = stuffs[i].price*1.0/stuffs[i].weight;
}
sort(stuffs, stuffs+n);
double result = getResult(n, c);
cout << result << endl;
delete[] stuffs;
}
return 0;
}
③ 01背包问题
有 n 个物体，重量分别为 wi，价值为 vi，在总重量不超过容量 C 的情况下让总价值最高，
但不允许只取走部分物体，要拿走只能整个拿走。
从01背包开始就涉及到了动态规划的知识，动态规划的本质就是递推。
先打表进行观察：
表中 dp[ i ] [ j ] 表示容量为 j，可以在 0 号物品到 i 号物品中进行任意组合，这种情况下的最大值。
第一行与第一列都不用说，一眼就可以直接得到答案。
剩下的部分怎么进行选择呢？
比如 dp[2] [4] = 6，我们已经知道了 dp[1] [4] = 5，说明在没有考虑 2 号物品的时候最大价值为 5。
现在加入了 2 号物品需要考虑，（3,4）重量为 3，价值为 4。
那么必须要选择 2 号物品才有可能超过之前计算不考虑 2 号物品的最大价值 5。
而选择 2 号物品的最大价值为多少呢？
应该是 dp[2-1] [4-3] + 4 = dp[1] [1] + 4 = 2 + 4 = 6，
dp[1] [1] 为不考虑 2 号物品，容量为 1 的最大价值，这样正好可以装下重量为 3 的 2 号物品且价值最大。
因此我们只要比较加入 2 号物品的最大价值与不加入 2 号物品的最大价值即可，
即 max(dp[1] [1] + 4, dp[1] [4])。
一般情况：dp[i] [j] = max( dp[i-1] [j-w] + v, dp[i-1] [j] )。
所以处理到最后 dp[2] [5] 就是我们要求的答案。
参考代码：
#include<iostream>
#include<algorithm>
using namespace std;
int **stuffs; // 物品数组
int **dp; // 二维数组保存dp表
void show(int **arr, int n, int c){
for(int i = 0; i < n; i++){
for(int j = 0; j <= c; j++){
cout << arr[i][j] << " ";
}
cout << endl;
}
}
// 得到dp表
int getDpTable(int n, int c){
// 初始化第一行
for(int i = 0; i < c+1; i++){
if(i >= stuffs[0][0]){
dp[0][i] = stuffs[0][1];
}
else{
dp[0][i] = 0;
}
}
// 初始化第一列
for(int i = 0; i < n; i++){
dp[i][0] = 0;
}
// currentWeight和currentValue保存当前物品的重量与价值
int currentWeight, currentValue;
for(int i = 1; i < n; i++){
currentWeight = stuffs[i][0];
currentValue = stuffs[i][1];
for(int j = 1; j < c+1; j++){ // 注意i和j都是从1开始，j表示背包的容量
if(j >= currentWeight){
int value1 = currentValue+dp[i-1][j-currentWeight]; // 该物品的价值 + 没有加上该物品时的最大价值
int value2 = dp[i-1][j]; // 使用前面i个物品组合成的最大价值
dp[i][j] = max(value1, value2);
}
else{
dp[i][j] = dp[i-1][j];
}
}
}
show(dp, n, c);
return dp[n-1][c];
}
int main(){
int n, c;
while(cin >> n >> c){
stuffs = new int*[n];
dp = new int*[n];
for(int i = 0; i < n; i++){
stuffs[i] = new int[2];
dp[i] = new int[c+1];
}
for(int i = 0; i < n; i++){
cin >> stuffs[i][0] >> stuffs[i][1];
}
cout << getDpTable(n, c) << endl;
for(int i = 0; i < n; i++){
delete[] stuffs[i];
delete[] dp[i];
}
delete[] stuffs;
delete[] dp;
}
return 0;
}
④ 完全背包问题
在01背包的基础上添加了新的条件：各个物品不再是一个，而是变成一种，可以拿多个。
继续打表观察：
前面三种情况都很好分析，重点是最后一种情况。
这里的 v[i]+dp[i] [j-w[i]] 注意是 i 而不是01背包中的 i-1，是同一行。
虽然在完全背包中一个物品可以选择多个，但是并不需要通过 for 循环来确定选择 k 个 i 物品时价值最大。
我们只要简单分成两个状态就足够了： 1. 选择 i 物品 2. 不选择 i 物品
而 dp[i-1] [j] 就是不选择 i 物品时的最大价值 maxValue。
v[i] + dp[i] [j-w[i]] 是选择 i 物品时的最大价值maxValue，这里 v[i] 表示选择一个 i 物品，
但是选择一个 i 物品不保证是最大价值啊，这里就要看 dp[i] [j-w[i]] 了。
dp[i] [j-w[i]] 就已经包含了 k-1 个 i 物品的最大价值，因此两者组合起来就是 k 个 i 物品使总价值最大。
（01背包只能选一个，因此为 v[i] + dp[i-1] [j-w[i]]，
完全背包问题可以选多个，因此为 v[i] + dp[i] [j-w[i]]）
参考代码：
#include<iostream>
#include<algorithm>
using namespace std;
struct STUFF {
int weight;
int value;
}*stuffs;
int **dp;
int getResult(int n, int c){
for(int i = 1; i <= c; i++){
dp[0][i] = (i/stuffs[0].weight)*stuffs[0].value; // 初始化第一行 只能取第一个物品
}
for(int i = 1; i < n; i++){
for(int j = 1; j <= c; j++){
if(stuffs[i].weight > j){
dp[i][j] = dp[i-1][j]; // 如果买不起该物品 最大价值就是不买该物品时计算出来的最大值
}
else{
// 两种情况：1.买该物品 2.不买该物品
// dp[i-1][j]就是不买该物品的最大价值
// value[i]+dp[i][j-weight[i]]是买该物品时的最大价值 i物品被这里被选择了k次而不是1次 注意该重点
dp[i][j] = max(dp[i-1][j], stuffs[i].value+dp[i][j-stuffs[i].weight]);
}
}
}
for(int i = 0; i < n; i++){
for(int j = 0; j <= c; j++){
cout << dp[i][j] << " ";
}
cout << endl;
}
return dp[n-1][c];
}
int main(){
int n, c;
while(cin >> n >> c){
stuffs = new STUFF[n];
dp = new int*[n];
for(int i = 0; i < n; i++){
dp[i] = new int[c+1]; // 注意是c+1 dp数组中有容量为0的情况
}
for(int i = 0; i < n; i++){
for(int j = 0; j <= c; j++){
dp[i][j] = 0;
}
}
for(int i = 0; i < n; i++){
cin >> stuffs[i].weight >> stuffs[i].value;
}
int ans = getResult(n, c);
cout << ans << endl;
for(int i = 0; i < n; i++){
delete[] dp[i];
}
delete[] dp;
delete[] stuffs;
}
return 0;
}
【END】感谢观看
扫一扫
2496
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
