HDU 5816 Hearthstone （状压DP）

Hearthstone

题目链接：

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

Description

Hearthstone is an online collectible card game from Blizzard Entertainment. Strategies and luck are the most important factors in this game. When you suffer a desperate situation and your only hope depends on the top of the card deck, and you draw the only card to solve this dilemma. We call this "Shen Chou Gou" in Chinese.
Now you are asked to calculate the probability to become a "Shen Chou Gou" to kill your enemy in this turn. To simplify this problem, we assume that there are only two kinds of cards, and you don't need to consider the cost of the cards.
-A-Card: If the card deck contains less than two cards, draw all the cards from the card deck; otherwise, draw two cards from the top of the card deck.
-B-Card: Deal X damage to your enemy.
Note that different B-Cards may have different X values.
At the beginning, you have no cards in your hands. Your enemy has P Hit Points (HP). The card deck has N A-Cards and M B-Cards. The card deck has been shuffled randomly. At the beginning of your turn, you draw a card from the top of the card deck. You can use all the cards in your hands until you run out of it. Your task is to calculate the probability that you can win in this turn, i.e., can deal at least P damage to your enemy.

Input

The first line is the number of test cases T (T

Output

For each test case, output the probability as a reduced fraction (i.e., the greatest common divisor of the numerator and denominator is 1). If the answer is zero (one), you should output 0/1 (1/1) instead.

Sample Input

2
3 1 2
1 2
3 5 10
1 1 1 1 1 1 1 1 1 1

Sample Output

1/3
46/273

Source

2016 Multi-University Training Contest 7


##题意：

炉石游戏：此时对手有P点血，自己手上没牌，牌库中有n张奥术智慧(抽两张牌)和m张直伤牌(伤害不同)，问自己的回合神抽打死对面的概率是多少.


##题解：

由于总牌数不超过20，所以很容易想到可以压缩状态.
dp[s]：已摸到牌的集合是s且能打死对面的方案数.
对于每个状态S，可以算出此时还能摸 A-B+1 张牌.
如果此时抓到的伤害牌已经够打死对面，那么就不需要往后拓展(直接计算后面卡牌的全排列即可).
否则要枚举S中的空位置，并用dp[s]去更新新状态.
结果：
所有能打死对面的组合S： dp[s] * (剩余卡牌的全排列).

官方题解：
这题其实有O(2^M)的做法. 方法用f[i][j]表示A类牌和B类牌分别抽到i张和j张，且抽牌结束前保证i>=j的方案数，这个数组可以用O(n^2)的dp预处理得到. 接下来枚举B类牌的每个子集，如果这个子集之和不小于P，用k表示子集的1的个数，将方案总数加上取到这个集合刚好A类卡片比B类卡片少一（过程结束）的方案数：f[k-1][k] * C(n, k - 1) * (k - 1)! * k! * (n + m – 2*k + 1)! . 如果子集包含了所有的B类卡片，则还需要再加上另一类取牌结束的情况，也就是取完所有牌，此时应加上的方案数为f[n][m] * n! * m! . 最后的总方案数除以(n+m)!就是答案.


##代码：
``` cpp
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define LL long long
#define eps 1e-8
#define maxn 501000
#define mod 100000007
#define inf 0x3f3f3f3f
#define mid(a,b) ((a+b)>>1)
#define IN freopen("in.txt","r",stdin);
using namespace std;

LL gcd(LL a,LL b) {

return b==0? a:gcd(b,a%b);

}

LL dp[1<<21];

int dam[21];

LL fac[21];

int main(int argc, char const *argv[])

{

//IN;

fac[0] = 1;
for(int i=1; i<21; i++)
    fac[i] = fac[i-1] * i;

int t; cin >> t;
int p, a,b;
while(scanf("%d %d %d", &p,&a,&b) != EOF)
{
    int n = a + b;
    memset(dp, 0, sizeof(dp));

    for(int i=1; i<=b; i++)
        scanf("%d", &dam[i]);

    dp[0] = 1;
    for(int s=0; s<(1<<n); s++) {
        if(!dp[s]) continue;

        int A = 0, B = 0, tol_dam = 0;
        for(int i=0; i<b; i++) {
            if(s & (1<<i)) {
                B++; tol_dam += dam[i+1];
            }
        }
        if(tol_dam >= p) continue;
        for(int i=b; i<n; i++) {
            if(s & (1<<i)) {
                A++;
            }
        }

        if(A - B + 1 <= 0) continue;

        for(int i=0; i<n; i++) {
            if(s & (1<<i)) continue;
            dp[s | (1<<i)] += dp[s];
        }
    }

    LL ans = 0;
    for(int s=0; s<(1<<n); s++) {
        if(!dp[s]) continue;
        int A = 0, B = 0, tol_dam = 0;
        for(int i=0; i<b; i++) {
            if(s & (1<<i)) {
                B++; tol_dam += dam[i+1];
            }
        }
        for(int i=b; i<n; i++) {
            if(s & (1<<i)) {
                A++;
            }
        }

        if(tol_dam >= p) {
            ans += dp[s] * fac[n-A-B];
        }
    }

    LL tol = fac[n];
    LL gcds = gcd(ans, tol);

    printf("%lld/%lld\n", ans/gcds, tol/gcds);
}

return 0;

}