求方案数初始化总结

二维 

1.体积至多是 j   f[0][i]=1 (0<=i<=m) 其余为 0 （因为体积是至多是j 它可以小于j f[0][0]=1 是肯定的 f[0][i] 这当中 i也可以包括0 一定要get到至多 即便不选物品 f[0][i]也是 1 它可以包含f[0][0])

2.体积恰好是 j f[0][0]=1 其余都为 0（因为恰好 f[0][j]（j>0) 无法在不选择物品的条件下达到 j 故是0 ）

3.体积至少是 j f[0][0]=1 其余都为0（f[0][j]（j>0) 体积至少 是 j 故不可能在不选择物品的条件下达到j 故其也为0）

一维 

 1.体积至多是 j   f[i]=1(0<=i<=m)

2.体积恰好是 j f[0]=1,其余都为0

3.体积至少是 j  f[0]=1，其余都为0

求最大值最小值初始化总结  

二维 

1.体积至多 j f[i,j]=0 (0<=i<=n,0<=j<=m) (只会求价值的最大值）

2.体积恰好是 j 

     当求价值的最小值时 f[0][0]=0  其余为 INF

     当求价值的最大值时 f[0][0]=0 其余为 -INF

3.体积至少是 j f[0][0]=0 其余为 INF（只会求价值的最小值）

 一维

1、体积至多j，f[i] = 0, 0 <= i <= m（只会求价值的最大值）
2、体积恰好j，
         当求价值的最小值：f[0] = 0, 其余是INF
         当求价值的最大值：f[0] = 0, 其余是-INF
3、体积至少j，f[0] = 0，其余是INF（只会求价值的最小值）

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

 

#include<iostream>
#include<algorithm>
using namespace std;
const int N=1010;
int v[N],w[N];  // 体积 价值 
int f[N][N]; // f[i][j], j体积下前i个物品的最大价值
int main()
{
    int n,m;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++)
        {
            //  当前背包容量装不进第i个物品，则价值等于前i-1个物品
            if(j<v[i]) f[i][j]=f[i-1][j];
           // 能装，需进行决策是否选择第i个物品
            else f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i]);
        }
    }
    cout<<f[n][m]<<endl;
    return 0;
}

 

一维 

#include<iostream>
#include<algorithm>
using namespace std;
const int N=1010;
int v[N],w[N];
int f[N];
int main()
{
    int n,m;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=m;j>=v[i];j--)
        {
            f[j]=max(f[j],f[j-v[i]]+w[i]);
        }
    }
    cout<<f[m]<<endl;
    return 0;
}

采药（最大价值Max）

辰辰是个天资聪颖的孩子，他的梦想是成为世界上最伟大的医师。

为此，他想拜附近最有威望的医师为师。

医师为了判断他的资质，给他出了一个难题。

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

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

输入格式

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

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

输出格式

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

数据范围

1≤T≤1000
1≤M≤100

输入样例：

70 3
71 100
69 1
1 2

输出样例：

3

 二维

#include<iostream>
using namespace std;
const int N=1010;
int f[N][N];//f[i,j] 在前i个药品中选，不超过j的最大价值
int t[N],w[N];//时间 价值
int main()
{
    int T,n;cin>>T>>n;
    for(int i=1;i<=n;i++) cin>>t[i]>>w[i];
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=T;j++)
        {
            f[i][j]=f[i-1][j];
            if(j>=t[i]) f[i][j]=max(f[i][j],f[i-1][j-t[i]]+w[i]);
        }
    }
    cout<<f[n][T]<<endl;
    return 0;
}

 一维

#include<iostream>
using namespace std;
const int N=1010;
int f[N];//f[i,j] 在前i个药品中选，不超过j的最大价值
int t[N],w[N];//时间 价值
int main()
{
    int T,n;cin>>T>>n;
    for(int i=1;i<=n;i++)
    {
        cin>>t[i]>>w[i];
        for(int j=T;j>=t[i];j--) f[j]=max(f[j],f[j-t[i]]+w[i]);
    }
    cout<<f[T]<<endl;
    
    return 0;
}

