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
Sample Output
|
思路：我们求出所有方案数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;
}