背包问题总结

最新推荐文章于 2024-07-08 22:12:26 发布

jdsdyy

最新推荐文章于 2024-07-08 22:12:26 发布

阅读量88

点赞数 1

文章标签：算法动态规划 c++

本文链接：https://blog.csdn.net/2201_75581681/article/details/132925287

版权

总体背包问题思路

立足与已做过的题目

画好dp图，分析问题时使用原来已写过的题进行对照，就可以得出问题的求解思路。

简单背包问题

AcWing 2. 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
输出样例：
8

思路：以这最简单的第一题为例，dp算法其实就是对状态的压缩，以一个量（集合）来表示（维护）多个量（集合）。此时我们可以这样思考，对于第i件物品我们可以选或者不选他，于是就产生了两个集合，这两个集合就可以表示从1到i中选的最大总价值，此时用两维的变量表示就可以。f[i][j](第i个物品体积为j时的表示的最大体积)=max(f[i-1][j](不选第i个物品),f[i-1,j-v[i]]+w[i](选第i个物品))。

图示：

#include<iostream>
#include<algorithm>

using namespace std;

const int N=1010;

int n,V,v[N],w[N],f[N][N];

int main()
{
    cin>>n>>V;
    
    for(int i=1;i<=n;i++) cin>>v[i]>>w[i];
    
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=V;j++)
        {
            f[i][j]=f[i-1][j];//因为这里为避免下标为负数，所以从1开始枚举
            if(j>=v[i])
                f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i]);
        }
    }
    
    printf("%d",f[n][V]);//表示从1到n个物品中选，总体积为V的最大价值
    
    return 0;
}

观察上方的计算过程：我们可以发现可以将第1维消去，此时体积需要从大到小枚举，为了保证枚举的时候都是由上一个的状态转移过来的，即假设j大于v[i]，此时f[j-v[i]]一定是上一层f[i-1]更新的状态，如果是从小到大枚举体积，则是会使得枚举的是这一层f[i]更新的状态，即第i件物品被反复使用。

#include<iostream>
#include<algorithm>

using namespace std;

const int N=1010;

int n,V,f[N];

int main()
{
    cin>>n>>V;
    
    for(int i=1;i<=n;i++)
    {
        int v,w;
        cin>>v>>w;
        for(int j=V;j>=v;j--)
            f[j]=max(f[j],f[j-v]+w);
    }
    
    cout<<f[V];
    
    return 0;
}

AcWing 3. 完全背包问题

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

思路：因为此时的每个物品可以选无限个，参照上一题的思路可是很快发现此时我们仅仅需要将体积从小到大枚举就是本题的答案了。

#include<iostream>
#include<algorithm>

using namespace std;

const int N=1010;

int f[N],n,V;

int main()
{
    cin>>n>>V;
    for(int i=1;i<=n;i++)
    {
        int v,w;
        cin>>v>>w;
        for(int j=v;j<=V;j++)
            f[j]=max(f[j],f[j-v]+w);
    }
    
    cout<<f[V];
    
    return 0;
}

AcWing 4. 多重背包问题

有 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

思路：此题可以将每一件物品都看成单独的物品，就可以采用01背包的模板直接做。记得将数组开大点。

#include<iostream>
#include<algorithm>

using namespace std;

const int N=10100;

int n,V,f[N],v[N],w[N],idx;

int main()
{
    cin>>n>>V;
    
    for(int i=1;i<=n;i++)
    {
        int v1,w1,s1;
        cin>>v1>>w1>>s1;
        while(s1--) {v[++idx]=v1;w[idx]=w1;}
    }
    for(int i=1;i<=idx;i++)
    {
 
        for(int j=V;j>=v[i];j--)
            f[j]=max(f[j],f[j-v[i]]+w[i]);
    }
    
    cout<<f[V];
    
    return 0;
}

AcWing 5. 多重背包问题

有 N种物品和一个容量是 V的背包。第 i 种物品最多有 si件，每件体积是 vi，价值是 wi。

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

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

思路：

此题看上去是一道与上一题一样的题，但是注意此时的数据范围阔大，此时我们不能够直接的生硬的将每一件物品看成独立的物品，我们可以采用二进制优化的方法化简为01背包问题。

二进制优化：采用1，2，4，8，他们的组合可以表示1到15的任意组合，如果s还有剩余，就直接将他视作下一位。

