hdoj 2243 考研路茫茫——单词情结 【AC自动机 + 构造矩阵】

考研路茫茫——单词情结 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 4489    Accepted Submission(s): 1355 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

思路：我们求出所有方案数ans = 26^1 + 26^2 + 26^3 + 26^4 + ... + 26^L。然后求出不含有模式串的方案数temp = sum(1) + sum(2) + sum(3) + ... + sum(L)。其中sum(i)表示长度为i的串不含有模式串的方案数。

对于ans = 26^1 + 26^2 + 26^3 + ... + 26^L。

令F[L] = 26^0 + 26^1 + ... 26^L，可以得到公式F[L] = 26*F[L-1] + 1。

这样可以构造二维矩阵用矩阵快速幂求出ans = F[L] - 1。

对于temp = sum(1) + ... + sum(L)。首先是构建trie树上的状态转移，得到初始矩阵ori.a。

我们知道sum(L) = res.a[0][0] + ... res.a[0][Node-1]，其中res.a为ori.a的L次幂，Node为trie节点数。

这样可以利用矩阵的性质，在矩阵ori.a基础上增加一行一列，并令第Node列全为1。

求出ori.a的L次幂res.a，最后res.a[0][0] + ... + res.a[0][Node] - 1 就是我们要求的temp。

本题要使用unsigned long long 存储2^64。

AC代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#define MAXN 50
#define LL unsigned long long
using namespace std;
struct Matrix{
    LL a[MAXN][MAXN];
    LL N;
};
Matrix ori, res;
Matrix multi(Matrix x, Matrix y)
{
    Matrix z;
    memset(z.a, 0, sizeof(z.a));
    z.N = x.N;
    for(int i = 0; i < x.N; i++)
    {
        for(int k = 0; k < y.N; k++)
        {
            if(x.a[i][k] == 0) continue;
            for(int j = 0; j < x.N; j++)
                z.a[i][j] += x.a[i][k] * y.a[k][j];
        }
    }
    return z;
}
Matrix M_op(LL n)
{
    while(n)
    {
        if(n & 1)
            res = multi(ori, res);
        ori = multi(ori, ori);
        n >>= 1;
    }
}
LL sum(LL n)
{
    memset(ori.a, 0, sizeof(ori.a));
    memset(res.a, 0, sizeof(res.a));
    ori.N = res.N = 2;
    for(int i = 0; i < 2; i++)
        res.a[i][i] = 1;
    ori.a[0][0] = ori.a[0][1] = 1;//构建矩阵 一开始这里写错了，找好久bug
    ori.a[1][1] = 26;
    if(n == 1)
        return 27;
    M_op(n-1);
    return 27 * res.a[1][1] + res.a[0][1];
}
struct Trie
{
    int next[MAXN][30], fail[MAXN], End[MAXN];
    int L, root;
    int newnode()
    {
        for(int i = 0; i < 26; i++)
            next[L][i] = -1;
        End[L++] = 0;
        return L-1;
    }
    void init()
    {
        L = 0;
        root = newnode();
    }
    void Insert(char *s)
    {
        int len = strlen(s);
        int now = root;
        for(int i = 0; i < len; i++)
        {
            if(next[now][s[i]-'a'] == -1)
                next[now][s[i]-'a'] = newnode();
            now = next[now][s[i]-'a'];
        }
        End[now] = 1;
    }
    void Build()
    {
        queue<int> Q;
        fail[root] = root;
        for(int i = 0; i < 26; 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();
            if(End[fail[now]])//失配指针指向模式串
                End[now] = 1;//可行
            for(int i = 0; i < 26; 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]);
                }
            }
        }
    }
    void getMatrix()
    {
        for(int i = 0; i < L; i++)
            if(End[i] == 0)
                for(int j = 0; j < 26; j++)
                    if(End[next[i][j]] == 0)
                        ori.a[i][next[i][j]]++;
        for(int i = 0; i < L+1; i++)
            ori.a[i][L] = 1;
    }
};
Trie ac;
void init_M(int NN)
{
    memset(ori.a, 0, sizeof(ori.a));
    memset(res.a, 0, sizeof(res.a));
    ori.N = res.N = NN;
    for(int i = 0; i < NN; i++)
        res.a[i][i] = 1;
}
LL solve(LL n)
{
    M_op(n);
    LL ans = 0;
    for(int i = 0; i < res.N; i++)
        ans += res.a[0][i];
    return ans;
}
char str[100];
int main()
{
    int N;
    LL L;
    while(scanf("%d%llu", &N, &L) != EOF)
    {
        LL ans = sum(L) - 1;//总方案数
        ac.init();
        for(int i = 0; i < N; i++)
            scanf("%s", str), ac.Insert(str);
        ac.Build();
        init_M(ac.L+1); ac.getMatrix();
        LL temp = solve(L) - 1;//不符合方案数
        printf("%llu\n", ans - temp);
    }
    return 0;
}