HDU5816（状压DP,位运算的一些技巧）

最新推荐文章于 2019-07-14 13:58:25 发布

原创最新推荐文章于 2019-07-14 13:58:25 发布 · 606 阅读

0 ·

CC 4.0 BY-SA版权

动态规划专栏收录该内容

31 篇文章

订阅专栏

本文介绍了一种计算在一回合内击败对手概率的方法。在一个包含A类卡和B类卡的牌堆中，A类卡能抽取更多卡牌，而B类卡能对对手造成伤害。文章详细阐述了通过枚举所有可能的抽牌方案来确定能够达到对手生命值阈值的具体概率。

题意：

牌堆里有 N张 A类卡，M张 B类卡

A类卡能让你从牌堆里抽两张卡
第 i张 B类卡能让你对对手造成 x_i点伤害
刚开始从牌堆抽 1张牌，并且对手有 P点生命值

问一回合内打倒对手的概率是多少

分析：n+m<=20.所以可以考虑枚举每一个抽牌方案。然后判断每一种状态是否可以击败对手，可以就停，不行就再抽牌。具体见代码分析。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll dp[1<<21];
ll f[25];
int a[25];
int p,n,m;
bool check(int mask)
{
    mask>>=n;//只看前m位的伤害牌是否总伤害够p
    ll res=0;
    for(int i=0;i<m;i++)
    {
        if((mask>>i)&1)
            res+=a[i];
    }
    if(res>=p)return 1;
    else return 0;
}
int main()
{
    f[0]=1;
    for(int i=1;i<=21;i++){f[i]=f[i-1]*i;}
    int t;scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d%d",&p,&n,&m);
        for(int i=0;i<m;i++)scanf("%d",&a[i]);
        int up=(1<<(n+m))-1;//把n+m的状态全部枚举，前面m位是选伤害牌，后面n位是抽牌卡
        int upn=(1<<n)-1;//枚举抽牌卡的所有状态
        int num=n+m;
        ll ans=0;
        memset(dp,0,sizeof(dp));
        for(int i=0;i<num;i++)dp[1<<i]=1;//初始化，第一轮只能抽一张牌
        for(int i=0;i<=up;i++)
        {
            int have=__builtin_popcount(i);//选了几张牌
            int left=num-have;//还剩几张牌
            int haven=__builtin_popcount(i&upn);//选了几张抽牌卡
            if(check(i))//当前抽牌状态是否已经达到目标。达到就停
            {
                ans+=dp[i]*f[left];continue;//达到了目标，剩下的排可以全排列。
            }
            if(haven*2+1-have<=0)continue;//没牌抽也停
            for(int j=0;j<num;j++)
            {
                if(!((i>>j)&1))//枚举可以选的抽牌卡，然后抽这张抽牌卡
                {
                    dp[i|(1<<j)]+=dp[i];//状态转移
                }
            }
        }
        ll gcd=__gcd(ans,f[n+m]);//所有方案就是全排列的方案数
        printf("%lld/%lld\n",ans/gcd,f[n+m]/gcd);
    }
    return 0;
}

标程：官方题解：

方法用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)!就是答案.

#include <cstdio>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <cctype>
#include <map>
#include <set>
#include <queue>
#include <bitset>
#include <string>
using namespace std;
typedef pair<int,int> Pii;
typedef long long LL;
typedef unsigned long long ULL;
typedef double DBL;
typedef long double LDBL;
#define MST(a,b) memset(a,b,sizeof(a))
#define CLR(a) MST(a,0)
#define SQR(a) ((a)*(a))
#define PCUT puts("\n----------")

LL GCD(LL a, LL b){return b?GCD(b,a%b):a;}
int P,N,M, A[1<<20], sum[1<<20], cnt[1<<20], fmask;
LL f[25][25], fact[25], C[25][25];

void init();

int main()
{
    #ifdef LOCAL
    freopen("in.txt", "r", stdin);
//  freopen("out.txt", "w", stdout);
    #endif

    f[0][0] = f[0][1] = 1;
    for(int i=1; i<=20; i++)
    {
        f[i][0]=1;
        for(int j=1; j<i; j++) f[i][j] = f[i-1][j] + f[i][j-1];
        f[i][i] = f[i][i+1] = f[i][i-1];
    }

    for(int i=1; i<(1<<20); i++) cnt[i] = cnt[i^(i&-i)] + 1;

    fact[0]=1;
    for(int i=1; i<=20; i++) fact[i] = fact[i-1]*i;

    for(int i=0; i<=20; i++)
    {
        C[i][0]=1;
        for(int j=1; j<=i; j++) C[i][j] = C[i-1][j] + C[i-1][j-1];
    }

    int T;
    scanf("%d", &T);
    for(int ck=1; ck<=T; ck++)
    {
        scanf("%d%d%d", &P, &N, &M);
        LL ans=0;
        fmask = (1<<M)-1;
        for(int i=0; i<M; i++) scanf("%d", &A[1<<i]);
        sum[0] = 0;
        for(int i=1; i<=fmask; i++) sum[i] = sum[i^(i&-i)] + A[i&-i];
        for(int i=0; i<=fmask; i++) if(sum[i]>=P && cnt[i] <= N+1)
        {
            ans += C[N][cnt[i]-1] * f[cnt[i]-1][cnt[i]] * fact[cnt[i]-1] * fact[cnt[i]] * fact[N+M-2*cnt[i]+1];
        }
        if(sum[fmask] >= P && cnt[fmask] < N+1) ans += f[N][M] * fact[N] * fact[M];
        LL D = GCD(ans, fact[N+M]);
        printf("%lld/%lld\n", ans/D, fact[N+M]/D);
    }
    return 0;
}