hdu5816 Hearthstone 状态压缩dp

/*
    题目描述：在牌堆中有n+m（n+m <= 20）张牌，其中n张是A类牌，m张是B类牌，每摸到一张A类牌，可以再摸两张，
         每摸到一张B类牌，可以对敌人造成该张牌上标出的伤害，现在已知敌人的血量，牌堆中的牌被任意顺序放置，问有多大的
         概率可以斩杀敌人。
    
    思路：用状态压缩来解决此问题，将m张B类牌压成一个正整数st，dp[i][st]的含义如下：
       现在摸出了i张A类牌，摸出B类牌的情况是st，那么
              如果st中的总伤害大于敌人的hp，那么dp[i][st]表示这些A类与B类牌能够斩杀敌人时的合理摆放顺序的情况种类数；
              如果st中的总伤害小于敌人的hp，那么dp[i][st]表示能够顺利的摸出这些A类牌与B类牌时合理摆放顺序的情况种类
              数（比如前面放的都是B类牌那么肯定不能把这些牌全部摸出来）
           转移如下：
                dp[i][st | ( 1 << (t - 1) )] += dp[i][st];      表示已经摸了st的情况下又摸了第t张B类牌
                dp[i + 1][st] += dp[i][st] * (n - i);       表示已经摸了st的情况下又摸了一张A类牌，因为已经摸了i张A类牌，所以A类牌还有（n-i）张
                （注意转移的时候有一个先决条件，如果摸了k张A类牌，l张B类牌，这些牌伤害总和既不能斩杀对手，又不可能全部摸出，那么不进行转移）
*/
#pragma warning(disable:4786)
#pragma comment(linker, "/STACK:102400000,102400000")
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<vector>
#include<cmath>
#include<string>
#include<sstream>
#include<bitset>
#define LL long long
#define FOR(i,f_start,f_end) for(int i=f_start;i<=f_end;++i)
#define mem(a,x) memset(a,x,sizeof(a))
#define lson l,m,x<<1
#define rson m+1,r,x<<1|1
using namespace std;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double PI = acos(-1.0);
const double eps=1e-6;
const int maxn = (1 << 20) - 1;
int T , n , m , N , M , hp , cnt;
LL a[30] , f[30] , dp[21][maxn] , attack[maxn] , re[maxn];
vector<int>v[21];
LL gcd(LL a , LL b)
{
    return b == 0 ? a : gcd(b , a % b);
}
void dfs(int num , int st , int msum , int att)
{
    if(num == m + 1){
        v[msum].push_back(st);
        re[st] = 1 - msum;
        attack[st] = att;
        return ;
    }
    dfs(num + 1 , (st | (1 << (num - 1) )) , msum + 1 , att + a[num] );
    dfs(num + 1 , st , msum , att );
}
void init(int rt)
{
    for(int i = 0 ; i<=20 ; i++){
        v[i].clear();
    }
    for(int i = 0 ; i<= n; i++){
        for(int st = 0 ; st <= rt ; st++){
            dp[i][st] = 0;
        }
    }
}
int main()
{
    LL sum = 0 , p , q;
    scanf("%d", &T);
    f[0] = 1LL;
    for(int i = 1; i<= 20; i++){
        f[i] = f[i - 1] * i;
    }   //算阶乘
    while(T--){
        scanf("%d %d %d",&hp , &n , &m);
        int rt = (1<< m) - 1;
        for(int i =1 ; i<= m ; i++){
            scanf("%lld", &a[i]);
            sum += a[i];
        }
        if(sum < hp){
            puts("0/1");
            continue;
        }
        init(rt);
        dfs(1 , 0 , 0 , 0);
        dp[0][0] = 1;
        for(int i = 0 ; i <= n ; i++){
            for(int j = 0 ; j<= m ; j++){
                int st , sz = v[j].size();
                for(int k = 0 ; k < sz ; k++){      //上面其实是在枚举i和st，本来是想剪掉一些情况才这么写的，后来发现少情况了，写的比较丑
                    st = v[j][k];
                    if(i + re[st] <= 0 && attack[st] < hp)      continue;       //先决条件的判断
                     for(int t = 1 ; t <= m ; t++){
                        if(st & ( 1 << (t - 1) ) )      continue;
                        dp[i][st | ( 1 << (t - 1) )] += dp[i][st];      //dp部分刷表
                    }
                    dp[i + 1][st] += dp[i][st] * (n - i);
                }
            }
        }
        p = dp[n][rt];
        q = f[n + m];
        LL d= gcd(p , q);
        p /= d;
        q /= d;
        printf("%lld/%lld\n", p , q);
    }
    return 0;
}