[ZJOI2019]麻将

Luogu5279 , LOJ3042
题意：给出初始13张手牌，求理论可以和牌的最小轮数的期望．定义和牌为：4句话+1对乱将，不能有杠；七对

原始题解-shadowice
写得很好的题解

首先分析期望：
\(<--\)所有和牌的步数和＝所有不和牌的情况都再摸1张，除以所有的情况数\((4n-13)!\)
设\(f(i)\)为摸i张牌还不和牌的方案数，则答案为　\[\frac{\sum_{i=1}^{4n−13} {f(i)⋅i!⋅(4n−13−i)!}} {(4n−13)!}\]
f(i)的求法要
把所有不和牌的状态\(dfs\)出一颗树(＂自动机＂？)，状态用\(map\)存
设\(f[i][j][k]\)表示已经考虑了\(i\)种牌，\(j\)张牌，当前状态为\(k\)且不和牌的方案数．如果当前下一种牌取\(t\)张，那么\(f[i+1][j+t][ch[k][t]]+=f[i][j][k]*C(4-a[i],t-a[i])\)

具体考虑设状态：
首先要知道一道判断是否和牌的题超级麻将，先考虑这题的设状态和怎么转移状态
每一种状态要存已经构成了几句话，有没有将．然后就只和最后两种牌选了几张构成顺子有关，于是关于牌的选取只要考虑最后两维
还可以定义3句同样的吃为3个碰，那么转移时是把碰单独考虑

