考研路茫茫——单词情结 （HDU-2243）（AC自动机+矩阵快速幂）

背单词，始终是复习英语的重要环节。在荒废了3年大学生涯后，Lele也终于要开始背单词了。
一天，Lele在某本单词书上看到了一个根据词根来背单词的方法。比如"ab",放在单词前一般表示"相反，变坏，离去"等。

于是Lele想，如果背了N个词根，那这些词根到底会不会在单词里出现呢。更确切的描述是：长度不超过L，只由小写字母组成的，至少包含一个词根的单词，一共可能有多少个呢？这里就不考虑单词是否有实际意义。

比如一共有2个词根 aa 和 ab ，则可能存在104个长度不超过3的单词，分别为
(2个) aa,ab,
(26个)aaa,aab,aac...aaz,
(26个)aba,abb,abc...abz,
(25个)baa,caa,daa...zaa,
(25个)bab,cab,dab...zab。

这个只是很小的情况。而对于其他复杂点的情况，Lele实在是数不出来了，现在就请你帮帮他。

Input

本题目包含多组数据，请处理到文件结束。
每组数据占两行。
第一行有两个正整数N和L。(0<N<6,0<L<2^31)
第二行有N个词根，每个词根仅由小写字母组成，长度不超过5。两个词根中间用一个空格分隔开。

Output

对于每组数据，请在一行里输出一共可能的单词数目。
由于结果可能非常巨大，你只需要输出单词总数模2^64的值。

Sample Input

2 3
aa ab
1 2
a

Sample Output

104
52

题意：中文题，不过多叙述题意。

思路：这道题的话，让你求包含的个数，那我们换个角度，我们求不包含的个数，然后再用总个数减去不包含的个数就好了。有一点需要注意的是，我们在构建矩阵的时候需要加一列全为1的元素。因为是对2^64取模，所以直接开unsigned long long 就可以，相当于自动对2^64取模。

AC代码：

#include <bits/stdc++.h>
typedef unsigned long long ull;
const int maxx=110;
const int maxn=26;
const int inf=0x3f3f3f3f;
using namespace std;
int Trie[maxn][maxn];
int fail[maxn];
int cntword[maxn];
char s[16];
int k,n,cnt;
ull m;
struct Matrix
{
    ull mat[maxx][maxx];
    Matrix()
    {
        memset(mat,0,sizeof(mat));
    }
    void init()
    {
        for(int i=0; i<=cnt; i++)
            for(int j=0; j<=cnt; j++)
                mat[i][j]=(i==j);
    }
    Matrix operator +(const Matrix &b)const
    {
        Matrix c;
        for(int i=0; i<=cnt; i++)
            for(int j=0; j<=cnt; j++)
                c.mat[i][j]=(mat[i][j]+b.mat[i][j]);
        return c;
    }
    Matrix operator *(const Matrix &b)const
    {
        Matrix c;
        for(int i=0; i<=cnt; i++)
            for(int j=0; j<=cnt; j++)
                for(int k=0; k<=cnt; k++)
                    c.mat[i][j]=(c.mat[i][j]+(mat[i][k]*b.mat[k][j]));
        return c;
    }
    Matrix operator ^(const ull &b)const
    {
        Matrix ans,a=(*this);
        ans.init();
        ull tot=b;
        while(tot)
        {
            if(tot&1)
                ans=ans*a;
            a=a*a;
            tot>>=1;
        }
        return ans;
    }
};
void init()
{
    k=0;
    memset(Trie,0,sizeof(Trie));
    memset(fail,0,sizeof(fail));
    memset(cntword,0,sizeof(cntword));
}
void insert(char *s)
{
    int p=0;
    int len=strlen(s);
    for(int i=0; i<len; i++)
    {
        int c=s[i]-'a';
        if(!Trie[p][c])
            Trie[p][c]=++k;
        p=Trie[p][c];
    }
    cntword[p]=1;
}
void build()
{
    queue<int>q;
    for(int i=0; i<26; i++)
    {
        if(Trie[0][i])
        {
            fail[Trie[0][i]]=0;
            q.push(Trie[0][i]);
        }
    }
    while(!q.empty())
    {
        int now=q.front();
        q.pop();
        if(cntword[fail[now]])
            cntword[now]=1;
        for(int i=0; i<26; i++)
        {
            if(Trie[now][i])
            {
                fail[Trie[now][i]]=Trie[fail[now]][i];
                q.push(Trie[now][i]);
            }
            else
                Trie[now][i]=Trie[fail[now]][i];
        }
    }
}
int main()
{
    while(~scanf("%d%u",&n,&m))
    {
        Matrix a,b;
        init();
        for(int i=1; i<=n; i++)
        {
            scanf("%s",s);
            insert(s);
        }
        build();
        for(int i=0; i<=k; i++)
        {
            if(cntword[i])
                continue;
            for(int j=0; j<26; j++)
            {
                if(cntword[Trie[i][j]])
                    continue;
                ++a.mat[i][Trie[i][j]];
            }
        }
        for(int i=0; i<=k+1; i++)
            a.mat[i][k+1]=1;
        cnt=k+1;
        a=a^m;
        ull ans=0;
        for(int i=0; i<=cnt; i++)
            ans+=a.mat[0][i];
        cnt=2;
        b.mat[0][0]=26;
        b.mat[0][1]=1;
        b.mat[1][1]=1;
        b=b^m;
        ull temp=b.mat[0][0]+b.mat[0][1];
        cout<<temp-ans<<endl;
    }
    return 0;
}