装箱问题 (最大价值Max）

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

要求 n 个物品中，任取若干个装入箱内，使箱子的剩余空间为最小(剩余最小即所用空间最大 求出来用原空间相减即可）

输入格式

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

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

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

输出格式

一个整数，表示箱子剩余空间。

数据范围

0<V≤20000
0<n≤30

输入样例：

24
6
8
3
12
7
9
7

输出样例：

0

#include<iostream>
#include<cstring>
using namespace std;
const int N=33;
int v[N];
int f[N][21000];
int main()
{
    int V;cin>>V;
    int n;cin>>n;
    for(int i=1;i<=n;i++) cin>>v[i];//把价值弄成体积
    
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=V;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]]+v[i]);//选
        }
    }
   cout<<V-f[n][V]<<endl;//含义：箱子最大容积 - 所有选中物品合起来的最大体积
    return 0;
}

 宠物小精灵之收服（Max）

(二维费用01背包问题)

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

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

小智也想收服其中的一些小精灵。

然而，野生的小精灵并不那么容易被收服。

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

当皮卡丘的体力小于等于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

 

 

#include<iostream>
#include<algorithm>
using namespace std;
const int N=1010,W=550;
int f[N][W];//f[i][j]表示精灵球为i 体积值为j 收服小精灵的最大数量
int v1[N],v2[N];//收服小精灵需要的精灵球(价值1) 和 伤害值(价值2)
int main()
{
    int n,m,K;cin>>n>>m>>K;
    for(int i=1;i<=K;i++) cin>>v1[i]>>v2[i];
    for(int i=1;i<=K;i++)
    {
        //三维转化为二维 
        for(int j=n;j>=v1[i];j--)
        {
          //不能从m开始遍历 因为从m 开始的话说明皮卡丘体力为0 不可
            for(int k=m-1;k>=v2[i];k--)
            {
                f[j][k]=max(f[j][k],f[j-v1[i]][k-v2[i]]+1);
            }
        }
    }
    cout<<f[n][m-1]<<" ";
    for(int k=0;k<=m-1;k++)
    {
        if(f[n][k]==f[n][m-1])
        {
            cout<<m-k<<endl;break;
        }
    }
    return 0;
}

#include<iostream>
#include<algorithm>
using namespace std;
const int N=1010,W=550;
int f[N][W];//f[i][j]表示精灵球为i 体积值为j 收服小精灵的最大数量
int v1[N],v2[N];//收服小精灵需要的精灵球(价值1) 和 伤害值(价值2)
int main()
{
    int n,m,K;cin>>n>>m>>K;
    for(int i=1;i<=K;i++)
    {
        int V1,V2;cin>>V1>>V2;
        for(int j=n;j>=V1;j--)
        {
            for(int k=m-1;k>=V2;k--)
            {
                f[j][k]=max(f[j][k],f[j-V1][k-V2]+1);
            }
        }
    }
    cout<<f[n][m-1]<<" ";
    for(int k=0;k<=m-1;k++)
    {
        if(f[n][k]==f[n][m-1])
        {
            cout<<m-k<<endl;break;
        }
    }
    return 0;
}

 数字组合(求数量 Count)

给定 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

 二维

#include<iostream>
using namespace std;
const int N=110,M=11000;
int f[N][M];//f[i][j]从前i个物品中选,体积刚好为j的数量
int v[N];//第几个数就是第几个物品,数的大小为体积
int main()
{
    int n,m;cin>>n>>m;
    for(int i=1;i<=n;i++) cin>>v[i];
    f[0][0]=1;
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=m;j++)
        {
            f[i][j]=f[i-1][j];//不选
            if(j>=v[i]) f[i][j]+=f[i-1][j-v[i]];//选
        }
    }
    cout<<f[n][m]<<endl;
    return 0;
}

一维 

#include<iostream>
using namespace std;
const int M=11000;
int f[M];
int main()
{
    int n,m;cin>>n>>m;
    f[0]=1;
    for(int i=1;i<=n;i++)
    {
        int v;cin>>v;
        for(int j=m;j>=v;j--)
        {
            f[j]+=f[j-v];
        }
    }
    cout<<f[m]<<endl;
    return 0;
}

开心的金明 (Max)

金明今天很开心，家里购置的新房就要领钥匙了，新房里有一间他自己专用的很宽敞的房间。

