hdu2243 考研路茫茫——单词情结【AC自动机】【矩阵快速幂】

考研路茫茫——单词情结

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 7136    Accepted Submission(s): 2502

Problem Description

背单词，始终是复习英语的重要环节。在荒废了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

 

Author

linle

 

Recommend

lcy

题意：

给定$n$个字符串，问长为$l$的串，有多少个里面含有给定的这些字符串之一。

思路：

之前poj2778  https://www.cnblogs.com/wyboooo/p/9899944.html这道题求得是不含有字符串的情况。

那么这道题其实可以转换为，所有的情况减去不含有这些字符串的情况。

建立AC自动机，然后根据标记建立矩阵,矩阵快速幂$l+1$的幂次。

因为长度是小于等于$l$的都行，所以做$l+1$，这里会超$int$

然后对矩阵

$$

egin{matrix}

26 & 0 \

1 & 1 

end {matrix}

$$做$l$次快速幂，结果的第二行第一列乘26就是总的个数。

#include<iostream>
#include<bits/stdc++.h>
#include<cstdio>
#include<cmath>
//#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<queue>
#include<vector>
//#include<set>
//#include<climits>
//#include<map>
using namespace std;
typedef long long LL;
typedef unsigned long long ull;
#define pi 3.1415926535
#define inf 0x3f3f3f3f

const int maxn = 160;
struct Tree{
    int fail;
    int son[26];
    int ed;
}AC[maxn];
int tot = 0;

void init()
{
    for(int i = 0; i <= tot; i++){
        AC[i].fail = 0;
        AC[i].ed = 0;
        memset(AC[i].son, 0, sizeof(AC[i].son));
    }
    tot = 0;
}

void build(string s)
{
    int len = s.length();
    int now = 0;
    for(int i = 0; i < len; i++){
        if(AC[now].son[s[i] - 'a'] == 0){
            AC[now].son[s[i] - 'a'] = ++tot;
        }
        now = AC[now].son[s[i] - 'a'];
    }
    AC[now].ed += 1;
}

void get_fail()
{
    queue<int>que;
    AC[0].fail = 0;
    for(int i = 0; i < 26; i++){
        if(AC[0].son[i] != 0){
            AC[AC[0].son[i]].fail = 0;
            que.push(AC[0].son[i]);
        }
    }
    while(!que.empty()){
        int u = que.front();
        que.pop();
        if(AC[AC[u].fail].ed)AC[u].ed++;
        for(int i = 0; i < 26; i++){
            if(AC[u].son[i] != 0){
                AC[AC[u].son[i]].fail = AC[AC[u].fail].son[i];
                que.push(AC[u].son[i]);
            }
            else{
                AC[u].son[i] = AC[AC[u].fail].son[i];
            }
        }
    }
}

struct matrix{
    ull m[maxn][maxn];
    int n;
    matrix(){}
    matrix(int _n)
    {
        n = _n;
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                m[i][j] = 0;
            }
        }
    }
    matrix operator *(const matrix &b)const{
        matrix ret = matrix(n);
        //memset(ret.m, 0x3f, sizeof(ret.m));
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                for(int k = 0; k < n; k++){
                    ret.m[i][j] += m[i][k] * b.m[k][j];
                }
            }
        }
        return ret;
    }
    void debug()
    {
        for(int i = 0; i < n; i++){
            for(int j = 0; j <n; j++){
                printf("%llu ", m[i][j]);
            }
            cout<<endl;
        }
    }
}g;

ull pow_m(ull a, int n)
{
    ull ret = 1;
    ull tmp = a;
    while(n){
        if(n & 1)ret *= tmp;
        tmp *= tmp;
        n >> 1;
    }
    return ret;
}

matrix pow_M(matrix a, ull x)
{
    //a.debug();
    matrix ret = matrix(a.n);
    for(int i = 0; i < a.n; i++){
        ret.m[i][i] = 1;
    }
    matrix tmp = a;
    while(x){
        if(x & 1)ret = ret * tmp;
        tmp = tmp * tmp;
        //tmp.debug();
        //ret.debug();cout<<endl;
        x >>= 1;
    }
    return ret;
}

matrix get_matrix()
{
    matrix ret = matrix(tot + 1);
    for(int i = 0; i < tot; i++){
        if(AC[i].ed)continue;
        for(int j = 0; j < 26; j++){
            if(AC[AC[i].son[j]].ed == false){
                ret.m[i][AC[i].son[j]]++;
            }
        }
    }
    for(int i = 0; i < tot + 1; i++){
        ret.m[i][tot] = 1;
    }
    return ret;
}

int n;
ull l;
int main()
{
    while(scanf("%d%I64u", &n, &l) != EOF){
        init();
        for(int i = 0; i < n; i++){
            string s;
            cin>>s;
            build(s);
        }
        //cout<<l<<endl;
        get_fail();
        g = get_matrix();
        //g.debug();
        g = pow_M(g, l + 1);
        //g.debug();
        ull res = 0;
        /*for(int i = 0; i < g.n; i++){
            res += g.m[0][i];
        }*/
        res = g.m[0][tot] - 1;
        matrix T = matrix(2);
        //S.m[0][0] = 26;S.m[1][0] = 0;
        T.m[0][0] = 26;T.m[0][1] = 0;
        T.m[1][0] = 1;T.m[1][1] = 1;
        T = pow_M(T, l);
        printf("%I64u
", T.m[1][0] * 26 - res);
    }
    return 0;
}