ZJOI2019神题，间接送我退役的神题233
考场上由于T2写挂去写爆搜的时候已经没多少时间了，所以就写挂了233
这里不多废话直接开始讲正解吧，我们把算法分成两部分
1.建一个“胡牌自动机”
首先我们发现这题不能转化为一般DP问题求解的最大瓶颈就是因为它的状态很诡异
但是我们细细一想，形如\(\{1,1,1,2,3,4,5,6,7,8,9,10,12,12\}\)和\(\{3,3,3,5,6,7,9,10,11,14,15,16,20,20\}\)的本质其实是一样的（都是三个顺子+一个刻子+一个雀头的形式，且相对大小分布相同）
那么考虑到一共只有\(13\)张牌，那么最后的有效集合数必然很少，如果我们可以构造出这些集合那么可以帮助DP了
如果你知道DP套DP的姿势，那么就会套路地明白内层的DP应该用自动机的转移形式，所以我们大致的目标就出现了：
建出一个自动机，其中每一个节点都是一个状态，然后每个节点向子节点连的边就是摸牌之后能转移到的状态
所以我们就先考虑怎么建这个自动机，还是考虑DP
我们设\(f_{0/1,i,j,k}\)表示目前处理完了前\(i\)种牌，还剩下\(j\)组\((i-1,i)\)以及\(k\)张\(i\)，且是否（用\(0/1\)表示）存在雀头时最多的面子数
由于当\(j,k\ge 3\)时可以直接用\(i-1,i\)组成刻子，因此我们状态中的\(j,k\le 2\)
那么我们就开一个\(3\times3\)的矩阵表示状态，单个转移的时候枚举用于拼面子，与\((i-1,i)\)拼顺子，以及用来保留的个数，然后将多余的拿来拼刻子即可
然后考虑每次多出一个数值，我们直接讨论是否要留出一个雀头，分情况转移即可
我们发现这样并没有考虑七对子的情况，这个没关系，我们直接记录雀头的个数，特判了即可
因此剩下终止状态的判断就很简单了，直接把能胡的点作为终止节点结束即可
具体构造的过程可以用一个map来去重，然后用BFS来扩展状态，这个具体看代码
2.期望DP
先说一句，前面由于自动机对于任意数据构造相同，所以总点数是固定的\(2092\)，如前言所述不大
那么考虑DP求解最后的问题，我们用一个经典套路，将求\(\ge\)的化为求\(>\)然后最后加上等于的情况即可
具体到这道题上，其实就是求出\(i\)轮后不胡的方案数然后乘上贡献，最后的总答案加\(1\)即可
那么大致的DP方程就有了，我们设\(f_{i,j,k}\)表示选了前\(i\)种牌，一共用了\(j\)张，此时位于自动机上\(k\)号点的方案数
那么转移其实很简单，枚举第\(i\)种牌选的张数\(t\)，\(f_{i,j,k}\)向\(f_{i+1,j+t,node_k.son_{a_i+t}}\)转移，注意不要忘记乘上组合数\(C_{4-a_i}^t\)
求出\(f\)数组后最后的答案统计就十分简单了，令\(m=4n-13\)：
\[ans=\sum_{i=1}^m \frac{f_i\cdot i!\cdot(m-i)!}{m!}+1\]
这个很好理解，因为前后都可以随便选，因此不再赘述
综上，我们得到了一个复杂度上界为\(2092\cdot n^2\)的优秀做法，因为常数很小且跑不满因此足以通过
CODE
#include<cstdio>
#include<cstring>
#include<map>
#define RI register int
#define CI const int&
using namespace std;
const int N=105,MX=2100,mod=998244353;
inline void maxer(int& x,CI y)
{
if (y>x) x=y;
}
inline int min(CI a,CI b)
{
return a<b?a:b;
}
struct Matrix
{
int mat[3][3];
inline int* operator [] (CI x) { return mat[x]; }
inline Matrix(void)
{
memset(mat,-1,sizeof(mat));
}
friend inline bool operator != (Matrix A,Matrix B)
{
for (RI i=0;i<3;++i) for (RI j=0;j<3;++j)
if (A[i][j]!=B[i][j]) return 1; return 0;
}
friend inline bool operator < (Matrix A,Matrix B)
{
for (RI i=0;i<3;++i) for (RI j=0;j<3;++j)
if (A[i][j]!=B[i][j]) return A[i][j]<B[i][j];
}
inline bool Com_Hu(void)
{
for (RI i=0;i<3;++i) for (RI j=0;j<3;++j)
if (mat[i][j]>=4) return 1; return 0;
}
inline void flush(Matrix pre,CI num)
{
for (RI i=0;i<3;++i) for (RI j=0;j<3;++j)
if (~pre[i][j]) for (RI k=0;k<3&&i+j+k<=num;++k)
maxer(mat[j][k],min(i+pre[i][j]+(num-i-j-k)/3,4));
}
};
struct Hu_Auto_Node
{
Matrix p[2]; int cur,ch[5];
inline Hu_Auto_Node(void)
{
memset(ch,0,sizeof(ch)); cur=0; p[0]=p[1]=Matrix();
}
inline bool is_Hu(void)
{
if (cur>=7) return 1; return p[1].Com_Hu();
}
inline void Hu(void)
{
memset(ch,0,sizeof(ch)); cur=-1; p[0]=p[1]=Matrix();
}
friend inline bool operator < (Hu_Auto_Node A,Hu_Auto_Node B)
{
if (A.cur!=B.cur) return A.cur<B.cur;
if (A.p[0]!=B.p[0]) return A.p[0]<B.p[0];
if (A.p[1]!=B.p[1]) return A.p[1]<B.p[1]; return 0;
}
friend inline Hu_Auto_Node operator + (Hu_Auto_Node A,CI num)
{
if (A.is_Hu()) return A.Hu(),A; Hu_Auto_Node s;
s.p[0].flush(A.p[0],num); s.p[1].flush(A.p[1],num);
if (num>=2) s.p[1].flush(A.p[0],num-2);
s.cur=A.cur+(num>=2); if (s.is_Hu()) s.Hu(); return s;
}
};
class Hu_Automation
{
private:
map <Hu_Auto_Node,int> Hash;
inline void expand(CI id)
{
for (RI i=0;i<=4;++i)
{
Hu_Auto_Node son=node[id]+i;
if (!Hash.count(son)) node[Hash[son]=++tot]=son;
node[id].ch[i]=Hash[son];
}
}
public:
Hu_Auto_Node node[2100]; int tot;
inline Hu_Automation(void)
{
node[1].p[0][0][0]=0; node[tot=2].cur=-1;
Hash[node[1]]=1; Hash[node[2]]=2; expand(1);
for (RI i=3;i<=tot;++i) expand(i);
}
/*inline void check(void)
{
printf("%d\n",tot); for (RI i=1;i<=tot;++i,putchar('\n'))
for (RI j=0;j<=4;++j) printf("%d ",node[i].ch[j]);
}*/
}HA;
int f[2][N<<2][MX],a[N],fact[N<<2],inv[N<<2],n,m,x,y,nw,ans;
inline void inc(int& x,CI y)
{
if ((x+=y)>=mod) x-=mod;
}
inline int quick_pow(int x,int p=mod-2,int mul=1)
{
for (;p;p>>=1,x=1LL*x*x%mod) if (p&1) mul=1LL*mul*x%mod; return mul;
}
inline void init(CI n)
{
RI i; for (fact[0]=i=1;i<=n;++i) fact[i]=1LL*fact[i-1]*i%mod;
for (inv[n]=quick_pow(fact[n]),i=n-1;~i;--i) inv[i]=1LL*inv[i+1]*(i+1)%mod;
}
inline int C(CI n,CI m)
{
return 1LL*fact[n]*inv[m]%mod*inv[n-m]%mod;
}
inline void calc(CI x,CI y)
{
inc(ans,1LL*f[nw][x][y]*fact[x]%mod*fact[m-x]%mod);
}
int main()
{
RI i,j,k,t; for (scanf("%d",&n),i=1;i<=13;++i) scanf("%d%d",&x,&y),++a[x];
for (init(m=(n<<2)-13),f[0][0][1]=i=1;i<=n;++i)
for (nw=i&1,memset(f[nw],0,sizeof(f[nw])),j=m;~j;--j)
for (k=1;k<=HA.tot;++k) if (f[nw^1][j][k]) for (t=0;t<=4-a[i];++t)
inc(f[nw][j+t][HA.node[k].ch[a[i]+t]],1LL*f[nw^1][j][k]*C(4-a[i],t)%mod);
for (nw=n&1,i=1;i<=m;++i) for (calc(i,1),j=3;j<=HA.tot;++j) calc(i,j);
return printf("%d",(1LL*ans*inv[m]%mod+1)%mod),0;
}