更让他高兴的是，妈妈昨天对他说：“你的房间需要购买哪些物品，怎么布置，你说了算，只要不超过 N 元钱就行”。

今天一早金明就开始做预算，但是他想买的东西太多了，肯定会超过妈妈限定的 N 元。

于是，他把每件物品规定了一个重要度，分为 5 等：用整数 1∼5表示，第 5 等最重要。

他还从因特网上查到了每件物品的价格（都是整数元）。

他希望在不超过 N 元（可以等于 N 元）的前提下，使每件物品的价格与重要度的乘积的总和最大。 

设第 j 件物品的价格为 v[j]，重要度为 w[j]，共选中了 k 件物品，编号依次为 j1，j2，…，jk 则所求的总和为： 

v[j1]×w[j1]+v[j2]×w[j2]+…+v[jk]×w[jk]

请你帮助金明设计一个满足要求的购物单。

输入格式

输入文件的第 1 行，为两个正整数 N 和 m，用一个空格隔开。（其中 N 表示总钱数，m 为希望购买物品的个数） 

从第 2 行到第 m+1 行，第 jj 行给出了编号为 j−1 的物品的基本数据，每行有 2 个非负整数 v 和 p。（其中vv 表示该物品的价格，pp 表示该物品的重要度）

输出格式

输出文件只有一个正整数，为不超过总钱数的物品的价格与重要度乘积的总和的最大值（数据保证结果不超过 10^8）。

数据范围

1≤N<30000
1≤m<25
0≤v≤10000
1≤p≤5

输入样例：

1000 5
800 2
400 5
300 5
400 3
200 2

输出样例：

3900

 

#include<iostream>
using namespace std;
const int N=3e4+10;
int f[N];
int w[N],v[N];
int main()
{
    int n,m;cin>>m>>n;
    for(int i=1;i<=n;i++)
    {
        int a,b;cin>>a>>b;
        v[i]=a;//体积（价格）
        w[i]=a*b;//价值
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=m;j>=v[i];j--)
        {
            f[j]=max(f[j],f[j-v[i]]+w[i]);
        }
    }
    cout<<f[m]<<endl;
    return 0;
}

完全背包问题

有 N 种物品和一个容量是 V 的背包，每种物品都有无限件可用。

第 ii 种物品的体积是 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

基本框架    O(n^3) 会超时 

#include<iostream>
#include<algorithm>
using namespace std;
const int N=1010;
int v[N],w[N];
int f[N][N];
int main()
{
    int n,m;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=0;j<=m;j++)
        {
            for(int k=0;k*v[i]<=j;k++)
            {
                f[i][j]=max(f[i][j],f[i-1][j-k*v[i]]+k*w[i]);
            }
        }
    }
    cout<<f[n][m]<<endl;
    return 0;
}

优化

f[i , j ] = max( f[i-1,j] , f[i-1,j-v]+w ,  f[i-1,j-2*v]+2*w , f[i-1,j-3*v]+3*w , .....)
f[i , j-v]= max(            f[i-1,j-v]   ,  f[i-1,j-2*v] + w , f[i-1,j-3*v]+2*w , .....)
由上两式，可得出如下递推关系： 
                        f[i][j]=max(f[i,j-v]+w , f[i-1][j]) 

#include<iostream>
#include<algorithm>
using namespace std;
const int N=1010;
int v[N],w[N];
int f[N][N];
int main()
{
    int n,m;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=0;j<=m;j++)
        {
            f[i][j]=f[i-1][j];
            if(j>=v[i])
            {
                f[i][j]=max(f[i][j],f[i][j-v[i]]+w[i]);
            }
        }
    }
    cout<<f[n][m]<<endl;
    return 0;
}

 一维

#include<iostream>
#include<algorithm>
using namespace std;
const int N=1010;
int v[N],w[N];
int f[N];
int main()
{
    int n,m;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=0;j<=m;j++)
        {
            //原来二维与之对应的是 f[i][j]=max(f[i][j],f[i][j-v[i]]+w[i]);对应正是第i层 不是i-1层 故从小到大即可
            if(j>=v[i]) f[j]=max(f[j],f[j-v[i]]+w[i]);
        }
    }
    cout<<f[m]<<endl;
    return 0;
}