#include<iostream>
#include<algorithm>

using namespace std;

const int N=100010;
int f[N],v[N],w[N],idx,n,V;

int main()
{
    cin>>n>>V;
    
    for(int i=0;i<n;i++)
    {
        int v1,w1,s;
        cin>>v1>>w1>>s;
        
        for(int i=1;i<=s;i*=2)
        {
            v[++idx]=i*v1,w[idx]=i*w1;
            s-=i;
        }
        if(s) v[++idx]=s*v1,w[idx]=s*w1;
    }
    
    for(int i=1;i<=idx;i++)
        for(int j=V;j>=v[i];j--)
            f[j]=max(f[j],f[j-v[i]]+w[i]);
            
    cout<<f[V];
    
    return 0;
}

AcWing 9. 分组背包问题

有 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方式，无法优化.

#include<iostream>
#include<algorithm>

using namespace std;

const int N=110;

int f[N][N],v[N][N],w[N][N],s[N],n,V;

int main()
{
    cin>>n>>V;
    
    for(int i=1;i<=n;i++)
    {
        cin>>s[i];
        for(int j=0;j<s[i];j++) cin>>v[i][j]>>w[i][j];
    }
    
    for(int i=1;i<=n;i++)
        for(int j=0;j<=V;j++)
        {
            f[i][j]=f[i-1][j];
            for(int k=0;k<s[i];k++)
                if(j>=v[i][k]) f[i][j]=max(f[i][j],f[i-1][j-v[i][k]]+w[i][k]);
        }
        
    cout<<f[n][V];
    
    return 0;
}

中等偏上背包问题

AcWing 423. 采药

辰辰是个天资聪颖的孩子，他的梦想是成为世界上最伟大的医师。为此，他想拜附近最有威望的医师为师。医师为了判断他的资质，给他出了一个难题。

医师把他带到一个到处都是草药的山洞里对他说：“孩子，这个山洞里有一些不同的草药，采每一株都需要一些时间，每一株也有它自身的价值。我会给你一段时间，在这段时间里，你可以采到一些草药。如果你是一个聪明的孩子，你应该可以让采到的草药的总价值最大。”

如果你是辰辰，你能完成这个任务吗？

输入格式
输入文件的第一行有两个整数 T和 M，用一个空格隔开，T代表总共能够用来采药的时间，M
代表山洞里的草药的数目。

接下来的 M行每行包括两个在 1 到 100之间（包括 1和 100）的整数，分别表示采摘某株草药的时间和这株草药的价值。

输出格式
输出文件包括一行，这一行只包含一个整数，表示在规定的时间内，可以采到的草药的最大总价值。

数据范围
1≤T≤1000
1≤M≤100
输入样例：
70 3
71 100
69 1
1 2
输出样例：
3

思路：首先这个题目跟01背包完全相似，01背包为在体积为V的情况下的最大物品的价值，对应本题目在时间为T的情况下对应的草药的最大价值。

于是直接拿01的模板直接过。~~这里就不再写代码了~~

AcWing 1024. 装箱问题

有一个箱子容量为 V，同时有 n 个物品，每个物品有一个体积（正整数）。

要求 n 个物品中，任取若干个装入箱内，使箱子的剩余空间为最小。

输入格式
第一行是一个整数 V，表示箱子容量。

第二行是一个整数 n，表示物品数。

接下来 n 行，每行一个正整数（不超过10000），分别表示这 n 个物品的各自体积。

输出格式
一个整数，表示箱子剩余空间。

数据范围
0<V≤20000
,
0<n≤30
输入样例：
24
6
8
3
12
7
9
7
输出样例：
0

思路：这个题目看似与01背包没有关联，其实可以这样思考，我们可以求在体积为j的情况下的最大体积是多少，然后用j减去他的最大体积就是剩余的体积，即把体积看成价值，相应问题转化为在体积为v的情况下的最大体积（价值），再用v减去就得到剩余的体积。

#include<iostream>
#include<algorithm>

using namespace std;

const int N=200010;
int f[N],n,v;

int main()
{
    cin>>v>>n;
    
    int v1;
    for(int i=0;i<n;i++)
    {
        cin>>v1;
        for(int j=v;j>=v1;j--)
            f[j]=max(f[j],f[j-v1]+v1);//体积为j的最大体积是多少
    }
    
    cout<<v-f[v];
    return 0;
}

