HDU 3535：AreYouBusy（分组背包）

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3535

题目翻译：给出N，T，代表有N组任务，给T时间长去做。

给出M,S，M代表该组中任务的个数，S代表该组任务的类型。

给出该组中M个任务所需要耗费的时间和所能收获的快乐值。

S = 0 .该组的任务至少选择一个做；

S = 1. 该组的任务至多选择一个做；

S  = 2.该组的任务选多少个做都行。

求做完N组任务后，能够获得的最大快乐值。如果答案不存在，输出-1.

有可能对于任意一个时间，时间都不够，则当前时不会有答案的。

解题思路：

设dp数组，dp[i][j]代表做前i组任务，给予时间j时所能获得的最大快乐值。

1.由于S = 0时，每组必须选择任务，因此当第i组任务，先将其对应的dp赋值为负无穷。

dp[i][j]，可以由dp[i-1][j]转移而来，dp[i-1][j]  其内值可能得到更新，如果我们在此

基础上装，dp[i-1][j-c] + g,可能时有值的，则dp[i][j]若想有值，则肯定时装入该组的第

一个物品时转移而来的，在装入第一件物品后，我们就可以在该组继续装其他物品。

装其余物品的时候，我们用dp[i][j]进行转移。则该情况动态转移方程是。

  dp[i][k] = max(dp[i][k],max(dp[i][k-c[j]]+g[j],dp[i-1][k-c[j]]+g[j]));

2.由于S  = 1时，每组要么选一个，要没一个不选。

则处理第i的时候，我们先把前i-1组处理的值赋给第i组，这样dp[i][j]代表的含义其实就是

没有在第i组选任务的最大快乐值。

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

其状态转移方程如上所示。

这个题目想了好久，看别人的代码，想为什么这样转移就是该组要么选了一个，要么没有选。

它怎么控制只选则组内的一个。

主要还是看状态转移方程。

dp[i][k]里面的值其实时dp[i-1][k]，其值代表该组没有选。

dp[i-1][k] 里面是处理过第k-1组的，则dp[i-1][k-c]+g 代表选了，每次必须从上一组的状态转移。

当S = 2的时候，代表随便选

 dp[i][k] = max(dp[i][k],dp[i][k-c[j]]+g[j]);

dp[i][k]  的值是 dp[i-1][k]的值，依然代表不选

dp[i][k-c] + g   代表选，而且可以选择多个，则在改组的状态上进行转移。

AC代码：

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <string.h>

using namespace std;

const int inf = 0x3f3f3f3f;
int dp[110][110];    ///dp[i][j]代表前i组，时间为j时的最大欢乐度
int c[110],g[110];   ///c[i]消费，g[i]价值
int main() {
    int n,T;   ///n组工作，T时间
    while(~scanf("%d%d",&n,&T)) {
         memset(dp,0,sizeof(dp));
        for(int i = 1; i <= n; i++) {
            int m,s;
            scanf("%d%d",&m,&s);   ///该组内有m个工作。
            for(int j = 1; j <= m; j++) {
                scanf("%d%d",&c[j],&g[j]);  ///输入m种工作的消耗和收益
            }
            ///至少选择一个
            if(s == 0){
                ///将其初始化为负无穷。
                for(int j = 0; j <= T; j++) {
                    dp[i][j] = -inf;
                }
                for(int j = 1; j <= m; j++) {
                    for(int k = T; k >= c[j]; k--) {
                        dp[i][k] = max(dp[i][k],max(dp[i][k-c[j]]+g[j],dp[i-1][k-c[j]]+g[j]));
                    }
                }
            } else if(s == 1) {  ///至多选择一个
                for(int j = 0; j <= T; j++) {
                    dp[i][j] = dp[i-1][j];
                }
                for(int j = 1; j <= m; j++) {
                    for(int k = T; k >= c[j]; k--) {
                        dp[i][k] = max(dp[i][k],dp[i-1][k-c[j]]+g[j]);
                    }
                }
            } else {    ///选多少个都行
                for(int j = 0; j <= T; j++) {
                    dp[i][j] = dp[i-1][j];
                }
                for(int j = 1; j <= m; j++) {
                    for(int k = T; k >= c[j]; k--) {
                        dp[i][k] = max(dp[i][k],dp[i][k-c[j]]+g[j]);
                    }
                }
            }
        }
        dp[n][T] = max(dp[n][T],-1);
        printf("%d\n",dp[n][T]);
    }
    return 0;
}