HDU 4778 Gems Fight!【博弈+DP】

这个题真的想得超级久都没有思路，想明白了又因为位运算少加个括号调试了将近一个小时，大家都秒出的题我又基本是最后几个交的。今天各种智商不在线。伤心难过受打击。。

---

题意：

有$B(0\le B \le 21)$个背包，有$G(0 \le G \le 8)$种颜色的宝石，这两个人轮流选择某一个背包，把这个背包包里的宝石放到一个共享的地方里，当这里某一种颜色的宝石等于$S$，那么就可以产生一个魔法石，这个人得到这个魔法石并且还能得到一个额外的拿包的机会，两个人都用最佳策略，问最后两个人能获得的魔法石的差。

分析：

还是分析透彻题目的性质！
1. 首先可以明确，背包最多只有$21$个， 所以我们可以用状态压缩来表示拿背包的情况。
2. 对于不同局势，先手后手均采取最优策略，所以二者均采取同样的方式拿包。
3. 另外一个重要性质就是两个人拿到魔法石的总数总是确定的！

那么我们就可以得出：
设$dp[i] :=面对背包状态为i时可以获得的最大的魔法宝石数$
状态转移方程：
如果拿某个包产生了新的魔法石，则当前的人可以继续下一轮，即dp[i] = max (dp[i], dp[i|(1<<j)] + ccnt);
否则，换手，那么$dp[i|(1<<j)]$就是下一手的了，根据总和我们就可以求出当前手对应的值
dp[i] = max (dp[i], res - dp[i|(1<<j)]);
当所有背包都被取即$i == 1 << n - 1$时，此时获得的最大魔法石数为$0$，所以我们倒着推一遍，先手获得的最大值即为$dp[0]$。

代码：

#include<cstdio>
#include<iostream>
#include<cmath>
#include<queue>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn = 22, oo = 0x3f3f3f3f;
int dp[1<<maxn], cnt[maxn][10],num[maxn];
int main ()
{
    int G, B, S;
    while (scanf ("%d %d %d", &G, &B, &S) && (G + B + S)){
        int m, x;
        memset (cnt, 0, sizeof(cnt));
        for (int i = 0; i < B; i++){
            scanf ("%d", &m);
            for (int j = 0; j < m; j++){
                scanf ("%d", &x);
                cnt[i][x] ++;
            }
            for(int j = 1; j <= G; j++){
                num[j] += cnt[i][j];
            }
        }
        int sum = 0;
        for(int i = 1; i <= G; i++){
            sum += num[i] / S;
        }
        memset(dp, 0, sizeof(dp));
        int n = 1 << B;
        for(int i = n - 2; i >= 0; i--){
            memset(num, 0, sizeof(num));
            for(int j = 0; j < B; j++){
                if(i & (1 << j)){
                    for(int k = 1; k <=G; k++){
                        num[k] += cnt[j][k];
                    }
                }
            }
            int now = 0;
            for(int j = 1; j <= G; j++){
                now += num[j] / S;
                num[j] %= S;
            }
            int res = sum - now;
            for (int j = 0; j < B; j++){
                if ((i & (1<< j)) == 0){
                    int ccnt = 0;
                    for (int k = 1; k <= G; k++)
                        ccnt += (num[k] + cnt[j][k]) / S;
                    if (ccnt > 0)
                        dp[i] = max (dp[i],  dp[i|(1<<j)] + ccnt);
                    else
                        dp[i] = max (dp[i], res - dp[i|(1<<j)]);
                }
            }
        }
        printf ("%d\n", 2 * dp[0] - sum);
    }
    return 0;
}