买书（求数量Count）

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

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

输入格式

一个整数 n，代表总共钱数。

输出格式

一个整数，代表选择方案种数。

数据范围

0≤n≤1000

输入样例1：

20

输出样例1：

2

输入样例2：

15

输出样例2：

0

输入样例3：

0

输出样例3：

1

 二维

#include<iostream>
using namespace std;
const int N=1010;
int f[10][N];//表示前i中物品中选择 体积刚好为j的数量
int v[5];
int main()
{
    int n;cin>>n;
    v[1]=10,v[2]=20,v[3]=50,v[4]=100;
    f[0][0]=1;
    for(int i=1;i<=4;i++)
    {
        for(int j=0;j<=n;j++)
        {
            f[i][j]=f[i-1][j];//不选
            if(j>=v[i]) f[i][j]+=f[i][j-v[i]];//选
        }
    }
    cout<<f[4][n]<<endl;
}

一维 

#include<iostream>
using namespace std;
const int N=1010;
int f[N];//体积刚好为j的数量
int v[5];
int main()
{
    int n;cin>>n;
    v[1]=10,v[2]=20,v[3]=50,v[4]=100;
    f[0]=1;
    for(int i=1;i<=4;i++)
    {
        for(int j=v[i];j<=n;j++)
        {
            f[j]+=f[j-v[i]];
        }
    }
    cout<<f[n]<<endl;
}

 货币系统（Count)

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

输入格式

第一行，包含两个整数n和m。

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

输出格式

共一行，包含一个整数，表示方案数。

数据范围

n≤15,m≤3000

输入样例：

3 10
1
2
5

输出样例：

10

#include<iostream>
using namespace std;
const int N=3300;
long long f[N];//数据范围要注意
int v[N];
int main()
{
    int n,m;cin>>n>>m;
    f[0]=1;
    for(int i=1;i<=n;i++)
    {
        cin>>v[i];
        for(int j=v[i];j<=m;j++)
        {
            f[j]+=f[j-v[i]];
        }
    }
    cout<<f[m]<<endl;
    return 0;
}

 货币系统

在网友的国度中共有 n 种不同面额的货币，第 i 种货币的面额为 a[i]，你可以假设每一种货币都有无穷多张。

为了方便，我们把货币种数为 n、面额数组为 a[1..n] 的货币系统记作 (n,a)。 

在一个完善的货币系统中，每一个非负整数的金额 x 都应该可以被表示出，即对每一个非负整数 x，都存在 n 个非负整数 t[i]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 
4 
3 19 10 6 
5 
11 29 13 19 17 

输出样例：

2
5

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

using namespace std;

//这题是一道线性代数问题
//求解一个向量组的秩(最大无关向量组的向量个数)
//但是代码写起来就是一个模拟筛的过程
//从小到大，先查看当前数有没有被晒掉，
//1)如果没有就把它加入到最大无关向量组中，并把他以及他和此前的硬币的线性组合都筛掉
//2)如果有就不理会
//即就是在完全背包求方案数的过程中，统计那些初始没有方案数的物品
//这样就变成一个完全背包问题了

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

int main()
{
    int T = 1;
    cin >> T;
    while (T -- )
    {
        cin >> n;
        for (int i = 1; i <= n; ++ i) cin >> v[i];
        sort(v + 1, v + n + 1);//排序的原因见之前的分析

        //我们只需统计所有物品的体积是否能被其他的线性表出
        //因此背包的体积只需设置为最大的物品体积即可
        //res用来记录最大无关向量组的个数
        int m = v[n], res = 0;
        memset(f, 0, sizeof f);
        f[0] = true;    //状态的初值
        for (int i = 1; i <= n; ++ i)
        {
            //如果当前物品体积被之前的物品组合线性筛掉了，则它是无效的
            if (f[v[i]]) continue;
            //如果没有被筛掉，则把它加入最大无关向量组
            res ++ ;
            //筛掉当前最大无关向量组能线性表示的体积
            for (int j = v[i]; j <= m; ++ j)
            {
                f[j] |= f[j - v[i]];
            }
        }
        //输出最大无关向量组的向量个数
        cout << res << endl;
    }
    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

输入样例

4 5
1 2 3
2 4 1
3 4 3
4 5 2

输出样例：

10

#include<iostream>
#include<algorithm>
using namespace std;
const int N=110;
int v[N],w[N],s[N];
int f[N][N];
int main()
{
    int n,m;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=0;j<=m;j++)//枚举体积
        {
            f[i][j]=f[i-1][j];
            for(int k=0;k*v[i]<=j&&k<=s[i];k++)
            {
                f[i][j]=max(f[i][j],f[i-1][j-v[i]*k]+w[i]*k);
            }
        }
    }
    cout<<f[n][m]<<endl;
    return 0;
}

