HDU2243 考研路茫茫——单词情结 ——AC自动机、矩阵优化

题目链接：https://vjudge.net/problem/HDU-2243

考研路茫茫——单词情结

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

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

题意：

给出m个单词，问长度不超过n且至少含有1个单词（可重叠）的字符串有多少个？

题解：

1.由于求“>=1”，那么可以先求出“<1”，即“=0”的有多少个，然后再用总的减去，得到答案。

2.“=0”，即不含有任何一个单词，详情请看：POJ2278 DNA Sequence 。

3. 由于长度<=n，那么我们要求 A^1 + A^2 + …… + A^n，其中A是初步得到的矩阵，怎么求？UVA11149 Power of Matrix 。

4. 最后用总的（26+26^2+……+26^n）减去不含单词的（A^1 + A^2 + …… + A^n 的初始状态那一行之和），即为答案。

代码如下：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <string>
#include <set>
using namespace std;
typedef unsigned long long LL;
const double EPS = 1e-6;
const int INF = 2e9;
const LL LNF = 9e18;
const int MOD = 1e9+7;
const int MAXN = 30+10;

int Size;
struct MA
{
    LL mat[30][30];
    void init()
    {
        for(int i = 0; i<Size; i++)
        for(int j = 0; j<Size; j++)
            mat[i][j] = (i==j);
    }
};

MA operator+(const MA &x, const MA &y)
{
    MA ret;
    memset(ret.mat, 0, sizeof(ret.mat));
    for(int i = 0; i<Size; i++)
    for(int j = 0; j<Size; j++)
        ret.mat[i][j] = x.mat[i][j]+y.mat[i][j];
    return ret;
}

MA operator*(const MA &x, const MA &y)
{
    MA ret;
    memset(ret.mat, 0, sizeof(ret.mat));
    for(int i = 0; i<Size; i++)
    for(int j = 0; j<Size; j++)
    for(int k = 0; k<Size; k++)
        ret.mat[i][j] += 1LL*x.mat[i][k]*y.mat[k][j];
    return ret;
}

MA qpow(MA x, int y)
{
    MA s;
    s.init();
    while(y)
    {
        if(y&1) s = s*x;
        x = x*x;
        y >>= 1;
    }
    return s;
}

MA solve(MA x, int n)
{
    if(n==1) return x;
    MA s;
    s.init();
    s = (s+qpow(x,n/2))*solve(x, n/2);
    if(n%2) s = s+qpow(x, n);
    return s;
}

struct Trie
{
    const static int sz = 26, base = 'a';
    int next[MAXN][sz], fail[MAXN], end[MAXN];
    int root, L;
    int newnode()
    {
        for(int i = 0; i<sz; i++)
            next[L][i] = -1;
        end[L++] = 0;
        return L-1;
    }
    void init()
    {
        L = 0;
        root = newnode();
    }
    void insert(char buf[])
    {
        int len = strlen(buf);
        int now = root;
        for(int i = 0; i<len; i++)
        {
            if(next[now][buf[i]-base] == -1) next[now][buf[i]-base] = newnode();
            now = next[now][buf[i]-base];
        }
        end[now] = 1;
    }
    void build()
    {
        queue<int>Q;
        fail[root] = root;
        for(int i = 0; i<sz; i++)
        {
            if(next[root][i] == -1) next[root][i] = root;
            else fail[next[root][i]] = root, Q.push(next[root][i]);
        }
        while(!Q.empty())
        {
            int now = Q.front();
            Q.pop();
            end[now] |= end[fail[now]];  //当前串的后缀是否也包含单词
            for(int i = 0; i<sz; i++)
            {
                if(next[now][i] == -1) next[now][i] = next[fail[now]][i];
                else fail[next[now][i]] = next[fail[now]][i], Q.push(next[now][i]);
            }
        }
    }

    LL query(int n)
    {
        MA s;
        memset(s.mat, 0, sizeof(s.mat));
        for(int i = 0; i<L; i++)
        {
            if(end[i]) continue;  //存在单词的状态没有后继
            for(int j = 0; j<sz; j++)
                if(end[next[i][j]]==0)   //存在单词的状态没有前驱
                    s.mat[i][next[i][j]]++;  // i到next[i][j]的路径数+1。注意，当next[i][j]==root时，路径数很可能大于1。
        }

        Size = L;
        s = solve(s, n);
        LL ret = 0;
        for(int i = 0; i<L; i++)  //答案为：初始状态到各个状态（包括初始状态）的路径数之和。
            ret += s.mat[0][i];
        Size = 1;
        memset(s.mat,0,sizeof(s.mat));  //26+26^2……+26^n。
        s.mat[0][0] = 26;
        s = solve(s, n);
        return s.mat[0][0]-ret;
    }
};

Trie ac;
char buf[20];
int main()
{
    int n, L;
    while(scanf("%d%d", &n,&L)!=EOF)
    {
        ac.init();
        for(int i = 1; i<=n; i++)
        {
            scanf("%s", buf);
            ac.insert(buf);
        }
        ac.build();
        LL ans = ac.query(L);
        printf("%llu
", ans);
    }
    return 0;
}