经典背包问题1——01背包问题、完全背包问题、多重背包问题（数据范围100）、多重背包问题（数据范围1000/2000）

最新推荐文章于 2024-06-20 09:44:35 发布

Kuany_

最新推荐文章于 2024-06-20 09:44:35 发布

阅读量1.5k

点赞数 2

分类专栏：刷题动态规划文章标签：动态规划背包问题

本文链接：https://blog.csdn.net/weixin_44718794/article/details/107805297

版权

刷题同时被 2 个专栏收录

21 篇文章 0 订阅

订阅专栏

动态规划

10 篇文章 0 订阅

订阅专栏

经典背包问题1——01背包问题、完全背包问题、多重背包问题（数据范围100）、多重背包问题（数据范围1000/2000）

1——01背包问题
2——完全背包问题
3——多重背包问题（数据范围100）
4——多重背包问题（数据范围1000/2000）

先放上结论代码，再看题：

#include<iostream>
#include<algorithm>
#include<iostream>
using namespace std;

const int N = 1010;//物品最多数量
int dp[N];//全局自动初始化为0
int n,m;//要输入的n个物品，m的容量
int v[N],w[N],s[N];//要输入的物品的体积,物品的价值,和物品的个数

int main(){
    cin>>n>>m;
    for(int i = 1;i<=n;i++){//给第i个物品（没有第0个）赋值体积，价值与个数
        cin>>v[i]>>w[i]>>s[i];
    }
//********************01背包**************************
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]);
    }
}
//********************完全背包*************************
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]);
    }
}
//********************多重背包(数据范围100内)***********
//01的改进
for(int i = 1;i<=n;i++){
    for(int j = m;j>=0;j--){
        for(int k = 1;k<=s[i] && k*v[i]<=j;k++){
            dp[j] = max(dp[j],dp[j-k*v[i]]+k*w[i]);
        }
    }
}
//********************多重背包(数据范围1000/2000)******
//把每个物品的种类个数拆成二进制问题
struct Good{
    int v,w;
};
vector<Good> goods;
    for(int i = 1;i<=n;i++){//给第i个物品（没有第0个）赋体积与价值
        cin>>v[i]>>w[i]>>s[i];
        //把每个物品像分苹果（1000个苹果分成有限堆，可以取不同的堆来表示不同个数的苹果）一样分开
        for(int k = 1;k<=s[i];k*=2){
            s[i] = s[i]-k;
            goods.push_back({v[i]*k,w[i]*k});
        }
        if(s[i]>0) goods.push_back({v[i]*s[i],w[i]*s[i]});
    }
    //现在就回归到01背包问题
    for(auto good:goods){
        for(int j = m;j>=good.v;j--){
            dp[j] = max(dp[j],dp[j-good.v]+good.w);
        }
    }
//****************************************************
    cout<<dp[m]<<endl;
    return 0;
}

1——01背包问题

有 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

输出样例：

动态规划思路：

定义dp，定义dp[i][j]的含义为当选择前i个物品，总体积为j的前提下，总价值是多少；
状态变化为每种物品都尝试，总体积也要不断增加，所以两次嵌套遍历第一层为从0到i，第二层为从0到j；
确定状态转移方程，当我们看前i个物品的时候可以选择放不放第i个物品到里面，要么放，要么不放，就要对比两者哪种的价值是最大的。不放里面，就是看前i-1个物品，容量为j的时候；放里面就是看前i-1个物品，总容量为j-当前第i个物品容量（前提是j要大于当前第i个物品容量）的时候。

代码：

#include<iostream>
#include<algorithm>
using namespace std;

const int N = 1010;//物品最多数量
int dp[N][N];//全局自动初始化为0
int n,m;//要输入的n个物品，m的容量
int v[N],w[N];//要输入的物品的体积和物品的价值

