【算法详解】背包模板或模型详解

01背包

有N 件物品和一个容量为V 的背包。放入第i 件物品耗费的空间 是vi，得到的价值是wi。求解将哪些物品装入背包可使价值总和最大。

根据题意，我们便可以设f[i][j]为已经装了i件物品且最大容量为j得最大价值.
此时，我们就可以枚举i和j进行动态规划的状态转移得到结论.
那么f[i][j]的最大价值是怎么转移的呢？
当第i件物品不选的时候，相当于前i件物品相同的体积j的最大价值
若不选，最大价值则是前i件物品体积为j-这个物品体积的最大价值加上最个物品价值
因此，我们可以得到01背包的状态转移方程：

$$f[i][j]=max(f[i-1][j],f[i-1][j-vi]+wi)$$
但是，我们仍然可以在空间上选择优化：
$$f[j]=max(f[j],f[j-vi]+wi)$$
每一层i的状态只和i-1有关，因此我们可以用1维的数组表示.但是当前面的j转移之后枚举到后面的j是显然需要用先前j来枚举，无法满足动态规划的无后效性，因此我们再枚举j的时候需要倒叙枚举.
代码如下：

#include<bits/stdc++.h>
using namespace std;
int n,V;
int v[100000];
int w[100000];
int f[1000000];
int main()
{
    ios::sync_with_stdio; 
    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=V;j>=v[i];j--)
            f[j]=max(f[j],f[j-v[i]]+w[i]);
    cout<<f[V];
    return 0;
} 

---

完全背包

有N 件物品和一个容量为V 的背包，每件物品都有无限件。放入 第i 件物品耗费的空间是vi，得到的价值是wi。求解将哪些物品装入背 包可使价值总和最大

根据01背包的求解思路，则有：

$$f[i][j]=max(f[i-1][j],f[i][j-vi]+wi)$$
就可以表示为不选和选过后可以再选，因此第二个方程是i而没有-1
联系一下01背包，01背包为什么要倒叙枚举，而不是正序枚举，是因为正序枚举是f[j-v[i]]这一步已经是被覆盖的了，即有可能已经取过第i件物品，矛盾了01背包的特性，因此要倒序；但是却符合完全背包，所以i将01背包倒过来即可
代码如下：

#include<bits/stdc++.h>
using namespace std;
int n,V;
int v[100000];
int w[100000];
int f[1000000];
int main()
{
    ios::sync_with_stdio(false); 
    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=v[i];j<=V;j++)
            f[j]=max(f[j],f[j-v[i]]+w[i]);
    cout<<f[V];
    return 0;
} 

---

多重背包

有N 件物品和一个容量为V 的背包，第i 件物品都有ni 件。放入 第i 件物品耗费的空间是ci，得到的价值是wi。求解将哪些物品装入背 包可使价值总和最大

显然，我们可以选择最暴力的做法，把每种情况列一遍，但是会TLE.因此需要二进制优化：
以13为例：13用2的平方数之和为：1+2+4还差6，所以13=1+2+4+6
不难发现，这4个数字都可以组成1-13的任何一个数：
1，2，1+2，4，1+4，2+4，1+2+4，2+6，1+2+6，4+6，1+4+6，2+4+6，1+2+4+6
其实，这种方法并不只是适用于13这个数，任何数都是如此.
所以，我们就把一件物品按数量拆分成这些二进制数和0或1个其它数字的和，然后再做01背包，这样就可以保证枚举到每一种的情况且时间复杂度要减少很多
代码如下：