设当前第\(x\)种，\(x-1\)种有\(i\)张牌构成吃，\(x\)种有\(j\)张牌构成吃，\(x+1\)种选\(i+j+k\)张且有\(k\)张牌构成吃时\(f[1/0][j][k]=max(f[1/0][j][k],min(4,f[0/1][i][j]+i+((x-i-j-k)>=3))\)
("构成吃"是指暂时没有贡献的多出来的牌数)
即只考虑有贡献的情况：选\(i+j+k\)张，多出来\(k\)张．
且此时\(i\)张形成顺子(都是多出来的)；碰单独考虑
总结一下就是，
用一个结构体维护：这个状态下的[最后两种牌对应的两维]下(分别拿出\(i,j\)张构成新顺子时)的情况：
\(cnt\)句话；\(f\)存无将的情况，\(g\)存有将的情况，

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<map>
#define debug(...) fprintf(stderr,__VA_ARGS__)
#define Debug(x) cout<<#x<<"="<<x<<endl
using namespace std;
typedef long long LL;
const int INF=1e9+7;
inline LL read(){
    register LL x=0,f=1;register char c=getchar();
    while(c<48||c>57){if(c=='-')f=-1;c=getchar();}
    while(c>=48&&c<=57)x=(x<<3)+(x<<1)+(c&15),c=getchar();
    return f*x;
}

const int N=405;
const int S=2105;
const int mod=998244353;

int a[N],fac[N],ifac[N];
int ch[S][5],f[N][S],g[N][S];
int n,Pcnt;

inline int add(int x,int y){x+=y;return x>=mod?x-mod:x;}
inline int mul(LL x,int y){x*=y;return x>=mod?x%mod:x;}
inline int C(int n,int m){return mul(fac[n],mul(ifac[m],ifac[n-m]));}

struct Node{
    int f[3][3];

    inline Node(){memset(f,-1,sizeof f);}//赋初值

    inline int* operator[] (const int x){return f[x];}//方便调用

    inline bool operator< (const Node &a) const { //便于插到map里面去
        for(int i=0;i<3;i++){
            for(int j=0;j<3;j++)
                if(f[i][j]!=a.f[i][j]) return f[i][j]<a.f[i][j];
        }
        return 0;
    }
    inline bool operator== (const Node &a) const {
        for(int i=0;i<3;i++){
            for(int j=0;j<3;j++)
                if(f[i][j]!=a.f[i][j]) return 0;
        }
        return 1;
    }
    inline bool operator!= (const Node &a) const {
        return !(*this==a);
    }
};

struct mahjong{
    Node f,g;//带将&不带将
    int cnt;

    inline mahjong(){f[0][0]=cnt=0;}///

    inline bool operator< (const mahjong &a) const { //便于插到map里面去
        if(f!=a.f) return f<a.f;
        if(g!=a.g) return g<a.g;
        return cnt<a.cnt;
    }

    inline mahjong trans(int x){//加x张新点数的牌进来,形成新的状态
        mahjong ans;
        ans.cnt=min(7,cnt+(x>=2));
        for(int i=0;i<3;i++)
            for(int j=0;j<3;j++){
                if(~f[i][j]){
                    for(int k=0;k<3&&i+j+k<=x;k++){
                        //只考虑有贡献的情况:选i+j+k张,多出来k张
                        ans.f[j][k]=max(ans.f[j][k],min(4,f[i][j]+i+((x-i-j-k)>=3)));
                        //此时i张形成顺子(都是多出来的);碰单独考虑
                    }
                    if(x>=2){
                        for(int k=0;k<3&&i+j+k<=x-2;k++) //作将
                            ans.g[j][k]=max(ans.g[j][k],min(4,f[i][j]+i));
                    }
                }
                if(~g[i][j]){
                    for(int k=0;k<3&&i+j+k<=x;k++)
                        ans.g[j][k]=max(ans.g[j][k],min(4,g[i][j]+i+((x-i-j-k)>=3)));
                }
            }
        return ans; // 维护的是 这个状态下的[最后两种牌对应的两维]下(分别拿出i,j张构成新顺子时)的情况:
                    // cnt句话;f存无将的情况,g存有将的情况
    }
};

map <mahjong,int> Id;

inline bool check(mahjong s){
    if(s.cnt>=7) return 1;
    for(int i=0;i<3;i++){
        for(int j=0;j<3;j++)
            if(s.g[i][j]>=4) return 1;
    }
    return 0;
}

inline int dfs(mahjong s){//把所有不和牌的状态构成一颗树(自动机)
    if(check(s)) return 0;//没有后继状态
    int &t=Id[s];
    if(t) return t;
    t=++Pcnt;
    for(int i=0;i<=4;i++)
        ch[t][i]=dfs(s.trans(i));
    return t;
}

int main(){
    n=read();
    for(int i=1;i<=13;i++) a[read()]++,read();
    fac[0]=fac[1]=ifac[0]=ifac[1]=1;
    for(int i=2;i<=(n<<2);i++) fac[i]=mul(fac[i-1],i);
    for(int i=2;i<=(n<<2);i++) ifac[i]=mul(ifac[mod%i],mod-mod/i);//阶乘必须分两步
    for(int i=2;i<=(n<<2);i++) ifac[i]=mul(ifac[i],ifac[i-1]);
    
    dfs(mahjong());

    g[0][1]=1;//强行滚动数组
    for(int i=0,sum=0;i<n;sum+=a[++i]){ //已经考虑了i种牌
        swap(f,g);
        for(int j=0;j<=(i<<2);j++)
            for(int k=1;k<=Pcnt;k++) g[j][k]=0;
        for(int j=sum;j<=(i<<2);j++) //已经摸了j张牌
            for(int k=1;k<=Pcnt;k++){ //状态为k
                if(!f[j][k]) continue;
                for(int t=a[i+1];t<=4;t++){
                    if(ch[k][t]) g[j+t][ch[k][t]]=add(g[j+t][ch[k][t]],mul(f[j][k],C(4-a[i+1],t-a[i+1])));
                }
            }
    }

    int ans=0;
    for(int i=1;i<=(n<<2)-13;i++){
        int sum=0;
        for(int j=1;j<=Pcnt;j++) sum=add(sum,g[i+13][j]);//i张牌还不和的方案数
        ans=add(ans,mul(sum,mul(fac[i],fac[4*n-13-i])));
    }

    printf("%d\n",add(mul(ans,ifac[4*n-13]),1));//所有不和的情况都加1步
}

转载于:https://www.cnblogs.com/lizehon/p/10835237.html