int main(){
    cin>>n>>m;
    for(int i = 1;i<=n;i++){//给第i个物品（没有第0个）赋体积与价值
        cin>>v[i]>>w[i];
    }
    for(int i = 1;i<=n;i++){//从前i个物品选
        for(int j = 0;j<=m;j++){//每个容量的时候，看价值最大是多少
            dp[i][j] = dp[i-1][j];//不选第i个
            if(j>=v[i]){
                dp[i][j] = max(dp[i][j],dp[i-1][j-v[i]]+w[i]);//选第i个，但是要跟选之前进行对比
            }
        }
    }
    cout<<dp[n][m]<<endl;
    return 0;
}

由于我们看到代码里，第i个背包只与第i-1个背包有关，所以我们可以对代码进行优化，采用一维数组，先上代码再解释：

#include<iostream>
#include<algorithm>
using namespace std;

const int N = 1010;//物品最多数量
int dp[N];//全局自动初始化为0
int n,m;//要输入的n个物品，m的容量
int v[N],w[N];//要输入的物品的体积和物品的价值

int main(){
    cin>>n>>m;
    for(int i = 1;i<=n;i++){//给第i个物品（没有第0个）赋体积与价值
        cin>>v[i]>>w[i];
    }
    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]);
        }
    }
    cout<<dp[m]<<endl;
    return 0;
}

dp问题的优化，一般都是对代码进行优化。
把dp[i][j]压缩成一维，把i那层拿掉，
这行代码：

dp[j] = max(dp[j],dp[j-v[i]]+w[i]);

对于j（容量）来讲，dp[j]的转移要么是dp[j]，要么是dp[j-v[i]]，也就是说当前体积要么是自己转移过来，要么是比自己小的体积转移过来;所以体积j从大到小枚举，从而可以保证枚举到当前体积j的时候，j - v[i]因为小还没被更新过，它是等价于dp[i - 1][j - v[i]]，也就是上一层的。
所以for循环写为：

for(int j = m;j>=v[i];j--)

2——完全背包问题

完全背包问题的题目跟01背包问题只有一处不同，就是01背包问题是每种物品只有一种，而完全背包问题是每种物品有无数个，可以任意选。

动态规划思路：
其他跟01背包问题思路一样，只是在选第i种这一步比01背包问题要复杂一些。01背包问题选第i种是先除去这第i种然后看前i-1种，价值最大是多少；而完全背包是分别选第i种1个、或者2个、或者三个…之后再选前i-1种他们的最大价值是多少。
在这里插入图片描述

这一步的推导：
在这里插入图片描述
代码：

#include<iostream>
#include<algorithm>
using namespace std;

const int N = 1010;//物品最多数量
int dp[N][N];//全局自动初始化为0
int n,m;//要输入的n个物品，m的容量
int v[N],w[N];//要输入的物品的体积和物品的价值

int main(){
    cin>>n>>m;
    for(int i = 1;i<=n;i++){//给第i个物品（没有第0个）赋体积与价值
        cin>>v[i]>>w[i];
    }
    for(int i = 1;i<=n;i++){
        for(int j = 0;j<=m;j++){
            dp[i][j] = dp[i-1][j];
            if(j>=v[i]){
                dp[i][j] = max(dp[i][j],dp[i][j-v[i]]+w[i]);
            }
        }
    }
    cout<<dp[n][m]<<endl;
    return 0;
}

优化：
优化思路和01背包一样，对代码进行优化，其实不难看到，与01背包的区别就是，dp[j-v[i]]是依赖本层还是上一层，01背包的优化是

dp[j] = max(dp[j],dp[j-v[i]]+w[i]);

去掉dp[i]之后，max的后半部分原本是依赖于上一层，也就是

dp[i][j] = max(dp[i][j],dp[i-1][j-v[i]]+w[i]);

优化完了之后如果j是从小到大的话，dp[j-v[i]]是已经算过的也就是依赖本层，故01背包的优化是让循环从大到小循环，才能保证优化后跟优化前恒等。

而完全背包此时已经是dp[i][j-v[i]]，进行优化则是依赖于本层，则j层循环依旧是从小到大。

