Cookie Choice+ZOJ+01背包之终级背包

Cookie Choice

---

Time Limit: 2 Seconds       Memory Limit: 32768 KB

---

MM enjoyed cookies very much. On Saint Valentine's Day, when she stepped into a big cookie store again, she wouldn't leave unless DD spent all his money in pocket!

There are N kinds of cookies, labeled from 1 to N, and all can be bought without any restriction by the store. But actually, for some kinds of cookies, MM wanted to buy one piece at most, and for some kinds of cookies, MM wanted to buy K_i pieces at most, and for some other kinds of cookies, there didn't exist an upper bound that MM wanted to buy.

There is another requirement from MM: there are some groups of cookies, MM considered their tastes similar, so she wanted to buy at most one kind of cookies in each group. A kind of cookie wouldn't appear in more than one group.

For the ith kind of cookies, MM has an "enjoyable value" E_i, if DD bought A_i pieces of this kind for her, and A_i didn't exceed her upper bound, MM get E_iA_i of enjoyable value. After buying cookies, MM's total enjoyable value will be the sum of E_iA_i.

But actually, poor DD had only D dollars, and the price for the ith kind of cookies is P_i dollars per piece. DD must spend all his D dollars to buy cookies, to meet requirements about amount and taste from MM, and to make MM's enjoyable value as high as possible. What's more, as you know, a legal plan's enjoyable value must be non-negative.

Input

There are multiple test cases. Each test case consists of three parts.

The first part is one line with two integers N and D.

The second part has N lines, line i consists of three integers K_i, E_i and P_i. If K_i equals to 0, it means for ith kind of cookies, there didn't exist an upper bound that MM wanted to buy, otherwise K_i is the upper bound for ith kind of cookies.

The third part describes the groups. A non-negative integer G represents the number of groups, and then G lines, each line consists of some integers represents labels of kinds of cookies in this group.

One blank line between test cases.

Output

If the proper and optimal plan exists, output the maximal total enjoyable value ΣE_iA_i, otherwise output "i'm sorry...".

Output one line per text case.

Data Restriction

1 <=  N  <= 1024, 0 <=  D  <= 1024.

0 <=  K_i  <= 1024, -1024 <=  E_i  <= 1024, 0 <  P_i  <=  D .

0 <=  G  <= 8.

All numbers referred are integers.

Number of test cases is no more than 80.

Sample Input

2 1024
0 1 3
0 0 1
0

10 1023
1 1 1
1 1 2
1 1 4
1 1 8
1 1 16
1 1 32
1 1 64
1 1 128
3 -1 256
1 1 512
1
9 10

10 1023
1 1 1
1 1 2
1 1 4
1 1 8
1 1 16
1 1 32
1 1 64
1 1 128
1 1 256
1 1 512
1
9 10

Sample Output

341
5
i'm sorry...

解决方案：求解是可分两部分，一个是分了组的，一个是没分组，没分组的之间按混合型背包问题来解，分好组的先在组内解出最优解集，然后把这两类的结果合并求出总的最优解。

code:
<pre name="code" class="cpp">#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#define MMAX 2048
#define inf -0x3f3f3f3f
using namespace std;
int n,d,g;
struct node
{
    int k,e,p;
} candy[MMAX*10];
int belong[MMAX*10];
int dp[20408],temp[20408],w[10][20408];
void Clear(int len,int f[])
{
    for(int i=0; i<=len; i++)
    {
        f[i]=inf;
    }
    f[0]=0;
}
void zeroone(int f[],int i,int k)
{
    for(int v=d; v>=candy[i].p*k; v--)
        f[v]=max(f[v],f[v-candy[i].p*k]+candy[i].e*k);
}///01背包问题的求解
void complete(int f[],int i)
{
    for(int v=candy[i].p; v<=d; v++)
    {
        f[v]=max(f[v],f[v-candy[i].p]+candy[i].e);
    }
}///完全背包问题的求解
int main()
{
    while(~scanf("%d%d",&n,&d))
    {

        for(int i=1; i<=n; i++)
        {
            scanf("%d%d%d",&candy[i].k,&candy[i].e,&candy[i].p);
        }
        memset(belong,-1,sizeof(belong));
        scanf("%d",&g);
        getchar();
        for(int i=0; i<g; i++)
        {
            int a;
            char s;
            while(1)
            {
                scanf("%d%c",&a,&s);
                belong[a]=i;
                if(s=='\n') break;
            }

        }
        Clear(d+1,dp);
        Clear(d+1,temp);
        for(int i=0; i<g; i++)
            Clear(d+1,w[i]);
        for(int i=1; i<=n; i++)
        {
            if(belong[i]!=-1) Clear(d+1,temp);
            if(candy[i].k==0||candy[i].k*candy[i].p>=d)
            {
                complete(belong[i]!=-1?temp:dp,i);
            }
            else
            {
                int k=1;
                int cnt=candy[i].k;
                while(1)
                {
                    cnt-=k;
                    if(cnt<0)
                    {
                        cnt+=k;
                        break;
                    }
                    zeroone(belong[i]!=-1?temp:dp,i,k);
                    k*=2;
                }
                zeroone(belong[i]!=-1?temp:dp,i,cnt);
            }
            if(belong[i]!=-1)
                for(int j=0; j<=d; j++)
                w[belong[i]][j]=max(w[belong[i]][j],temp[j]);///由于组内成员为互斥的，所以必须只能选一类
        }
        for(int i=0; i<g; i++)
        {
            for(int j=d; j>=0; j--)
            {
                for(int s=0; s<=j; s++)
                {
                    dp[j]=max(dp[j],dp[j-s]+w[i][s]);
                }
            }
        }///将w的结果合并到dp
        if(dp[d]<0)
        {
            printf("i'm sorry...\n");
        }
        else
            printf("%d\n",dp[d]);
    }
    return 0;
}