多重背包问题 II

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

第 ii 种物品最多有 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

 

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=2010,M=20100; //逐一枚举最大是N*logS
int v[M],w[M];
int f[N];
int main()
{
    int n,m;cin>>n>>m;
    int cnt=0;
    for(int i=1;i<=n;i++)
    {
        int a,b,s;cin>>a>>b>>s;
        int k=1;// 组别里面的个数
        //二进制转化
        while(k<=s)
        {
            cnt++;//组别先增加
            v[cnt]=k*a;//整体体积
            w[cnt]=k*b; // 整体价值
            s-=k;// s要减小
            k*=2;// 组别里的个数增加
        }
        if(s) //剩余的一组
        {
            cnt++;
            v[cnt]=a*s;
            w[cnt]=b*s;
        }
    }
    n=cnt;
    //01背包一维优化
    for(int i = 1;i <= n ;i ++)
        for(int j = m ;j >= v[i];j --)
            f[j] = max(f[j],f[j-v[i]] + w[i]);

    cout << f[m] << endl;
    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

提示

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

输入样例

4 5
1 2 3
2 4 1
3 4 3
4 5 2

输出样例：

10

 庆功会

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

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

输入格式

第一行二个数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>
using namespace std;
const int N=550,M=6100;
int f[N][M];
int v[N],w[N],s[N];
int main()
{
    int n,V;
    cin>>n>>V;
    for(int i=1;i<=n;i++) cin>>v[i]>>w[i]>>s[i];
    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*v[i]<=j;k++)
            {
                f[i][j]=max(f[i][j],f[i-1][j-k*v[i]]+k*w[i]);
            }
        }
    }
    cout<<f[n][V]<<endl;
    return 0;
}

#include<iostream>
#include<algorithm>
using namespace std;
const int N=550,M=6100;
int f[M];
int v[N],w[N],s[N];
int main()
{
    int n,V;
    cin>>n>>V;
    for(int i=1;i<=n;i++) cin>>v[i]>>w[i]>>s[i];
    for(int i=1;i<=n;i++)
    {
        for(int j=V;j>=v[i];j--)
        {
            
            for(int k=0;k<=s[i];k++)
            {
                if(j-k*v[i]>=0)
                f[j]=max(f[j],f[j-k*v[i]]+k*w[i]);
            }
        }
    }
    cout<<f[V]<<endl;
    return 0;
}

 分组背包问题

有 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

 结论：我们可以把分组背包看成多重背包
理由：我们把每组看做一个“物品”，而这个物品我们可以选择0到si个；
通过从后向前的遍历顺序来确保，我们对组的决策只有一种：要么选这个组，要么不选；
然后在通过枚举组内的情况，来对组内进行决策：要么选0个，选1个.....；

#include<iostream>
using namespace std;
const int N=110;
int v[N][N],w[N][N],s[N];//v为体积，w为价值，s代表第i组物品的个数
int f[N][N];//从前i组物品中选，当前体积小于等于j的最大值
int main()
{
    int n,m;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];
        }
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=m;j++)
        {
            f[i][j]=f[i-1][j];//不选
            for(int k=1;k<=s[i];k++)//决策
            {
                //从中选i组中的一个
                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][m]<<endl;
    return 0;
}

转化成一维的

#include<iostream>
using namespace std;
const int N=110;
int v[N][N],w[N][N],s[N];//v为体积，w为价值，s代表第i组物品的个数
int f[N];//从前i组物品中选，当前体积小于等于j的最大值
int main()
{
    int n,m;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];
        }
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=m;j>=0;j--)
        {
           
            for(int k=0;k<=s[i];k++)//决策
            {
                //从前i组物品中选1个 或者不选
                if(j>=v[i][k]) f[j]=max(f[j],f[j-v[i][k]]+w[i][k]);
            }
        }
    }
    cout<<f[m]<<endl;
    return 0;
}

