hdu 2243 长度为1~N的串中包含了模式串的串总共有几个

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
  
  
  
  


  
  

//

先要把总数26^1 + 26^2 + … + 26^N算出来，然后减去所有不包含的…反正比上题恶心一点点
答案要模2^64，直接用unsinged __int64 就OK了

#include<cstdio>
#include<cstring>
typedef unsigned __int64 ull;
//题目要模2^64  直接用unsigned __int64
const int NODE=35;
const int CH=26;
int tree[NODE][CH],cnt;
int word[NODE];
int fail[NODE];
int Que[NODE];
int num[150];
int matnum,matcal[NODE];
ull mm[NODE][NODE],tem[NODE][NODE],mat[NODE][NODE];
void Ins(char *a,int val)
{
    int p=0;
    for(; *a; a++)
    {
        int c=num[*a];
        if(!tree[p][c])
        {
            memset(tree[cnt],0,sizeof(tree[cnt]));//初始化新的节点
            fail[cnt]=0;//更新
            word[cnt]=0;
            tree[p][c]=cnt++;
        }
        p=tree[p][c];
    }
    word[p]=val;//做一个标记，说明这是病毒串
}
void AC()
{
    int *s=Que,*e=Que;
    for(int i=0; i<CH; ++i)
        if(tree[0][i])
        {
            fail[tree[0][i]]=0;//修改失败指针
            *e++=tree[0][i];
        }
    while(s!=e)
    {
        int p=*s++;
        for(int i=0; i<CH; ++i)
        {
            if(tree[p][i])
            {
                int v=tree[p][i];
                *e++=v;
                fail[v]=tree[fail[p]][i];
                word[v]|=word[fail[v]];//Wa了N次
            }
            else
            {
                tree[p][i]=tree[fail[p]][i];
            }
        }
    }
}
char s[13];
void Input(int m)
{
    fail[0]=0;
    memset(tree[0],0,sizeof(tree[0]));//初始化根节点，开始都指向根节点
    //从1开始，0有特殊使用
    cnt=1;//已经有根节点,节点是从1<=i<cnt
    for(int i=0; i<CH; i++)  num[i+'a']=i;
    for(int i=1; i<=m; i++)
    {
        scanf("%s",s);
        Ins(s,1);
    }
}
void init()//建立矩阵的关系
{
    memset(mat,0,sizeof(mat));
    memset(mm,0,sizeof(mm));
    memset(matcal,0,sizeof(matcal));
    matnum=0;//矩阵从0<=i<matnum
    for(int i=0; i<cnt; ++i)
        if(word[i]==0)  matcal[i]=matnum++;
    for(int i=0; i<cnt; ++i)
        if(word[i]==0)
        {
            for(int j=0; j<CH; ++j)
            {
                if(word[tree[i][j]]==0)//不是病毒串
                {
                    mm[matcal[i]][matcal[tree[i][j]]]++;
                }
            }
        }
}
void add(ull a[][NODE], ull b[][NODE])
{
    memset(tem,0,sizeof(tem));
    for(int i = 0; i < matnum; ++i)
        for(int j = 0; j < matnum; ++j)
            tem[i][j] = a[i][j] + b[i][j];
}
void Mul(ull a[NODE][NODE],ull b[NODE][NODE])
{
    memset(tem,0,sizeof(tem));
    for(int i=0; i<matnum; ++i)
        for(int j=0; j<matnum; ++j)
            for(int k=0; k<matnum; ++k)
                tem[i][j]=tem[i][j]+a[i][k]*b[k][j];
}
void solve(ull r[NODE][NODE],int k)//r=mm^k
{
    ull mt[NODE][NODE];
    memcpy(mt,mm,sizeof(mm));
    memset(r,0,sizeof(ull)*NODE*NODE);
    for(int i=0; i<matnum; ++i)  r[i][i]=1;
    while(k)
    {
        if(k&1)
        {
            Mul(mt,r);
            memcpy(r,tem,sizeof(tem));
        }
        k>>=1;
        Mul(mt,mt);
        memcpy(mt,tem,sizeof(tem));
    }
}
void work(ull dst[][NODE],int k)//dis=a^1+a^2+...+a^k
{
    if(k==1)
    {
        memcpy(dst,mm,sizeof(mm));
        return;
    }
    ull res[NODE][NODE],x[NODE][NODE],y[NODE][NODE];
    solve(x,k>>1);
    work(y,k>>1);
    for(int i = 0; i < matnum; ++i) x[i][i]++;//加上前面那一部分
    Mul(x,y);
    memcpy(res,tem,sizeof(tem));
    if(k&1)
    {
        solve(x,k);//缺少了一个a^k
        add(res,x);//res=res+x
        memcpy(res,tem,sizeof(tem));
    }
    memcpy(dst,res,sizeof(res));
}
ull inc(int k)
{
    ull r=1,t=CH;
    while(k)
    {
        if(k&1)  r=r*t;
        k>>=1;
        t=t*t;
    }
    return r;
}
ull cal(int n)//26^1+26^2+...+26^n
{
    if(n==1)  return CH;
    ull x=inc(n>>1)+1;//加上前面那些
    ull y=cal(n>>1);
    ull res=x*y;
    if(n&1)
    {
        res+=inc(n);
    }
    return res;
}
int main()
{
    int m,n;
    while(scanf("%d%d",&m,&n)!=EOF)
    {
        Input(m);
        AC();
        init();
        work(mat,n);
        ull res=cal(n);
        for(int i = 0; i < matnum; ++i)
            res -= mat[0][i];
        printf("%I64u\n",res);
    }
    return 0;
}