UVALive

初始有一个空串s，从前n个大写字母中不断随机取出一个字母添加到s的结尾，出现模式串t时停止，求停止时s的长度期望。

这道题解法不唯一，比较无脑的方法是对模式串t建一个单串AC自动机，设u为自动机上的一个结点，dp[u]为从该结点出发走到终结状态时的期望步数，则dp[u]=∑(1+dp[v])/n,v为u的后继状态。特别地，终结状态的dp值为0。

这样一来，就可以列出线性方程组进行高斯消元了。由于答案非常大，用double会损失精度，所以改成longlong。

由于有除法的存在，为了防止出现除不开的现象，我写了个大模数+逆元的版本，还需要用到按位乘。(闲的蛋疼系列)

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

const ll mod=(1ll<<61)-1;
int m,ka;
char s[15];
ll Mul(ll x,ll p) {
    if(p<0)p+=mod;
    ll ret=0;
    for(; p; x=(x+x)%mod,p>>=1)if(p&1)ret=(ret+x)%mod;
    return ret;
}
ll Pow(ll x,ll p) {
    ll ret=1;
    for(; p; x=Mul(x,x)%mod,p>>=1)if(p&1)ret=Mul(ret,x)%mod;
    return ret;
}
ll inv(ll x) {return Pow(x,mod-2);}

struct Mat {
    static const int N=15;
    int n;
    ll a[N][N];
    ll* operator[](int x) {return a[x];}
    void gauss() {
        for(int i=0; i<n; ++i) {
            int r=i;
            if(!a[r][i]) {
                for(int k=i+1; k<n; ++k)if(a[k][i]) {r=k; break;}
            }
            if(r!=i)for(int j=i; j<=n; ++j)swap(a[i][j],a[r][j]);
            for(int k=i+1; k<n; ++k) {
                ll tmp=Mul(a[k][i],inv(a[i][i]));
                for(int j=i; j<=n; ++j)a[k][j]=(a[k][j]-Mul(a[i][j],tmp))%mod;
            }
        }
        for(int i=n-1; i>=0; --i) {
            for(int j=i+1; j<n; ++j)a[i][n]=(a[i][n]-Mul(a[j][n],a[i][j]))%mod;
            a[i][n]=Mul(a[i][n],inv(a[i][i]));
        }
    }
} G;

struct AC {
    static const int N=100+10,M=26;
    int go[N][M],pre[N],tot,end[N];
    int idx(char ch) {return ch-'A';}
    void init() {tot=0; newnode();}
    int newnode() {
        int u=tot++;
        memset(go[u],0,sizeof go[u]);
        end[u]=pre[u]=0;
        return u;
    }
    void ins(char* s) {
        int u=0,n=strlen(s);
        for(int i=0; i<n; u=go[u][idx(s[i])],++i)
            if(!go[u][idx(s[i])])go[u][idx(s[i])]=newnode();
        end[u]=1;
    }
    void build() {
        queue<int> q;
        for(int i=0; i<M; ++i)if(go[0][i])q.push(go[0][i]);
        while(!q.empty()) {
            int u=q.front();
            q.pop();
            for(int i=0; i<M; ++i) {
                if(go[u][i]) {
                    pre[go[u][i]]=go[pre[u]][i];
                    q.push(go[u][i]);
                } else go[u][i]=go[pre[u]][i];
            }
        }
    }
    void gettransmat(Mat& G) {
        G.n=tot;
        int n=tot;
        for(int i=0; i<n; ++i)
            for(int j=0; j<=n; ++j)
                G[i][j]=j==i?1:0;
        for(int i=0; i<tot; ++i)if(!end[i]) {
                for(int j=0; j<m; ++j)G[i][go[i][j]]=(G[i][go[i][j]]-inv(m))%mod;
                G[i][n]=(G[i][n]+1)%mod;
            }
    }
} ac;

int main() {
    int T;
    scanf("%d",&T);
    while(T--) {
        if(ka)puts("");
        printf("Case %d:
",++ka);
        ac.init();
        scanf("%d%s",&m,s);
        ac.ins(s);
        ac.build();
        ac.gettransmat(G);
        G.gauss();
        printf("%lld
",(G[0][G.n]+mod)%mod);
    }
    return 0;
}