机器分配 （Max）

总公司拥有 M 台 相同 的高效设备，准备分给下属的 N 个分公司。

各分公司若获得这些设备，可以为国家提供一定的盈利。盈利与分配的设备数量有关。

问：如何分配这M台设备才能使国家得到的盈利最大？

求出最大盈利值。

分配原则：每个公司有权获得任意数目的设备，但总台数不超过设备数 M。

输入格式

第一行有两个数，第一个数是分公司数 N，第二个数是设备台数 M；

接下来是一个 N×M 的矩阵，矩阵中的第 i 行第 j 列的整数表示第 i 个公司分配 j 台机器时的盈利。

输出格式

第一行输出最大盈利值；

接下 N 行，每行有 2 个数，即分公司编号和该分公司获得设备台数。

答案不唯一，输出任意合法方案即可。

数据范围

1≤N≤10
1≤M≤15

输入样例：

3 3
30 40 50
20 30 50
20 25 30

输出样例：

70
1 1
2 1
3 1

#include<iostream>
using namespace std;
const int N=20;
int f[N][N];
int w[N][N];
int cnt[N];
int main()
{
    int n,m;cin>>n>>m;
    for(int i=1;i<=n;i++)
       for(int j=1;j<=m;j++) cin>>w[i][j];
       
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=m;j++)
        {
            for(int k=0;k<=j;k++)
            {
                f[i][j]=max(f[i][j],f[i-1][j-k]+w[i][k]);
            }
        }
    }
    cout<<f[n][m]<<endl;
    int j=m;
    for(int i=n;i>=1;i--)
    {
        for(int k=0;k<=j;k++)
        {
            if(f[i][j]==f[i-1][j-k]+w[i][k])
            {
                cnt[i]=k;
                j-=k;
                break;
            }
        }
    }
    for(int i=1;i<=n;i++) cout<<i<<" "<<cnt[i]<<endl;
    return 0;
}

 若是字典序

#include<iostream>
using namespace std;
const int N=1010;
int f[N][N];
int w[N][N];
int cnt[N];
int main()
{
    int n,m;cin>>n>>m;
    for(int i=1;i<=n;i++)
    for(int j=1;j<=m;j++) cin>>w[i][j];
    for(int i=n;i>=1;i--)
    {
        for(int j=0;j<=m;j++)
        {
            for(int k=0;k<=j;k++)
            {
                f[i][j]=max(f[i][j],f[i+1][j-k]+w[i][k]);
            }
        }
    }
    cout<<f[1][m]<<endl;
    int j=m;
    for(int i=1;i<=n;i++)
    {
        for(int k=0;k<=j;k++)
        {
            if(f[i][j]==f[i+1][j-k]+w[i][k])
            {
                cnt[i]=k;
                j-=k;
                break;
            }
        }
    }
    for(int i=1;i<=n;i++) cout<<i<<" "<<cnt[i]<<endl;
    return 0;
    
}

 

 

混合背包问题 

混合背包问题 

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

物品一共有三类：

• 第一类物品只能用1次（01背包）；
• 第二类物品可以用无限次（完全背包）；
• 第三类物品最多只能用 sisi 次（多重背包）；

每种体积是 vi，价值是 wi。

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

输入格式

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

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

• si=−1 表示第 i 种物品只能用1次；
• si=0 表示第 ii 种物品可以用无限次；
• si>0 表示第 ii 种物品可以使用 si 次；

输出格式

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

数据范围

0<N,V≤10000<N,V≤1000
0<vi,wi≤10000<vi,wi≤1000
−1≤si≤1000−1≤si≤1000

输入样例

4 5
1 2 -1
2 4 1
3 4 0
4 5 2

输出样例：

8

把01背包和完全背包弄成多重背包 二进制优化

