HDU 6407 Pop the Balloons（状压DP+高精度）

Description

给出一个$n\times m$的区域，如果一个位置为$Q$表示该位置有一个气球，每次射击可以射中一个气球并扎破这个气球所处行列上所有的气球，问射击$1,...,k$次扎破所有气球的方案数

Input

第一行一整数$T$表示用例组数，每组用例首先输入三个整数$n,m,k$表示区域范围和最多可以射击的次数，最后输入一个$n\times m$的区域表示气球的分布

$(1\le T\le 100,1\le n\le 12,1\le m\le 20,1\le k\le 20)$

Output

输出$k$个整数分别表示射击$1,...,k$次扎破所有气球的方案数

Sample Input

4
2 2 2
QQ
.Q
2 2 2
QQ
..
3 3 3
.Q.
QQQ
.Q.
1 3 1
Q.Q

Sample Output

1
2
2
0
1
8
0
2

Solution

$n\le 12$较小，考虑枚举必须要扎破的行的状态$T$，然后按列进行转移，$dp[j][S]$表示前$j$行已经扎破的行状态为$S$的方案数，那么若第$j+1$列的气球状态被$T$包含，可以选择不在列扎气球，有转移$dp[j+1][S]+=dp[j][S]$，若第$j+1$列有在$T$中而不在$S$中的第$x$行的气球，那么可以选择扎这个气球，有转移$dp[j+1][S+2^x]+=dp[j][S]$，$dp[m][T]$即为必须扎破$T$状态气球的方案数，假设$T$状态中有$x$个气球，那么对第$x$个答案的贡献即为$dp[m][T]\cdot x!$，由于结果会爆$long\ long$故结果要用高精度

Code

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
struct BigInt
{
    const static int mod=10000;
    const static int LEN=4;
    int a[20],len;
    BigInt() 
    {
        memset(a,0,sizeof(a));
        len=1;
    }
    void init(ll x)
    {
        memset(a,0,sizeof(a));
        len=0;
        do
        {
            a[len++]=x%mod;
            x/=mod;
        }while(x);
    }
    void Init(const char s[])
    {
        memset(a,0,sizeof(a));
        int l=strlen(s),res=0;
        len=l/LEN;
        if(l%LEN)len++;
        for(int i=l-1;i>=0;i-=LEN)
        {
            int t=0,k=max(i-LEN+1,0);
            for(int j=k;j<=i;j++)t=t*10+s[j]-'0';
            a[res++]=t;
        }
    }
    int Compare(const BigInt &b)
    {
        if(len<b.len)return -1;
        if(len>b.len)return 1;
        for(int i=len-1;i>=0;i--)
            if(a[i]<b.a[i])return -1;
            else if(a[i]>b.a[i])return 1;
        return 0;
    }
    BigInt operator +(const BigInt &b)const
    {
        BigInt ans;
        ans.len=max(len,b.len);
        for(int i=0;i<=ans.len;i++)ans.a[i]=0;
        for(int i=0;i<ans.len;i++)
        {
            ans.a[i]+=((i<len)?a[i]:0)+((i<b.len)?b.a[i]:0);
            ans.a[i+1]+=ans.a[i]/mod;
            ans.a[i]%=mod;
        }
        if(ans.a[ans.len]>0)ans.len++;
        return ans;
    }
    BigInt operator -(const BigInt &b)const
    {
        BigInt ans;
        ans.len=len;
        int k=0;
        for(int i=0;i<ans.len;i++)
        {
            ans.a[i]=a[i]+k-b.a[i];
            if(ans.a[i]<0)ans.a[i]+=mod,k=-1;
            else k=0;           
        }
        while(ans.a[ans.len-1]==0&&ans.len>1)ans.len--;
        return ans;
    }
    BigInt operator *(const BigInt &b)const
    {
        BigInt ans;
        for(int i=0;i<len;i++)
        {
            int k=0;
            for(int j=0;j<b.len;j++)
            {
                int temp=a[i]*b.a[j]+ans.a[i+j]+k;
                ans.a[i+j]=temp%mod;
                k=temp/mod;
            }
            if(k!=0)ans.a[i+b.len]=k;
        }
        ans.len=len+b.len;
        while(ans.a[ans.len-1]==0&&ans.len>1)ans.len--;
        return ans;
    }
    BigInt operator /(const int &n)const
    {
        BigInt ans;
        ans.len=len;
        int k=0;
        for(int i=ans.len-1;i>=0;i--)
        {
            k=k*mod+a[i];
            ans.a[i]=k/n;
            k=k%n;
        }
        while(ans.a[ans.len-1]==0&&ans.len>1)ans.len--;
        return ans;
    }
    void output()
    {
        printf("%d",a[len-1]);
        for(int i=len-2;i>=0;i--)
            printf("%04d",a[i]);
        printf("\n");
    }
}fact[13],temp;
const int INF=0x3f3f3f3f,maxn=100001;
ll dp[21][(1<<12)+5],res[22];
int T,n,m,k,Sta[21],num[(1<<12)+5];
char s[22][22];
int main()
{
    int f=1;
    for(int i=1;i<=12;i++)
    {
        f=f*i;
        fact[i].init(f);
    }
    num[0]=0;
    for(int i=1;i<(1<<12);i++)num[i]=num[i/2]+(i&1);
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d",&n,&m,&k);
        for(int i=0;i<n;i++)scanf("%s",s[i]);
        for(int j=0;j<m;j++)
        {
            Sta[j+1]=0;
            for(int i=0;i<n;i++)
                if(s[i][j]=='Q')Sta[j+1]|=(1<<i);
        } 
        memset(dp,0,sizeof(dp));
        memset(res,0,sizeof(res));
        int N=1<<n;
        for(int T=0;T<N;T++)
        {
            dp[0][0]=1;
            for(int j=0;j<m;j++)
            {
                int flag=0;
                for(int S=T;;S=(S-1)&T)
                {
                    if(dp[j][S])
                    {
                        if((Sta[j+1]&T)==Sta[j+1])
                        {
                            flag=1;
                            dp[j+1][S]+=dp[j][S];
                        }
                        int W=(T^S)&Sta[j+1];
                        while(W)
                        {
                            int x=W&(-W);
                            flag=1;
                            dp[j+1][S|x]+=dp[j][S];
                            W-=x;
                        }
                        dp[j][S]=0;
                    }
                    if(!S)break;
                }
                if(!flag)break;
            }
            res[num[T]]+=dp[m][T];
            for(int S=T;;S=(S-1)&T)
            {
                dp[m][S]=0;
                if(!S)break;
            }
        }
        for(int i=1;i<=k;i++)
        {
            temp.init(res[i]);
            temp=temp*fact[i];
            temp.output();
        }
    }
    return 0;
}