BZOJ3846: ZCC loves words

注意到模数5047621=179*173*163
拆成这3个质数算，EXCRT合并
建立AC自动机，在上面dp，套个矩乘
但是发现在i位置匹配一个长度为k的单词j，贡献是(i+k)*prime[j]，对于不同的i贡献不同，又因为模数<200，最多只有100+种矩阵，处理出循环节就可以矩乘了

code：

#include<set>
#include<map>
#include<deque>
#include<queue>
#include<stack>
#include<cmath>
#include<ctime>
#include<bitset>
#include<string>
#include<vector>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<climits>
#include<complex>
#include<iostream>
#include<algorithm>
#define ll long long
using namespace std;

void exgcd(int a,int b,ll &x,ll &y)
{
    if(!a)
    {
        x=0,y=1;
        return;
    }
    ll tx,ty; exgcd(b%a,a,tx,ty);
    x=ty-b/a*tx;
    y=tx;
}
void merge(int &a,int b,int &m1,int m2)
{
    ll x,y; exgcd(m1,m2,x,y);
    x*=(b-a);
    a=((ll)a+(ll)m1*x)%(m1*m2); m1*=m2;
    a=a%m1; if(a<0) a+=m1;
}
const int maxn = 45;
const int maxx = 1100;

int mod[]={163,173,179},mn=3,Mod;
inline void add(int &a,const int &b){a+=b;if(a>=Mod)a-=Mod;}

int p[maxn],pri;
bool v[maxx];
void pre()
{
    for(int i=2;pri<40;i++)
    {
        if(!v[i]) p[++pri]=i;
        for(int j=1,k=p[j]*i;k<maxx;j++,k=p[j]*i)
        {
            v[k]=true;
            if(i%p[j]==0) break;
        }
    }
}

int n; ll L;
struct trie{int son[26],dis,L,c,fail;}tr[maxn]; int root,tot;
char str[maxn][maxn];
queue<int>q;
void build()
{
    while(tot>=0) 
    {
        tr[tot].c=tr[tot].L=tr[tot].dis=tr[tot].fail=0;
        memset(tr[tot].son,0,sizeof tr[tot].son);
        tot--;
    }
    root=tot=0;
    for(int i=1;i<=n;i++)
    {
        int x=root,l=strlen(str[i]+1);
        for(int j=1;j<=l;j++)
        {
            int cc=str[i][j]-'A',&y=tr[x].son[cc];
            if(!y) y=++tot;
            x=y;
        }
        tr[x].L=l,tr[x].c=p[i];
    }

    q.push(root);
    while(!q.empty())
    {
        const int x=q.front(); q.pop();
        int fl=tr[x].fail;
        for(int i=0;i<26;i++)
        {
            int &y=tr[x].son[i];
            if(y)
            {
                if(x!=root) tr[y].fail=tr[fl].son[i],tr[y].dis=tr[x].dis+1;
                q.push(y);
            }
            else y=tr[fl].son[i];
        }
    }
}
struct mat
{
    int a[maxn][maxn];
    mat(){memset(a,0,sizeof a);}
    inline mat operator *(const mat &y)
    {
        mat re;
        for(int i=0;i<=tot;i++)
            for(int k=0;k<=tot;k++)
                for(int j=0;j<=tot;j++)
                    add(re.a[i][j],a[i][k]*y.a[k][j]%Mod);
        return re;
    }
}trans[maxx],al,one;
mat pw(ll k)
{
    mat re=one;
    for(;k;k>>=1,al=al*al) if(k&1ll)
        re=re*al;
    return re;
}
int G()
{
    memset(one.a,0,sizeof one.a);
    for(int i=0;i<=tot;i++) one.a[i][i]=1;
    int u=L>1e9?Mod:min(Mod,(int)L);
    for(int i=1;i<=u;i++)
    {
        mat &now=trans[i];
        memset(now.a,0,sizeof now.a);
        for(int x=0;x<=tot;x++)
        {
            for(int j=0;j<26;j++)
            {
                int y=tr[x].son[j],cc;

                if(tr[y].c) cc=(i+tr[y].L)%Mod*tr[y].c%Mod;
                else cc=1;
                int tmp=y,dis=tr[tmp].dis;
                while(tr[tmp].fail)
                {
                    tmp=tr[tmp].fail;
                    if(tr[tmp].c&&dis>=tr[tmp].L)
                        cc=cc*(i+tr[tmp].L)%Mod*tr[tmp].c%Mod;
                    dis=min(dis,tr[tmp].dis);
                }

                add(now.a[x][y],cc);
            }
        }
    }
    if(L>=Mod)
    {
        al=trans[1];
        for(int i=2;i<=Mod;i++) al=al*trans[i];
    }
    mat re; re.a[0][0]=1;
    re=re*pw(L/Mod);
    ll oth=L%Mod;
    for(int i=1;i<=oth;i++) 
        re=re*trans[i];
    int ans=0;
    for(int i=0;i<=tot;i++) add(ans,re.a[0][i]);
    return ans;
}
int solve()
{
    int ans=0,m1=0;
    for(int i=0;i<3;i++)
    {
        Mod=mod[i]; int y=G();
        if(!m1) ans=y,m1=Mod;
        else merge(ans,y,m1,Mod);
    }
    return ans;
}

int main()
{
    pre(); int tcase=0;
    while(scanf("%d%lld",&n,&L)!=EOF)
    {
        for(int i=1;i<=n;i++) scanf("%s",str[i]+1);
        build();
        printf("Case #%d: %d\n",++tcase,solve());
    }

    return 0;
}