#include<iostream>
using namespace std;
const int N=2e6+10;
int v[N],w[N],f[N];
int cnt;
int main()
{
    int n,m;cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        int a,b,s;cin>>a>>b>>s;
        if(s==-1) s=1;//如果是01背包 s=1;
        if(s==0) s=m/a;//如果是完全背包 s最多是 m/a;
        int k=1;
        //都转化为多重背包写 二进制优化
        while(k<=s)
        {
            cnt++;
            v[cnt]=a*k;
            w[cnt]=b*k;
            s-=k;
            k*=2;
        }
        if(s>0)
        {
            cnt++;
            v[cnt]=a*s;
            w[cnt]=b*s;
        }
    }
    n=cnt;
    //01背包
    for(int i=1;i<=cnt;i++)
    {
        for(int j=m;j>=v[i];j--)
        {
            f[j]=max(f[j],f[j-v[i]]+w[i]);
        }
    }
    cout<<f[m]<<endl;
    return 0;
}

每个物品都是单独的 遇到什么背包就用什么状态 

#include<iostream>
using namespace std;
const int N=2e6+10;
int f[N];
int main()
{
    int n,m;cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        int v,w,s;cin>>v>>w>>s;
        if(!s)
        {
            for(int j=v;j<=m;j++) f[j]=max(f[j],f[j-v]+w);
        }
        else
        {
            if(s==-1) s=1;
            for(int k=1;k<=s;k*=2)
            {
                for(int j=m;j>=v*k;j--) f[j]=max(f[j],f[j-v*k]+w*k);
                s-=k;
            }
            if(s)
            {
                for(int j=m;j>=s*v;j--) f[j]=max(f[j],f[j-v*s]+w*s);
            }
        }
    }
    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

输入样例

4 5 6
1 2 3
2 4 4
3 4 5
4 5 6

输出样例：

8

#include<iostream>
using namespace std;
const int N=1010;
int f[N][N];//f[i][j]表示 i表示体积 j表示重量 体积不超过i重量不超过j的最大价值
int v[N],m[N],w[N];
int main()
{
    int n,V,M;cin>>n>>V>>M;
    for(int i=1;i<=n;i++) cin>>v[i]>>m[i]>>w[i];
    for(int i=1;i<=n;i++)
    {
        for(int j=V;j>=v[i];j--)
        {
            for(int k=M;k>=m[i];k--)
            {
                f[j][k]=max(f[j][k],f[j-v[i]][k-m[i]]+w[i]);
            }
        }
    }
    cout<<f[V][M]<<endl;
    return 0;
}

#include<iostream>
using namespace std;
const int N=1010;
int f[N][N];//f[i][j]表示 i表示体积 j表示重量 体积不超过i重量不超过j的最大价值
int main()
{
    int n,V,M;cin>>n>>V>>M;
    for(int i=1;i<=n;i++)
    {
        int v,m,w;cin>>v>>m>>w;
        for(int j=V;j>=v;j--)
        {
            for(int k=M;k>=m;k--)
            {
                f[j][k]=max(f[j][k],f[j-v][k-m]+w);
            }
        }
    }
    cout<<f[V][M]<<endl;
    return 0;
}

潜水员

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

他有一个带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<cstring>
using namespace std;
const int N=1010;
int f[N][N];//f[i][j] 氧气为至少i 氮气为至少j的最小重量
int a[N],b[N],c[N];
int main()
{
    int n,m;cin>>n>>m;
    int K;cin>>K;
    for(int i=1;i<=K;i++) cin>>a[i]>>b[i]>>c[i];
    memset(f,0x3f,sizeof f);
    f[0][0]=0;
    for(int i=1;i<=K;i++)
    {
         for (int j = n; j >= 0; -- j)
        {
            for (int k = m; k >=0; -- k)
            {
                f[j][k] = min(f[j][k], f[max(j - a[i],0)][max(k - b[i],0) ] + c[i]);
            }
        }
    }
    cout<<f[n][m]<<endl;
    return 0;
}

背包问题求方案数

背包问题求方案数

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

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

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

输出 最优选法的方案数。注意答案可能很大，请输出答案模 10^9+7 的结果。

输入格式

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

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

输出格式

输出一个整数，表示 方案数 模 10^9+7 的结果。

数据范围

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

输入样例

4 5
1 2
2 4
3 4
4 6

输出样例：

2

 

 