故：

#include<iostream>
#include<algorithm>
using namespace std;

const int N = 1010;//物品最多数量
int dp[N];//全局自动初始化为0
int n,m;//要输入的n个物品，m的容量
int v[N],w[N];//要输入的物品的体积和物品的价值

int main(){
    cin>>n>>m;
    for(int i = 1;i<=n;i++){//给第i个物品（没有第0个）赋体积与价值
        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]<<endl;
    return 0;
}

3——多重背包问题（数据范围100）

多重背包的其他定义和前两种无异，只是多了个每种物品有多少个（有限个）的限制。

输入格式
第一行两个整数，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

输出样例：

动态规划思路：

其实就是比01背包问题多了个每种选几个的循环；

#include<iostream>
#include<algorithm>
using namespace std;

const int N = 110;//物品最多数量
int dp[N];//全局自动初始化为0
int n,m;//要输入的n个物品，m的容量
int v[N],w[N],s[N];//要输入的物品的体积,物品的价值,和物品的个数

int main(){
    cin>>n>>m;
    for(int i = 1;i<=n;i++){//给第i个物品（没有第0个）赋值体积，价值与个数
        cin>>v[i]>>w[i]>>s[i];
    }
    for(int i = 1;i<=n;i++){
        for(int j = m;j>=0;j--){
            for(int k = 1;k<=s[i] && k*v[i]<=j;k++){//每种物品选几个
                dp[j] = max(dp[j],dp[j-k*v[i]]+k*w[i]);
            }
        }
    }
    cout<<dp[m]<<endl;
    return 0;
}

4——多重背包问题（数据范围1000/2000）

输入格式
第一行两个整数，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

输出样例：

这一题跟上一题的区别就是数据范围更大了，这时候三层嵌套循环就不满足时间条件了，我们可以选择把每个物品像分苹果（1000个苹果分成有限堆，可以取不同的堆来表示不同个数的苹果）一样分开（其实就是利用二进制（8421这种）可以组合为任意的数的思想），然后摊开来就像01背包问题那样解决就好了。

#include<iostream>
#include<algorithm>
using namespace std;

const int N = 2010;//物品最多数量
int dp[N];//全局自动初始化为0
int n,m;//要输入的n个物品，m的容量
int v[N],w[N],s[N];//要输入的物品的体积和物品的价值

struct Good{
    int v,w;
};

int main(){
    cin>>n>>m;
    vector<Good> goods;
    for(int i = 1;i<=n;i++){//给第i个物品（没有第0个）赋体积与价值
        cin>>v[i]>>w[i]>>s[i];
        //把每个物品像分苹果（1000个苹果分成有限堆，可以取不同的堆来表示不同个数的苹果）一样分开
        for(int k = 1;k<=s[i];k*=2){
            s[i] = s[i]-k;
            goods.push_back({v[i]*k,w[i]*k});
        }
        if(s[i]>0) goods.push_back({v[i]*s[i],w[i]*s[i]});
    }
    //现在就回归到01背包问题
    for(auto good:goods){
        for(int j = m;j>=good.v;j--){
            dp[j] = max(dp[j],dp[j-good.v]+good.w);
        }
    }
    cout<<dp[m]<<endl;
    return 0;
}

比较难理解，多自己敲几遍，反复思考就好了，观看视频连接：
大雪菜闫氏DP

Kuany_

关注

2
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
经典背包问题1——01背包问题、完全背包问题、多重背包问题（数据范围100）、多重背包问题（数据范围1000/2000）

经典背包问题——01背包问题有 N 件物品和一个容量是 V的背包。每件物品只能使用一次。第 i件物品的体积是 vi，价值是 wi。求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。输出最大价值。输入格式第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。接下来有 N行，每行两个整数 vi,wi，用空格隔开，分别表示第 i件物品的体积和价值。输出格式输出一个整数，表示最大价值。数据范围0<N,V≤10000<vi,wi≤1000输入样例
复制链接

扫一扫