AcWing 1022. 宠物小精灵之收服

宠物小精灵是一部讲述小智和他的搭档皮卡丘一起冒险的故事。

一天，小智和皮卡丘来到了小精灵狩猎场，里面有很多珍贵的野生宠物小精灵。

小智也想收服其中的一些小精灵。然而，野生的小精灵并不那么容易被收服。

对于每一个野生小精灵而言，小智可能需要使用很多个精灵球才能收服它，而在收服过程中，野生小精灵也会对皮卡丘造成一定的伤害（从而减少皮卡丘的体力）。

当皮卡丘的体力小于等于0时，小智就必须结束狩猎（因为他需要给皮卡丘疗伤），而使得皮卡丘体力小于等于0的野生小精灵也不会被小智收服。

当小智的精灵球用完时，狩猎也宣告结束。

我们假设小智遇到野生小精灵时有两个选择：收服它，或者离开它。

如果小智选择了收服，那么一定会扔出能够收服该小精灵的精灵球，而皮卡丘也一定会受到相应的伤害；如果选择离开它，那么小智不会损失精灵球，皮卡丘也不会损失体力。

小智的目标有两个：主要目标是收服尽可能多的野生小精灵；如果可以收服的小精灵数量一样，小智希望皮卡丘受到的伤害越小（剩余体力越大），因为他们还要继续冒险。

现在已知小智的精灵球数量和皮卡丘的初始体力，已知每一个小精灵需要的用于收服的精灵球数目和它在被收服过程中会对皮卡丘造成的伤害数目。

请问，小智该如何选择收服哪些小精灵以达到他的目标呢？

输入格式
输入数据的第一行包含三个整数：N，M，K，分别代表小智的精灵球数量、皮卡丘初始的体力值、野生小精灵的数量。

之后的K行，每一行代表一个野生小精灵，包括两个整数：收服该小精灵需要的精灵球的数量，以及收服过程中对皮卡丘造成的伤害。

输出格式
输出为一行，包含两个整数：C，R，分别表示最多收服C个小精灵，以及收服C个小精灵时皮卡丘的剩余体力值最多为R。

数据范围
0<N≤1000
0<M≤500
0<K≤100
输入样例1：
10 100 5
7 10
2 40
2 50
1 20
4 20
输出样例1：
3 30
输入样例2：
10 100 5
8 110
12 10
20 10
5 200
1 110
输出样例2：
0 100

思路：此题有点长，不过大家应该都接触过这样的游戏，我们需要培育一种抽象的思维，将题目抽象为如下问题：在限制为V1下，限制为V2-1（皮卡丘体力为0时失败，故不能取到V2）下的最大的价值，每一个物品在V1下有对应的v1,在V2-1下有对应的v2，价值都是1，选出他的最大价值。还可以这样解释，在体积为j的情况下，重量为k的情况下求最大价值，每个物品都有对应的体积和重量，价值都为1。

#include<iostream>
#include<algorithm>

using namespace std;

const int N=1010,M=510;
int f[N][M],V1,V2,m;

int main()
{
    cin>>V1>>V2>>m;
    
    int v1,v2;
    for(int i=0;i<m;i++)
    {
        cin>>v1>>v2;
        for(int j=V1;j>=v1;j--)
            for(int k=V2-1;k>=v2;k--)
                f[j][k]=max(f[j][k],f[j-v1][k-v2]+1);
    }
    
    int k=V2-1;
    while(0<k&&f[V1][V2-1]==f[V1][k-1]) k--;
    
    cout<<f[V1][V2-1]<<" "<<V2-k;
    return 0;
}

注：根据01背包优化问题，我们一样可以优化他成两维，两维可以调转，对最走的答案无影响。

这里给出两维调转的代码，~~希望读者能够多多思考，不要固化思维。~~

#include<iostream>
#include<algorithm>

using namespace std;

const int N=1010,M=510;
int f[M][N],V1,V2,m;

int main()
{
    cin>>V1>>V2>>m;
    
    int v1,v2;
    for(int i=0;i<m;i++)
    {
        cin>>v1>>v2;
        for(int j=V2-1;j>=v2;j--)
            for(int k=V1;k>=v1;k--)
                f[j][k]=max(f[j][k],f[j-v2][k-v1]+1);
    }
    
    int k=V2-1;
    while(0<k&&f[V2-1][V1]==f[k-1][V1]) k--;
    
    cout<<f[V2-1][V1]<<" "<<V2-k;
    return 0;
}

