hdu2243 考研路茫茫——单词情结 (AC自动机+矩阵快速幂)

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)

Total Submission(s): 4709    Accepted Submission(s): 1465


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

 
思路：这题是让你求长度为L且其中包含n个词根中某一个的单词的总数，我们可以求出总的单词数以及不包含任何一个词根的单词的总数，然后减一下。这题和poj2778的不同在于它还要统计小于等于L长度的单词个数总和，那么只要在矩阵中加一维就行了。这里要注意，用邻接矩阵的k次方求一个点到另一个点条数的时候，不能把顺序弄反，因为矩阵中存的是某点到某点间的条数，是有向边，所以我们在用矩阵快速幂的时候要用初始矩阵乘上邻接矩阵的k次，顺序不能相反。还有因为结果是mod2^64次，所以直接用unsigned long long就行了，最后也不用再取模。

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<vector>
#include<map>
#include<set>
#include<queue>
#include<stack>
#include<string>
#include<algorithm>
using namespace std;
typedef unsigned long long ll;
#define inf 99999999
#define pi acos(-1.0)
#define maxn 505
#define maxnode 100
struct trie{
ll sz,root,val[maxnode],next[maxnode][30],fail[maxnode];
int q[1111111];
void init(){
int i;
sz=root=0;
val[0]=0;
for(i=0;i<26;i++){
next[root][i]=-1;
}
}
int idx(char c){
return c-'a';
}
void charu(char *s){
ll i,j,u=0;
ll len=strlen(s);
for(i=0;i<len;i++){
int c=idx(s[i]);
if(next[u][c]==-1){
sz++;
val[sz]=0;
next[u][c]=sz;
u=next[u][c];
for(j=0;j<26;j++){
next[u][j]=-1;
}
}
else{
u=next[u][c];
}
}
val[u]=1;
}
void build(){
int i,j;
int front,rear;
front=1;rear=0;
for(i=0;i<26;i++){
if(next[root][i]==-1 ){
next[root][i]=root;
}
else{
fail[next[root][i] ]=root;
rear++;
q[rear]=next[root][i];
}
}
while(front<=rear){
int x=q[front];
if(val[fail[x]])
val[x]=1;
front++;
for(i=0;i<26;i++){
if(next[x][i]==-1){
next[x][i]=next[fail[x] ][i];

}
else{
fail[next[x][i] ]=next[fail[x] ][i];
rear++;
q[rear]=next[x][i];
}

}
}
}
}ac;

struct matrix{
ll n,m,i;
ll data[99][99];
void init_danwei(){
for(i=0;i<n;i++){
data[i][i]=1;
}
}
};

matrix multi(matrix &a,matrix &b){
ll i,j,k;
matrix temp;
temp.n=a.n;
temp.m=b.m;
for(i=0;i<temp.n;i++){
for(j=0;j<temp.m;j++){
temp.data[i][j]=0;
}
}
for(i=0;i<a.n;i++){
for(k=0;k<a.m;k++){
if(a.data[i][k]>0){
for(j=0;j<b.m;j++){
temp.data[i][j]=temp.data[i][j]+a.data[i][k]*b.data[k][j];
}
}
}
}
return temp;
}

matrix fast_mod(matrix &a,ll n){
matrix ans;
ans.n=a.n;
ans.m=a.m;
memset(ans.data,0,sizeof(ans.data));
ans.init_danwei();
while(n>0){
if(n&1)ans=multi(ans,a);
a=multi(a,a);
n>>=1;
}
return ans;
}

ll kuaisumi(ll a,ll b)
{
ll ans = 1;
while(b>0)
{
if(b%2==1)
ans=ans*a;
b=b/2;
a=a*a;
}
return ans;
}

int main()
{
int n,m,i,j;
char s[10];
ll sum,sum1,sum2;
while(scanf("%d%d",&n,&m)!=EOF)
{
ac.init();
for(i=1;i<=n;i++){
scanf("%s",s);
ac.charu(s);
}
ac.build();

matrix a;
a.n=a.m=ac.sz+2;
for(i=0;i<a.n;i++){
for(j=0;j<a.m;j++){
a.data[i][j]=0;
}
}

for(i=0;i<=ac.sz;i++){
for(j=0;j<26;j++){
if(ac.val[i]==0 && ac.val[ac.next[i][j] ]==0){ //这里ac.val[i]==0不加也行，因为最后算的是从原点出发不到危险点的方案数，从危险点出发的不会算进去
a.data[i][ac.next[i][j] ]++;
}
}
}
for(i=0;i<a.n;i++){
a.data[i][a.n-1 ]=1;
}

matrix b;
b.n=1;b.m=a.m;
memset(b.data,0,sizeof(b.data));
for(i=0;i<26;i++){
if(ac.val[ac.next[0][i] ]==0 ){
b.data[0][ac.next[0][i] ]++;
}
}
matrix ant=fast_mod(a,m);
matrix ans=multi(b,ant);

sum1=ans.data[0][ans.m-1];

matrix a1;
a1.n=1;a1.m=2;
a1.data[0][0]=0;a1.data[0][1]=1;

matrix b1;
b1.n=b1.m=2;
b1.data[0][0]=b1.data[1][0]=26;
b1.data[0][1]=0;b1.data[1][1]=1;

matrix ant1;
ant1=fast_mod(b1,m);
matrix ans1;
ans1=multi(a1,ant1);

sum2=ans1.data[0][0];
cout<<sum2-sum1<<endl;
}
return 0;
}