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;
}