hdu 3535 分组背包

hdu 3535 分组背包 好题

*

该题要用分组背包做，这里就是要怎样处理0必须选，

1最多选一个，2任意选的问题；

这里我们就开个二维数组；dp[i][j]，i表示第组，

j表示时间；当该组为0时，我们在该组的选择可以来自上一组的结果

，也可以来自该组的结果；

如果为1那么结果只能依赖上一组的结果，

如果依赖本组那么就会造成该组会多选；

为2是那就是一个01背包；

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<memory.h>
using namespace std;
int dp[125][125],n,m;
struct node
{
    int sum;
    int Typ;
    int c[125];
    int g[125];
} p[125];
int main()
{
    //int i,j,t,k;
    while(scanf("%d%d",&n,&m)==2)
    {
        memset(dp,-1,sizeof(dp));
        memset(dp[0],0,sizeof(dp[0]));
        for(int i=1; i<=n; i++)
        {
            cin>>p[i].sum>>p[i].Typ;
            for(int j=1; j<=p[i].sum; j++)
            {
                cin>>p[i].c[j]>>p[i].g[j];
            }
        }
        for( int i = 1 ; i <= n ; i ++ )
        {
            if(p[i].Typ==0)
            {
                for( int j = 1 ; j<=p[i].sum; j++ )
                    for( int k = m ; k >= p[i].c[j] ; k-- )
                    {
                        if( dp[i][k-p[i].c[j]]!=-1 )
                            dp[i][k] = max(dp[i][k],dp[i][k-p[i].c[j]]+p[i].g[j]);
                        if( dp[i-1][k-p[i].c[j]]!=-1 )
                            dp[i][k] = max(dp[i][k],dp[i-1][k-p[i].c[j]]+p[i].g[j]);
                    }

            }
            if(p[i].Typ==1)
            {
                for(int j=0;j<=m;j++) dp[i][j] = max(dp[i-1][j],dp[i][j]);
                for( int j = 1 ; j <= p[i].sum; j++ )
                    for( int k = m ; k >= p[i].c[j]; k-- )
                    {
                        if(dp[i-1][k-p[i].c[j]] != -1 )
                            dp[i][k] = max(dp[i][k],dp[i-1][k-p[i].c[j]]+p[i].g[j]);
                    }

            }
            if(p[i].Typ==2)
            {
                for( int j = 0 ; j <= m ; j++)
                {
                    dp[i][j] = dp[i-1][j];
                }
                for( int j = 1 ; j <=p[i].sum; j++ )
                    for( int k = m ; k >= p[i].c[j] ; k-- )
                    {
                        if(dp[i-1][k-p[i].c[j]] != -1 )
                            dp[i][k] = max(dp[i][k],dp[i][k-p[i].c[j]]+p[i].g[j]);
                    }
            }
        }
        cout<<dp[n][m]<<endl;
    }
    return 0;
}