AcWing 278. 数字组合

给定 N个正整数 A1,A2,…,AN，从中选出若干个数，使它们的和为 M，求有多少种选择方案。

输入格式
第一行包含两个整数 N和 M。

第二行包含 N个整数，表示 A1,A2,…,AN。

输出格式
包含一个整数，表示可选方案数。

数据范围
1≤N≤100
1≤M≤10000
1≤Ai≤1000
答案保证在 int 范围内。

输入样例：
4 4
1 1 2 2
输出样例：
3

思路：将此问题一样转化为01背包问题，此时是方案数。

#include<iostream>
#include<algorithm>

using namespace std;

const int N=10010;

int f[N],n,M;

int main()
{
    cin>>n>>M;
    
    int v1;
    
    f[0]=1;//注意，什么都不选，即和为0也是一种方案
    for(int i=0;i<n;i++)
    {
        cin>>v1;
        for(int j=M;j>=v1;j--)
            f[j]+=f[j-v1];
    }
    
    cout<<f[M];
    
    return 0;
}

AcWing 1023. 买书

小明手里有n元钱全部用来买书，书的价格为10元，20元，50元，100元。

问小明有多少种买书方案？（每种书可购买多本）

输入格式
一个整数 n，代表总共钱数。

输出格式
一个整数，代表选择方案种数。

数据范围
0≤n≤1000
输入样例1：
20
输出样例1：
2
输入样例2：
15
输出样例2：
0
输入样例3：
0
输出样例3：
1

思路：因为每本书可以选多次，于是可以联想到完全背包问题

#include<iostream>
#include<algorithm>

using namespace std;

const int N=1010;
int a[4]={10,20,50,100};
int f[N],V;

int main()
{
    cin>>V;
    
    f[0]=1;//一本书都不买也是一种方案
    for(int i=0;i<4;i++)
        for(int j=a[i];j<=V;j++)
            f[j]+=f[j-a[i]];
            
    cout<<f[V];
    return 0;
}

AcWing 1021. 货币系统

给你一个n种面值的货币系统，求组成面值为m的货币有多少种方案。

输入格式
第一行，包含两个整数n和m。

接下来n行，每行包含一个整数，表示一种货币的面值。

输出格式
共一行，包含一个整数，表示方案数。

数据范围
n≤15,m≤3000
输入样例：
3 10
1
2
5
输出样例：
10

思路：此题与上题类似，不再赘述。

#include<iostream>
#include<algorithm>

using namespace std;

const int N=3010;
int n,m;
long long f[N];
int main()
{
    cin>>n>>m;
    
    int v1;
    f[0]=1;
    for(int i=0;i<n;i++)
    {
        cin>>v1;
        for(int j=v1;j<=m;j++)
            f[j]+=f[j-v1];
    }
    
    cout<<f[m];
    
    return 0;
}

AcWing 532. 货币系统

在网友的国度中共有 n 种不同面额的货币,第i种货币的面额为a[i],你可以假设每一种货币都有无穷多张。为了方便，我们把货币种数为n、面额数组为a[1..n]的货币系统记作(n,a)。

在一个完善的货币系统中,每一个非负整数的金额 x都应该可以被表示出,即对每一个非负整数x,都存在n个非负整数 t[i]满足 a[i] × t[i] 的和为 x。

然而，在网友的国度中，货币系统可能是不完善的，即可能存在金额 x 不能被该货币系统表示出。

例如在货币系统 n = 3, a =[2,5,9] 中，金额 1,3 就无法被表示出来。

两个货币系统(n,a)和(m,b)是等价的,当且仅当对于任意非负整数x,它要么均可以被两个货币系统表出,要么不能被其中任何一个表出。

现在网友们打算简化—下货币系统。

他们希望找到一个货币系统（m,b），满足（m,b）与原来的货币系统（n,a）等价，且 m尽可能的小。

他们希望你来协助完成这个艰巨的任务：找到最小的 m。

输入格式

输入文件的第一行包含一个整数 T，表示数据的组数。

接下来按照如下格式分别给出 T 组数据。

每组数据的第一行包含一个正整数 n.

接下来一行包含 n 个由空格隔开的正整数 a[i]。

