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
思路：题目要求不超过L的所有符合单词，我们先考虑等于L
对于所有满足的情况 = 所有情况-不满足情况
不满足情况即是不包含词根的单词，对于计算满足长度所有情况，可以联想到矩阵快速幂，这样我们就只需要建一个矩阵图
对于建图，我们知道，所有以词根作为前缀子串的都是不符合条件的。
从根开始记录每种前缀可以添加的字母路径数（字母不是词根的结尾）。
于是我们可以想到AC自动机，对于自动机补全的trie图，每个单词的fail都指向其最长子后缀
也就是从根以fail指针向下建图的话，当遍历到一个词根末尾时，其下面的有词根都时不合法的，这可以用dfs维护。
我们知道当矩阵中存有边权（代表路径数）时（相当于到每个点走一条路径），我们将自身乘自身，得到的二次幂矩阵，每个位置的权值就相当于从i走到j走两条路径的路径数目。（离散数学）
这样推广到这，就相当于算出矩阵的L次幂，其第一行的和就是从0长度到L长度经过各个路径以各种字母结尾的路径和，这是长度等于L的情况。
那么对于长度<=L的所有情况，我们知道 Σ(A1+A2+A3+...+AL)，然后其第一行的和即是答案。
一开始写的是递归，对于L=6为偶数，A1+A2+A3+A3(A1+A2+A3)
　　　　　　　　　对于L=5为奇数，A1+A2+A2(A1+A2)+A5
但也许是姿势不对，一直tle。

然后看了Discus，我们可以添加一维，（假设原本矩阵为L，此L！=题面的L），使得L+1列全是1，这样对于第L个矩阵maps【1】【L+1】就储存Σ（A1+A2+A3+...+A[L-1]）
对于取模，因为是对1<<64取模，太大了直接取不了（睿智的尝试），可以直接把相关数组开成unsign long long 可以直接对溢出舍去相当于取模
还有利用等比数列公式时，由于涉及除法，利用欧拉定理求出逆元即可。

附上丑代码

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

typedef unsigned long long  ull;
struct Node
{
    int y,next;
} node[41];
int cnt,head[40],L;
int n;
ull len;
int tohash[40],topos;
void add(int x,int y)
{
    node[++cnt].y=y;
    node[cnt].next=head[x];
    head[x]=cnt;
}

struct MAP
{
    ull m[40][40];
    friend MAP operator*(const MAP a,const MAP b)
    {
        MAP tmp;
        for(int i=1; i<=L+1; i++)
        {
            for(int j=1; j<=L+1; j++)
            {
                tmp.m[i][j] = 0;

                for(int k=1; k<=L+1; k++)
                {
                    tmp.m[i][j] = tmp.m[i][j]+ a.m[i][k]*b.m[k][j];
                }

            }
        }
        return tmp;
    }
//    friend MAP operator+(const MAP a,const MAP b)
//    {
//        MAP tmp;
//        for(int i=1;i<=L;i++)
//        {
//            for(int j=1;j<=L+;j++)
//            {
//                tmp.m[i][j] = a.m[i][j] + b.m[i][j];
//            }
//        }
//        return tmp;
//    }
    void init()
    {
        for(int i=1; i<=L+1; i++)
        {
            for(int j=1; j<=L+1; j++)
            {
                m[i][j] = 0;
            }
            m[i][i] = 1;
        }
    }
} maps;
struct ACTO
{
    int trie[40][26],tot;
    int dp[40];
    int fail[40];
    int End[40];
    void init()
    {
        tot = cnt = L = topos = 0;
        memset(trie,0,sizeof(trie));
        memset(maps.m,0,sizeof(maps.m));
        memset(head,0,sizeof(head));
        memset(dp,0,sizeof(dp));
        memset(fail,0,sizeof(fail));
        memset(End,0,sizeof(End));
        memset(tohash,0,sizeof(tohash));
    }
    void Insert(char *str,int num)
    {
        int len = strlen(str),p=0;
        for(int i=0; i<len; i++)
        {
            int ch = str[i]-'a';
            if(!trie[p][ch])trie[p][ch]=++tot;
            p = trie[p][ch];
        }
        End[p]=num;
    }
    void get_fail()
    {
        queue<int>que;
        while(!que.empty())que.pop();
        for(int i=0; i<26; i++)if(trie[0][i])que.push(trie[0][i]);
        while(!que.empty())
        {
            int p = que.front();
            que.pop();
            for(int i=0; i<26; i++)
            {
                if(trie[p][i])
                {
                    fail[trie[p][i]] = trie[fail[p]][i];
                    que.push(trie[p][i]);
                }
                else trie[p][i] = trie[fail[p]][i];
            }
        }
    }
    void make_edge()
    {
        for(int i=1; i<=tot; i++)
        {
            add(fail[i],i);
        }
    }
    void dfs(int x,int f)
    {
        if(End[x])f=1;
        dp[x] = f;
        for(int i=head[x]; i; i=node[i].next)
        {
                dfs(node[i].y,f);
        }

    }
    void graph()
    {
        for(int i=0; i<=tot; i++)
        {
            if(!dp[i])
            {
                L++;
                if(!tohash[i])tohash[i] = ++topos;
                for(int j=0; j<26; j++)
                {
                    if(!dp[trie[i][j]])
                    {
                        if(!tohash[trie[i][j]])tohash[trie[i][j]]=++topos;
                        maps.m[tohash[i]][tohash[trie[i][j]]]++;
                    }
                }
            }
        }
    }
};

MAP qpow(MAP a,ull b)
{
    MAP ans;
    ans.init();
    MAP base = a;
    while(b)
    {
        if(b&1)ans = ans*base;
        base = base * base;
        b >>= 1;
    }
    return ans;
}

ACTO AC;

//MAP cal(int l,int r)
//{
//
//    if(l==r)return maps;
//    int mid = r/2;
//    if(r & 1)
//    {
//        return cal(l,mid)+qpow(maps,mid)*cal(l,mid)+qpow(maps,r);
//    }
//    else
//    {
//        return cal(l,mid)+cal(l,mid)*qpow(maps,mid);
//    }
//}



ull qmulti(ull m,ull n)
{
    ull ans = 0;
    while(n)
    {
        if(n&1)ans += m;
        m += m;
        n >>= 1;
    }
    return ans;
}
ull qpow(ull a,ull b)
{
    ull ans = 1;
    ull base = a;
    while(b)
    {
        if(b&1)ans = qmulti(ans,base);
        base  = qmulti(base,base);
        b >>= 1;
    }
    return ans;
}

int main()
{
    while(~scanf("%d%llu",&n,&len))
    {
        AC.init();
        memset(maps.m,0,sizeof(maps));
        char W[10];
        for(int i=1; i<=n; i++)
        {
            scanf(" %s",W);
            AC.Insert(W,i);
        }
        AC.get_fail();
        AC.make_edge();
        AC.dfs(0,0);
        AC.graph();
        for(int i=1;i<=2;i++)
        {
            for(int j=1;j<=2;j++)
            {
                printf(" %d ",maps.m[i][j]);
            }
            puts("");
        }
        for(int i=1;i<=L+1;i++)maps.m[i][L+1]=1;
       MAP ans = qpow(maps,len);
       ull total = (qpow(26,len+1)-26)*qpow(25,(1ull<<63)-1);
       for(int i=1;i<=L+1;i++)total -= ans.m[1][i];
       printf("%llu
",total+1);
    }
}