背包九讲

最新推荐文章于 2022-06-17 22:12:18 发布

Pegasi_Tio

最新推荐文章于 2022-06-17 22:12:18 发布

阅读量152

点赞数

分类专栏： AcWing ACM 文章标签： dp 动态规划背包

本文链接：https://blog.csdn.net/PegasiTIO/article/details/104866532

版权

ACM 同时被 2 个专栏收录

115 篇文章 0 订阅

订阅专栏

AcWing

2 篇文章 0 订阅

订阅专栏

题目链接

超级无敌蒟蒻和y总学习第二弹.jpg

01背包问题

有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。

第 ii 件物品的体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

输入格式

第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。

接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 ii 件物品的体积和价值。

输出格式

输出一个整数，表示最大价值。

数据范围

0<N,V≤1000
0<vi,wi≤1000

输入样例

输出样例：

理解背包很关键就是自己模拟一次过程，我自己写的太丑了就不上图片了，模拟一遍样例就啥都明白了
二维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

输入样例

输出样例：

每个物品无限也就是可以在选完一次的状态下继续选，也就相当于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

输入样例

输出样例：

再多加一层判断枚举个数即可

#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

提示：

本题考查多重背包的二进制优化方法。

输入样例

输出样例：

数据范围增大，三重循环达到4x10^9，是不可行的

1的思想是把所有可能的物品都加进的物品栏，比如i的1倍，两倍等等，把s个分成了s份

s种情况可以用 $log_2s$ 上取整得到

取完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

提示

本题考查多重背包的单调队列优化方法。

输入样例

输出样例：

通过单调队列优化来提升速度

首先第一个特点是：状态只会从背包容量对物体体积求余相等的状态转移过来

当物品体积为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

输入样例

输出样例：

把物品按照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

输入样例

输出样例：

多一种状态用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

输入样例

输出样例：

分组背包是一个特殊的多重背包

分组背包的一组相当于多重背包中的一个物品，一组中的不同物品可以想象成多重背包中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 的背包。

物品之间具有依赖关系，且依赖关系组成一棵树的形状。如果选择一个物品，则必须选择它的父节点。

如下图所示：
QQ图片20181018170337.png

如果选择物品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;

输入样例

输出样例：

用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

输入样例

输出样例：

设置一个数组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

输入样例

输出样例：

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;
}

Pegasi_Tio

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
背包九讲

超级无敌蒟蒻和y总学习第二弹.jpg01背包问题有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。第 ii 件物品的体积是 vi，价值是 wi。求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。输出最大价值。输入格式第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 ...
复制链接

扫一扫

专栏目录