输出格式

输出文件共有T行,对于每组数据,输出一行一个正整数,表示所有与(n,a)等价的货币系统(m,b)中,最小的 m。

数据范围

1<n<100,

1<a[i] <25000,

1<T<20

输入样例：

2

3 19 10 6

5

11 29 13 19 17

输出样例：

5

思路：这是一道线性代数问题，求最大的线性无关组（这个组中每个变量都不能够表示为其他的量），应该将读入的变量先排序，通过从小到大的筛法将能够表示出来的ai筛出去，无关组中的个数就是最后的答案。

#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

const int N=110,M=25010;
int a[N],n;
bool f[M];

int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        cin>>n;
        for(int i=1;i<=n;i++) cin>>a[i];
        sort(a+1,a+n+1);
        
        memset(f,0,sizeof f);
        f[0]=true;//设置0为真，是为了更新初始值，即f[a[i]-a[i]];
        int res=0;
        for(int i=1;i<=n;i++)
        {
            if(f[a[i]]) continue;
            res++;
            
            for(int j=a[i];j<=a[n];j++)
                f[j]|=f[j-a[i]];
        }
        
        cout<<res<<endl;
    }
    
    return 0;
}

AcWing 6. 多重背包问题 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

单调对列

#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

const int N=20010;
int f[N],g[N],q[N],v[N],w[N],s[N];
int n,V;
int main()
{
    cin>>n>>V;
    for(int i=0;i<n;i++) cin>>v[i]>>w[i]>>s[i];
    
    for(int i=0;i<n;i++)
    {
        memcpy(g,f,sizeof g);
        for(int r=0;r<v[i];r++)
        {
            int hh=0,tt=-1;
            for(int j=r;j<=V;j+=v[i])
            {
                
                while(hh<=tt&&j-q[hh]>v[i]*s[i]) hh++;//去掉头部，往左边滑动
                while(hh<=tt&&g[q[tt]]+(j-q[tt])/v[i]*w[i]<=g[j]) tt--;//保证队列单调递减
                q[++tt]=j;//入队
                f[j]=g[q[hh]]+(j-q[hh])/v[i]*w[i];//以头节点来更新f，保证其为最大值
            }
        }
    }
    
    cout<<f[V];
    
    return 0;
}

至此，恭喜你成功挑战成功一道男人八题中的一题。

AcWing 1019. 庆功会

为了庆贺班级在校运动会上取得全校第一名成绩，班主任决定开一场庆功会，为此拨款购买奖品犒劳运动员。

期望拨款金额能购买最大价值的奖品，可以补充他们的精力和体力。

输入格式
第一行二个数n，m，其中n代表希望购买的奖品的种数，m表示拨款金额。

接下来n行，每行3个数，v、w、s，分别表示第I种奖品的价格、价值（价格与价值是不同的概念）和能购买的最大数量（买0件到s件均可）。

输出格式
一行：一个数，表示此次购买能获得的最大的价值（注意！不是价格）。

数据范围
n≤500,m≤6000
v≤100,w≤1000,s≤10
输入样例：
5 1000
80 20 4
40 50 9
30 50 7
40 30 6
20 20 1
输出样例：
1040

思路：此题可以参照上一题的思路，不过换了一种说法，请读者自行完成思考。这里直接给代码。

#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

const int N=510,M=6010;
int f[M],g[M],q[M],v[N],w[N],s[N];
int n,m;
int main()
{
    cin>>n>>m;
    
    for(int i=0;i<n;i++) cin>>v[i]>>w[i]>>s[i];
    
    for(int i=0;i<n;i++)
    {
        memcpy(g,f,sizeof g);
        for(int r=0;r<v[i];r++)
        {
            int hh=0,tt=-1;
            for(int j=r;j<=m;j+=v[i])
            {
                while(hh<=tt&&j-q[hh]>v[i]*s[i]) hh++;
                while(hh<=tt&&g[q[tt]]+(j-q[tt])/v[i]*w[i]<=g[j]) tt--;
                q[++tt]=j;
                f[j]=g[q[hh]]+(j-q[hh])/v[i]*w[i];
            }
        }
    }
    
    cout<<f[m];
    return 0;
}

AcWing 7. 混合背包问题

有 N种物品和一个容量是 V的背包。

物品一共有三类：

