分组背包

题目

【问题描述】

　　有n个物品，编号为1..n，编号为i的物品的体积为v[i]，价值为p[i]。

　　有m个同样的背包，编号为1..m，他们的最大容积都为C。

　　现在需要选择一些物品装入这些背包，要求编号大的背包装入的物品不能比编号小的背包装入物品的编号小，具体地说，不允许把编号为2的物品装入背包1，然后把编号为1物品装入背包2的情况出现，也就是说，物品时按编号由小到大的顺序装入背包的，并且只有在背包1不能再装物品时，才开始装背包2！

　　请你计算m个背包能装入物品的最大价值！

【输入格式】  

　　第一行包含三个整数：n,m,C，表示物品数量、背包的数量和背包的容量。
　　接下来的n行，每行有两个正数v[i],p[i]，第i+1行表示编号为i的物品的体积和价值。

【输出格式】  

一个整数，表示m个背包装入物品的最大价值。

【输入样例】  

4 2 6
5 4
2 3
4 6
1 2

【输出样例】  

13

【数据范围】  

0 < n<=20 ,0< v[i],p[i]<=200 1<=m<=20 , 0< C<=200

分析

这种带限制的背包理论上来说就是dp，这种限制不dp就白学了
背包问题的经典dp是子集问题，同样的我们是可以用背包问题的子集dp来做的，因为题目加粗部分使我们的方程变得很好写，这里的最优子问题是显然的，具体见代码
时间复杂爱O(n*m*c)

代码

/*
f(i,j,k)表示前i个背包装前j个物品，第j个背包最多装k体积物品的最大价值
f(0,0,0)=0;
f(i,j,k)=max{下面这一坨}
//不装f(i,j-1,k)
//装
    //新背包
    f(i-1,j-1,c)+p[i]
    //旧背包
    f(i,j-1,k-v[i])+p[i] 
*/
#include<queue>
#include<cmath>
#include<cstdio>
#include<vector>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=25,maxc=205;
int n,m,c;
int v[maxn],p[maxn],d[maxn][maxn][maxc];
void Init()
{
    scanf("%d%d%d",&n,&m,&c);
    for(int i=1;i<=n;i++)
    {
        scanf("%d%d",&v[i],&p[i]);
    }
}
void dp()
{
    for(int i=1;i<=m;i++)
    {
        for(int j=1;j<=n;j++)
        {
            for(int k=0;k<=c;k++)
            {
                int t=d[i][j-1][k];
                if(k>=v[j])
                {
                    t=max(t,d[i-1][j-1][c]+p[j]);
                    t=max(t,d[i][j-1][k-v[j]]+p[j]);
                }
                d[i][j][k]=t;
            }
        }
    }
    cout<<d[m][n][c]<<endl;
}
int main()
{
    //freopen("in.txt","r",stdin);
    Init();
    dp();
    return 0;
}

关于代码
这道题其实我想说的主要是方程的问题
这里方程的定义是没问题，从理论上来说也是讲得通的，关键就在于方程的转移，而这个转移的关键恰恰是不装物品的情况，这里为什么是f(i,j-1,k)呢，想其实是很好想的，就是不用第j个背包的情况下的值，不过我之前写成了f(i-1,j,k)这是个什么鬼东西，不过没关系，加上去也无妨

还有一点就是这里的三个维度似乎没有任何从属关系，因此可以按照任意顺序打表，只要不按照k，我们还能进行滚动数组

第二个思路

这是个很经典的序列型dp，因为就是为了将物品分组嘛，装进不同的背包里，刚好就是放隔板，因为顺序是固定的，要加一个预处理
O（n*n*n*c（预处理，常数很小，比1/6还小）+n*n*m），所亿在这种情况下说不定这个思路的效率更高，因为常熟小，我就懒得写代码了
写个方程
g[i][j]表示i元素到j元素放在一个背包里面的最优值，用01背包预处理
f(i,j)表示前i个背包里面装前j个物品的最优值
f(i,j)=max{f(i-1,k)+g[k][j]}
ans=f(m,n)
当然可以不放东西，因此我们把f(i-1,j)的值一起赋下来吧，就不用搜索答案了,这种思路还可以应用在其他地方，不过有些不好转移的地方，比如要求刚刚好字眼，那么就不能这样做，比如DAG上的dp或者单调子序列，只能在一个比较好的情况去包含一个比较坏的情况，并不要过于偷这种懒，分析出来没问题才能用

注意分组dp一定是一个元素作为一组，后一个元素到现在的元素作为新的元素

补个代码

/*
预处理
f(i,j)表示前i个元素方才j体积之内的最大价值
f(0,0)=0;
f(i,j)=max(f(i-1,j),f(i-1,j-v[i])+p[i]) 
ans=f(i,j)

计算
f(i,j)表示最多用i个背包装j个物品的最大值
f(0,0)=0
f(i,j)=max{f(i,k)+g[i][k]||1<=k<=j}
ans=f(m,n); 
*/
#include<queue>
#include<cmath>
#include<cstdio>
#include<vector>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=25,maxc=205;
int n,m,c;
int v[maxn],p[maxn],d[maxn][maxn];
int g[maxn][maxn],f[maxn][maxc];
int calc(int a,int b)
{
    for(int i=1;i<=c;i++)
        f[a-1][i]=0;
    for(int i=a;i<=b;i++)
    {
        for(int j=0;j<=c;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]]+p[i]);
        }
    }
    return f[b][c];
}
void Init()
{
    scanf("%d%d%d",&n,&m,&c);
    for(int i=1;i<=n;i++)
    {
        scanf("%d%d",&v[i],&p[i]);
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=i;j<=n;j++)
        {
            g[i][j]=calc(i,j);
        }
    }
}
void dp()
{
    for(int i=1;i<=m;i++)
    {
        for(int j=1;j<=n;j++)
        {
            d[i][j]=d[i-1][j];
            for(int k=1;k<=j;k++)
            {
                d[i][j]=max(d[i][j],d[i-1][k-1]+g[k][j]);
            }
        }
    }
    cout<<d[m][n]<<endl;
}
int main()
{
    //freopen("in.txt","r",stdin);
    Init();
    dp();
    return 0;
}

再谈谈之前那个要不要精确的问题，DAG不行，而这里的背包可以，因为DAG每个节点的性质不同，前面节点的答案不是这个节点的最优值，而背包就不同了，每个背包是一样的i个背包一定包含了i-1个背包，所以可以延续之前背包的值