#include<iostream>
#include<cstring>
using namespace std;
const int N=1010,mod=1e9+7;
int f[N][N];//f[i][j] 表示从前i个物品中选 总体积不超过j的最大价值
int g[N][N];//g[i][j] 考虑前 i 个物品，当前已使用体积恰好是 j 的，且 价值 为最大的方案
int v[N],w[N];
int main()
{
    int n,m;cin>>n>>m;
    for(int i=1;i<=n;i++) cin>>v[i]>>w[i];
    
    f[0][0]=0;
    for(int i=1;i<=n;i++)
    {
        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]);
        }
    }
    g[0][0]=1;
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=m;j++)
        {
           
            if(f[i][j]==f[i-1][j]) g[i][j]=(g[i][j]+g[i-1][j])%mod;
            if(f[i][j]==f[i-1][j-v[i]]+w[i]&&j>=v[i]) g[i][j]=(g[i][j]+g[i-1][j-v[i]])%mod;
        }
    }
    int res=0;
    for(int j=0;j<=m;j++)
    {
        if(f[n][j]==f[n][m]) res=(res+g[n][j])%mod;
    }
    cout<<res<<endl;
    return 0;
}

 f[i][j]表示从前i个物品中选择，体积就是j的价值，g[i][j]表示表示从前i个物品种选择
体积就是j的最大价值对应方案数

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

using namespace std;

const int N=1010,mod=1e9+7;

int f[N],g[N];

int main()
{
    int n,m;
    cin>>n>>m;
    memset(f,-0x3f,sizeof f);
    f[0]=0,g[0]=1;//显然选体积为0价值为0，而什么都不选的选法为1
    int mt=0;//用于保存最大值
    for(int i=1;i<=n;i++)
    {
        int v,w;
        cin>>v>>w;
        for(int j=m;j>=v;j--)
        {
            int maxv=max(f[j],f[j-v]+w);
            int s=0;//s这个临时变量存储的是能递推过来的最大价值的方案数
            if(maxv==f[j]) s+=g[j];//当maxv==f[j]时，说明最大价值可由上一层递推过来
            //那么s就需要加上上一层的方案数
            if(maxv==f[j-v]+w)  s=(s+g[j-v])%mod;//当maxv==f[j-v]+w时，说明最大价值可由本层递推过来
            //那么s就需要加上本层的方案数
            f[j]=maxv,g[j]=s;//最终体积为j的对应的最大价值的方案数便为s
            mt=max(mt,maxv);
        }
    }

    int res=0;
    for(int i=1;i<=m;i++)//mt就是最大价值
        if(f[i]==mt)  res=(res+g[i])%mod;
    cout<< max(res, 1) <<endl;
    return 0;
}

 

 

背包问题求具体方案

背包问题求具体方案

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

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

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

输出 字典序最小的方案。这里的字典序是指：所选物品的编号所构成的序列。物品的编号范围是 1…N。

输入格式

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

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

输出格式

输出一行，包含若干个用空格隔开的整数，表示最优解中所选物品的编号序列，且该编号序列的字典序最小。

物品编号范围是 1…N。

数据范围

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

输入样例

4 5
1 2
2 4
3 4
4 6

输出样例：

1 4

从后往前 和从前往后 求出来的 最大价值 是一样的

从后往前求是为了能够从 1~n 推出字典序最小的我路径 

#include<iostream>
using namespace std;
const int N=1010;
int f[N][N];
int v[N],w[N];
int main()
{
    int n,V;cin>>n>>V;
    for(int i=1;i<=n;i++) cin>>v[i]>>w[i];
    for(int i=n;i>=1;i--)
    {
        for(int j=0;j<=V;j++)
        {
            f[i][j]=f[i+1][j];//第i个物品不选
            if(j>=v[i]) f[i][j]=max(f[i][j],f[i+1][j-v[i]]+w[i]);
        }
    }
   // f[1][m]最大价值
    int j=V;
    for(int i=1;i<=n;i++)
    {
       //若当前有选该值则记录
        if(j>=v[i]&&f[i][j]==f[i+1][j-v[i]]+w[i])
        {
            cout<<i<<" ";
            j-=v[i];
        }
    }
    
    return 0;
}