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;
}