#include<bits/stdc++.h>
using namespace std;
int n,V,tot=0;
int w[100000];
int v[100000];
int f[1000000];
int main()
{
    ios::sync_with_stdio; 
    cin>>n>>V;
    for (int i=1;i<=n;i++)
    {
        int stv,stw,num,temp=0;
        cin>>stv>>stw>>num;
        while (num-(1<<temp)>=0)
        {
            w[++tot]=stw*(1<<temp);
            v[tot]=stv*(1<<temp);
            num-=1<<temp;
            temp++;
        }
        if (num) w[++tot]=stw*num,v[tot]=stv*num;
    }
    for (int i=1;i<=tot;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;
} 

---

三种背包（01，完全，多重背包）混合

#include<bits/stdc++.h>
using namespace std;
int n,V;
int f[100000];
其余变量...... 
void Zeroonebag(int v,int w)
{
    做01背包 
}
void Allbag(int v,int w)
{
    做完全背包 
}
void Manybag(int v,int w,int n)
{
    做多重背包 
} 
int main()
{
    ios::sync_with_stdio(false); 
    int n,V;
    cin>>n>>V;
    for (int i=1;i<=n;i++)
    {
        int stv,stw;
        cin>>stv>>stw>>num
        if (num==1) Zeroonebag(stv,stw);
        if (num*stv>V) Allbag(stv,stw);
        if (num>1&&num*stv<=V) Manybag(stv,stw,num); 
    }
    cout<<f[V];
    return 0;
} 

---

二维费用背包

有N 件物品，放入第i 件物品耗费的两种空间代价是ci 和di，得到 的价值是wi。两种代价可付出的最大值（两种背包容量）分别为V 和U。求解将哪些物品装入背包可使价值总和最大

事实上，这就是01背包，只不过多了一种空间和状态，我们只需要再原来的状态上面多一维并在程序的实现上面多一种循环去枚举即可.
设f[i][j]表示第一种空间用了i，第二种空间用了j的最大价值，那么我们很容易地得到：

$$f[i][j]=max(f[i-ci][j-di]+wi,f[i][j])$$
代码如下:

#include<bits/stdc++.h>
using namespace std;
int n;
int V,U;
int c[100000];
int d[100000];
int w[100000];
int f[5000][5000];
int main()
{
    ios::sync_with_stdio;
    cin>>n>>V>>U;
    for (int i=1;i<=n;i++)
        cin>>c[i]>>d[i]>>w[i];
    for (int i=1;i<=n;i++)
        for (int j=V;j>=c[i];j--)
            for (int k=U;k>=d[i];k--)
                f[j][k]=max(f[j][k],f[j-c[i]][k-d[i]]+w[i]);
    cout<<f[V][U];
    return 0;
}

---

分组背包

有N 件物品和一个容量为V 的背包。第i 件物品的空间代价是ci， 价值是wi。这些物品被划分为K 组，每组中的物品互相冲突，最多选一 件。求解将哪些物品装入背包可使价值总和最大。

这种背包的问题同样十分简单，只要再状态的设置上略加改动即可.
设f [i][j] 表示前i 组物品恰放入容量j的背包可以获得的最大价值。
我们便可以得到状态转移方程：

$$f [i][j] = max(f [i −1][j],f [i −1][j −ci] + wi) (i属于第k组)$$
对于其状态转移的过程，可以参考下面老师PPT的代码：

for(int i=1;i<=K;i++) 
    for(int j=V;j>=0;j−−) 
        for( item i in groupKl) 
            f [j] = max(f [j],f [j −ci] + wi);

我们可以思考思考一下：难道不会出现每件物品都重复的问题吗？
事实上是不会的，根据循环顺序，每件物品都有一个固定的j且j为倒叙枚举，即向前枚举的时候没有任意一个同组的物品存在前面状态中，故不会重复.
但是我们需要注意：这个循环的顺序是不能打乱的，必然就会产生重复的现象.
代码如下：

#include<bits/stdc++.h>
using namespace std;
int K,V;
int tot[10000];
int f[1000000];
int v[2000][2000];
int w[2000][2000];
int main()
{
    ios::sync_with_stdio;
    cin>>K>>V;
    for (int i=1;i<=K;i++)
    {
        cin>>tot[i];
        for (int j=1;j<=tot[i];j++)
            cin>>v[i][j]>>w[i][j];
    }
    for (int i=1;i<=K;i++)
        for (int j=V;j>=0;j--)
            for (int k=1;k<=tot[i];k++)
                if (j-v[i][k]>=0)
                    f[j]=max(f[j],f[j-v[i][k]]+w[i][k]);
    cout<<f[V];
    return 0;
}