考研路茫茫——单词情结
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 765 Accepted Submission(s): 222
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实在是数不出来了,现在就请你帮帮他。
一天,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。两个词根中间用一个空格分隔开。
每组数据占两行。
第一行有两个正整数N和L。(0<N<6,0<L<2^31)
第二行有N个词根,每个词根仅由小写字母组成,长度不超过5。两个词根中间用一个空格分隔开。
Output
对于每组数据,请在一行里输出一共可能的单词数目。
由于结果可能非常巨大,你只需要输出单词总数模2^64的值。
由于结果可能非常巨大,你只需要输出单词总数模2^64的值。
Sample Input
2 3aa ab1 2a
Sample Output
10452
通过求出所有可能数(26+26^1+...+26^n) - 不包含模式串各个长度总数来得到结果
求出可行矩阵A,求出A+A^1+...+A^n(记作S^n),则:
S^n=S^k * (E+A^k)+A^n // n=2*k+1
=S^k * (E+A^k) //n=2*k
这就是递归一样,我们可以从下到上类似栈一样来实现(代码)
源代码:
#include<iostream>
using namespace std;
const int KIND=26;
const int MAX=35;
struct TrieNode
{
bool unsafe;
int index;
TrieNode *fail;
TrieNode *next[KIND];
};
TrieNode memory[MAX];
int allocp;
TrieNode *q[MAX];
int m;
__int64 n;
TrieNode *CreateTrieNode()
{
TrieNode *p=&memory[allocp];
p->unsafe=false;
p->index=allocp;
allocp++;
p->fail=NULL;
memset(p->next,0,sizeof(p->next));
return p;
}
void InsertTrieNode(TrieNode *pRoot,char s[])
{
TrieNode *p=pRoot;
int i=0;
while(s[i])
{
int k=s[i]-'a';
if(p->next[k]==NULL)
p->next[k]=CreateTrieNode();
i++;
p=p->next[k];
}
p->unsafe=true;
}
void Build_AC_Automation(TrieNode *pRoot)
{
int head=0,tail=0,i;
TrieNode *p;
q[tail++]=pRoot;
pRoot->fail=NULL;
while(head!=tail)
{
p=q[head++];
for(i=0;i<KIND;i++)
if(p->next[i]!=NULL)
{
if(p==pRoot)
p->next[i]->fail=pRoot;
else
{
p->next[i]->fail=p->fail->next[i];
if(p->next[i]->fail->unsafe)
p->next[i]->unsafe=true;
}
q[tail++]=p->next[i];
}
else
{
if(p==pRoot)
p->next[i]=pRoot;
else
p->next[i]=p->fail->next[i];
}
}
}
struct Matrix
{
unsigned __int64 a[MAX][MAX];
int sz;
};
Matrix E;
void InitE(int size) //初始化单位矩阵
{
E.sz=size;
for(int i=0;i<E.sz;i++)
for(int j=0;j<E.sz;j++)
E.a[i][j]=(i==j);
}
Matrix MatrixAdd(Matrix m1,Matrix m2)//两矩阵再加
{
for(int i=0;i<m1.sz;i++)
for(int j=0;j<m2.sz;j++)
m1.a[i][j] += m2.a[i][j];
return m1;
}
Matrix MatrixMul(Matrix a,Matrix b)//两矩阵相乘
{
Matrix c;
int i,j,k;
c.sz=a.sz;
for(i=0;i<c.sz;i++)
for(j=0;j<c.sz;j++)
{
c.a[i][j]=0;
for(k=0;k<c.sz;k++)
c.a[i][j] += a.a[i][k]*b.a[k][j];
}
return c;
}
Matrix MatrixPow(Matrix a,__int64 n)//矩阵的n次幂
{
Matrix t=E;
while(n>0)
{
if(1&n)
t=MatrixMul(t,a);
a=MatrixMul(a,a);
n >>= 1;
}
return t;
}
Matrix MatrixSum(Matrix m0,__int64 times)//矩阵幂求和
{
Matrix m1,m2;
m1=m2=m0;
int i,bin[65],n=0;
while(times>0)
{
bin[n++]=(times&1);
times >>= 1;
}
for(i=n-2;i>=0;i--)//bin[n-1]一定为1
{
m1=MatrixMul(m1,MatrixAdd(m2,E));
m2=MatrixMul(m2,m2);
if(bin[i])
{
m2=MatrixMul(m2,m0);
m1=MatrixAdd(m1,m2);
}
}
return m1;
}
int main()
{
int i,j;
char word[15];
TrieNode *pRoot;
while(scanf("%d%I64d",&m,&n)!=EOF)
{
allocp=0;
pRoot=CreateTrieNode();
for(i=0;i<m;i++)
{
scanf("%s",word);
InsertTrieNode(pRoot,word);
}
Build_AC_Automation(pRoot);
Matrix g,dp;
InitE(allocp); //初始化单位阵
g.sz=allocp;
//初始化g
for(i=0;i<g.sz;i++)
for(j=0;j<g.sz;j++)
g.a[i][j]=0;
for(i=0;i<allocp;i++) //构建矩阵
for(j=0;j<KIND;j++)
{
TrieNode *tmp=memory[i].next[j];
if(memory[i].unsafe==false && tmp->unsafe==false)//要安全的
g.a[i][tmp->index]++;
}
g=MatrixSum(g,n);
unsigned __int64 ans=0;
for(i=0;i<allocp;i++)
ans += g.a[0][i];
//下面计算26+26^1+......+26^n
dp.sz=1;
dp.a[0][0]=26;
dp=MatrixSum(dp,n);
printf("%I64u\n",dp.a[0][0]-ans);
}
return 0;
}