F - 考研路茫茫――单词情结 HDU - 2243

背单词，始终是复习英语的重要环节。在荒废了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。
第二行有N个词根，每个词根仅由小写字母组成，长度不超过5。两个词根中间用一个空格分隔开。
Output
对于每组数据，请在一行里输出一共可能的单词数目。
由于结果可能非常巨大，你只需要输出单词总数模2^64的值。
Sample Input
2 3
aa ab
1 2
a
Sample Output
104
52
这题贼无语，一直TLE，还以为是我时间复杂度高了，后来才发现原来自己AC自动机写错了，v = f[v]的我写成了v = f[t]，结果一直TLE。
这题就是要求长度不超过l的串且至少包括一个模式串的个数，进而可以转化为长度不超过l的串的个数减去不包括模式串的个数。总数为26^1 + 26^2 + … + 26^l，不包括模式串的个数与hdu2778的求法类似，但是因为是不超过l的个数，那么可以假设不超过n的个数为S(n),长度为n的个数为f(n),S(n) = S(n-1) + f(n),f(n) = A*f(n-1) (实际上A是一个转移矩阵，可通过A^n求长度为n的不包括模式串的个数)于是可以画出这样的转移矩阵.
都知道通过矩阵求转移矩阵了，求等比数列和的转移矩阵也不难求了吧。
其次看了kuangbin大佬的博客，求等比矩阵的和可以将A增加一列sz，其中全为1，sz为单词树中结点个数。A的n次方后，求和即为A的第一行相加减去1，且第sz列为S(n - 1)为什么可以这样做呢，可用归纳法证明其正确性，另外不再多少A的含义了。n = 1时要求长度为1的不包括模式串的，直接把A的第一行求和后减一即可，并且第sz列为S(0) = 1，假定对n也成立，则A^(n+1) = A ^ n * A，此时A^(n+1) 中的第一行从0到sz - 1为从根节点出发走n +1步的符合条件的方案数，而第一行的sz列的值等于A^n中第一行sz列S(n-1) + 所有从根节点出发走n步符合条件的方案数，即为S(n)，由于f(0)是不需要放进去的因此要减去1(这里实际上应该把S(n) - 1合并在一起比较好直观的证明).
看完前面两种都是用矩阵求的方法，当然肯定还有别的比如直接二分，类似分治去做。
A^1 + A^2 + … + A^n,mid = n / 2，n % 2 == 0时，(1 + A^mid) * (A^1 +… + A^mid)。n % 2 == 1时，(1 + A^mid) * (A^1 +… + A^mid) + A^n，递归求解即可。
这个代码我是结合了，上面两种矩阵的方法。

#include <iostream>
#include <string>
#include <set>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <queue>
#include <cstring>
#include <stack>
#include <vector>
#include <map>
using namespace std;
#define ll unsigned long long
char str[10];
int ch[40][30],f[40], val[40], sz;
struct matrix {
    ll a[35][35];
    void init() {
        for (int i = 0; i < sz + 1; ++i) {
            a[i][i] = 1;
        }
    }
    void setzero() {
        for (int i = 0; i < sz + 1; ++i) {
            for (int j = 0; j < sz + 1; ++j) {
                a[i][j] = 0;
            }
        }
    }
}A;
long long n, l;
void insert() {
    int u = 0;
    for (int i = 0; str[i] != '\0'; ++i) {
        int t = str[i] - 'a';
        if (!ch[u][t]) {
            memset(ch[sz], 0, sizeof(ch[sz]));
            ch[u][t] = sz;
            val[sz] = 0;
            sz++;
        }
        u = ch[u][t];
    }
    val[u] = 1;
}
void getfail() {
    int u = 0;
    f[u] = 0;
    queue<int> q;
    for (int i = 0; i < 26; ++i) {
        int t = ch[u][i];
        if (t) {
            q.push(t);
            f[t] = 0;
        }
    }
    while (!q.empty()) {
        u = q.front();
        q.pop();
        for (int i = 0; i < 26; ++i) {
            int t = ch[u][i];
            if (!t) {
                ch[u][i] = ch[f[u]][i];
                continue;
            }
            q.push(t);
            int v = f[u];
            while (v && !ch[v][i]) {
                v = f[v];
            }
            f[t] = ch[v][i];
            val[t] |= val[f[t]];
            //last[t] = val[f[t]] ? f[t] : last[f[t]];
        }
    }
}
void solve() {
    A.setzero();
    for (int i = 0; i < sz; ++i) {
        if (val[i]) {
            continue;
        }
        for (int j = 0; j < 26; ++j) {
            int t = ch[i][j];
            if (!val[t]) {
                A.a[i][t]++;
            }
        }
    }
    long long k = l;
    matrix ans;
    ans.a[0][0] = 1, ans.a[0][1] = 0;
    ans.a[1][0] = 26, ans.a[1][1] = 26;
    ll s = 0, f = 1;
    matrix c;
    while (k) {
        if (k & 1) {
            s = s * ans.a[0][0] + f * ans.a[1][0];
            f *= ans.a[1][1];
        }
        for (int i = 0; i < 2; ++i) {
            for (int j = 0; j < 2; ++j) {
                c.a[i][j] = 0;
                for (int k = 0; k < 2; ++k) {
                    c.a[i][j] += ans.a[i][k] * ans.a[k][j];
                }
            }
        }
        ans = c;
        k >>= 1;
    }
    k = l;
    for (int i = 0; i < sz + 1; ++i){
        A.a[i][sz] = 1;
    }
    matrix F;
    F.setzero();
    F.init();
    while (k) {
        if (k & 1) {
            for (int i = 0; i < sz + 1; ++i) {
                for (int j = 0; j < sz + 1; ++j) {
                    c.a[i][j] = 0;
                    for (int k = 0; k < sz + 1; ++k) {
                        c.a[i][j] += F.a[i][k] * A.a[k][j];
                    }
                }
            }
            F = c;
        }
        for (int i = 0; i < sz + 1; ++i) {
            for (int j = 0; j < sz + 1; ++j) {
                c.a[i][j] = 0;
                for (int k = 0; k < sz + 1; ++k) {
                    c.a[i][j] += A.a[i][k] * A.a[k][j];
                }
            }
        }
        A = c;
        k >>= 1;
    }
    ll sum = 0;
    for (int i = 0; i < sz + 1; ++i) {
        sum = sum + F.a[0][i];
    }
    printf("%I64u\n", s - sum + 1);
}
int main() {
    while (scanf("%I64d%I64d", &n, &l) == 2) {
        sz = 1;
        memset(ch[0], 0, sizeof(ch[0]));
        for (int i = 0; i < n; ++i) {
            scanf("%s", str);
            insert();
        }
        getfail();
        solve();
    }
    return 0;
}