hdu 3535 AreYouBusy（分组背包）（推荐）

hdu 3535 AreYouBusy

分析

感觉是一道好题目。
简单来说，题目就是先告诉你有n个组，以及总时间t，然后分别告诉你每个组有几个任务m以及这个组的类别s。每个任务有花费的时间c以及得到的快乐g。
对于类别s==1的任务，要求是至多选一个。也就是选一个或者不选。如果不选，即继承上一个组的结果，即

for(int k=0; k<=T; k++)
                    dp[i][k]=dp[i-1][k];

保证了不选的情况，而

for(int p=T; p>=c[j]; p--)
                    {
                        if(dp[i-1][p-c[j]]!=-1)
                            dp[i][p]=max(dp[i][p],dp[i-1][p-c[j]]+g[j]);
                    }

则是保证在原有有的基础上，选择一个进行更新。（-1表示没有结果，而成功选一个的前提是之前有结果或者说之前是成功的。）

对于s==0的任务，要求是至少选一个。也就是选一个或者是多个，选一个同s==1的情况，而选多个则是

 for(int p=T; p>=c[j]; p--)
                    {
                        if(dp[i][p-c[j]]!=-1)
                            dp[i][p]=max(dp[i][p],dp[i-1][p-c[j]]+g[j]);
                    }

也就是这一组内的累加更新，实现了选多个，而且，不用担心会出现不选，首先它不继承之前的，而且dp除了dp[0]都初始化为-1，不更新的话依旧是-1，也就不会不选但是有数值了。

对于s==2的任务，要求是随意的。结合s==1以及s==0的情况，首先继承上一组的，实现不选而后组内进行更新，实现选多个，这里因为继承了，所以第一次的组内更新相当于选一个的情况，而后就是选多个。

（而s==0的情况，因为没有继承，所以选一个以及选多个都要写一下。而且要注意顺序，如果先选一个，然后在选多个，可能会出现自己选自己的情况，要注意。）

感觉这题算是好好玩了一下分组背包，三种约束条件各有不同但也有共同之处，关键之处在于分析。总的来说，考虑的就是不选，选一个，选多个。对应，只继承，只更新上一层成功的，组内成功的更新。

感觉对自己来说算是涨了经验和见识，还有就是之前的理解有错误的话，欢迎指出。

问题

http://acm.hdu.edu.cn/showproblem.php?pid=3535

代码

#include <iostream>
#include <cstring>
#include <ctime>
#include <fstream>
#include <cstdlib>
#include <algorithm>
#include <set>
#include <vector>

using namespace std;

int n,T,m,s;
int dp[110][110];
int c[110],g[110];

int main()
{
    while(scanf("%d %d",&n,&T)!=EOF)
    {
        memset(dp,-1,sizeof(dp));
        memset(dp[0],0,sizeof(dp[0]));
        for(int i=1; i<=n; i++)
        {
            scanf("%d %d",&m,&s);
            for(int j=0; j<m; j++)
            {
                scanf("%d %d",&c[j],&g[j]);
            }
            if(s==0)
            {
                for(int j=0; j<m; j++)
                    for(int p=T; p>=c[j]; p--)
                    {

                        if(dp[i][p-c[j]]!=-1)
                            dp[i][p]=max(dp[i][p],dp[i][p-c[j]]+g[j]);
                        if(dp[i-1][p-c[j]]!=-1)
                            dp[i][p]=max(dp[i][p],dp[i-1][p-c[j]]+g[j]);
                    }

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

        }

        cout<<dp[n][T]<<endl;

    }
    return 0;
}