第一类物品只能用1次（01背包）；
第二类物品可以用无限次（完全背包）；
第三类物品最多只能用 si次（多重背包）；每种体积是 vi，价值是 wi。

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

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

接下来有 N行，每行三个整数 vi,wi,si，用空格隔开，分别表示第 i种物品的体积、价值和数量。

si=−1表示第 i种物品只能用1次；
si=0表示第 i种物品可以用无限次；
si>0表示第 i种物品可以使用 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

思路：将前面的三种结合起来就是本题的解法。

#include<iostream>
#include<algorithm>

using namespace std;

const int N=1010,M=200010;
int f[N];
bool st[N];
int n,V;

void fa(int a,int b)
{
    for(int j=V;j>=a;j--)
        f[j]=max(f[j],f[j-a]+b);
}

void g(int a,int b)
{
    for(int j=b;j<=V;j++)
        f[j]=max(f[j],f[j-a]+b);
}
int main()
{
    cin>>n>>V;
    
    for(int i=0;i<n;i++) 
    {
        int a,b,c;
        cin>>a>>b>>c;
        if(c==-1) fa(a,b);
        else if(c==0) g(a,b);
        else
        {
            for(int i=1;i<=c;i*=2)
            {
                fa(a*i,b*i);
                c-=i;
            }
            if(c) fa(a*c,b*c);
        }
    }
    
    cout<<f[V];
    
    return 0;
}

AcWing 8. 二维费用的背包问题

有 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

#include<iostream>
#include<algorithm>

using namespace std;

const int N=110;
int f[N][N],n,m,V;

int main()
{
    cin>>n>>V>>m;
    
    int v1,m1,w1;
    for(int i=0;i<n;i++)
    {
        cin>>v1>>m1>>w1;
        for(int j=m;j>=m1;j--)
            for(int k=V;k>=v1;k--)
                f[j][k]=max(f[j][k],f[j-m1][k-v1]+w1);
    }
    
    cout<<f[m][V];
    return 0;
}

AcWing 1020. 潜水员

潜水员为了潜水要使用特殊的装备。

他有一个带2种气体的气缸：一个为氧气，一个为氮气。

让潜水员下潜的深度需要各种数量的氧和氮。潜水员有一定数量的气缸。

每个气缸都有重量和气体容量。潜水员为了完成他的工作需要特定数量的氧和氮。

他完成工作所需气缸的总重的最低限度的是多少？

例如：潜水员有5个气缸。每行三个数字为：氧，氮的（升）量和气缸的重量：

3 36 120

10 25 129

5 50 250

1 45 130

4 20 119
如果潜水员需要5升的氧和60升的氮则总重最小为249（1，2或者4，5号气缸）。

你的任务就是计算潜水员为了完成他的工作需要的气缸的重量的最低值。

输入格式
第一行有2个整数 m，n。它们表示氧，氮各自需要的量。

第二行为整数 k表示气缸的个数。

此后的 k行，每行包括ai，bi，ci，3个整数。这些各自是：第 i个气缸里的氧和氮的容量及气缸重量。

输出格式
仅一行包含一个整数，为潜水员完成工作所需的气缸的重量总和的最低值。

数据范围
1≤m≤21
1≤n≤79
1≤k≤1000
1≤ai≤21
1≤bi≤79
1≤ci≤800
输入样例：
5 60
5
3 36 120
10 25 129
5 50 250
1 45 130
4 20 119
输出样例：
249

#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

const int N=22,M=80;
int f[N][M];

int main()
{
    int v1,v2,n;
    cin>>v1>>v2>>n;
    int a,b,c;
    
    memset(f,0x3f,sizeof f);
    f[0][0]=0;
    
    for(int i=1;i<=n;i++)
    {
        cin>>a>>b>>c;
        for(int j=v1;j>=0;j--)
            for(int k=v2;k>=0;k--)
                f[j][k]=min(f[j][k],f[max(0,j-a)][max(0,k-b)]+c);
    }
    
    cout<<f[v1][v2];
    return 0;
}
/*该题也是二位费组背包问题，用f[i][j][k]表示的是从1-i中选容量1至少是j，容量2至少是k的最大价值
于是第2，3维应该取可以取负数，根据题意，应该让它直接为0的状态就可以了
状态转移还是从01背包的角度考虑，包含第i个物品和不包含第i个物品从大到小枚举就是上一层的状态
*/