您的位置:首页 > 其它

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

2015-10-11 15:49 351 查看

考研路茫茫——单词情结

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;
}
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: