HDU 2243 ac自动机

背单词，始终是复习英语的重要环节。在荒废了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^3 ， ...... 26^m-1 ，  26^m  . 

f(n) =  26^1 + 26^2 + 26^3 ....+26^n  . 

f(n) = f(n-1)  * 26 + 1 ;

-------------------------------------------------------------------

减去  含模式串的 情况。 为：

A^1 + A^2+....A^m .

的第一行的行和 。

那么构造  A 1 

                  0  1 

即可保存结果

----------------------------------------------------------------------

mod  2^64 这个用ULL 是相对于每次对2^64取余

typedef unsigned long long ULL ;

int     matn ;
struct  Mat{
        ULL x[108][108] ;
        Mat(){
             memset(x , 0 , sizeof(x)) ;
        }
        Mat(int){
             memset(x , 0 , sizeof(x)) ;
             for(int i = 0 ; i < matn ; i++)
                 x[i][i] = 1 ;
        }
};

Mat operator * (Mat a , Mat b){
        Mat s ;
        int n = matn  , i , j , k ;
        for(i = 0 ; i < n ; i++){
            for(j = 0 ; j < n ; j++){
                if(a.x[i][j] == 0) continue ;
                for(k = 0 ; k < n ; k++){
                     s.x[i][k] += a.x[i][j] * b.x[j][k] ;
                }
            }
        }
        return s ;
}

Mat  Pow(Mat x , int y){
     Mat s(1) ;
     for(; y ; y >>= 1){
          if(y & 1) s = s * x ;
          x = x * x ;
     }
     return s ;
}

/*AC-------------*/
const  int maxn = 30 ;
const  int kind = 26 ;
int    next[maxn][kind] ;
int    fail[maxn] ;
int    id[maxn]   ;

struct  AC{
        int  root , n ;
        int  newnode(){
             id[n] = 0 ;
             for(int i = 0 ; i < kind ; i++) next[n][i] = -1 ;
             return n++ ;
        }
        void  Init(){
              n = 0 ;
              root = newnode() ;
        }
        void  Insert(char *s){
              int now = root  , k ;
              while(*s){
                   k = *s - 'a' ;
                   if(next[now][k] == -1)
                       next[now][k] = newnode() ;
                   now = next[now][k] ;
                   s++ ;
              }
              id[now] = 1  ;
        }
        void  makeAc(){
              queue<int> q ;
              fail[root] = root ;
              int now , i ;
              for(i = 0 ; i < kind ; i++){
                   if(next[root][i] == -1)
                       next[root][i] = root ;
                   else{
                       fail[next[root][i]] =  root ;
                       q.push(next[root][i]) ;
                   }
              }
              while(! q.empty()){
                   now = q.front() ; q.pop() ;
                   if(id[fail[now]] == 1)  id[now] = 1 ;
                   for(i = 0 ; i < kind ; 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]) ;
                       }
                   }
              }
        }
        Mat  getMat(){
             matn = n+1 ;
             Mat s ;
             for(int i = 0 ; i < n ; i++){
                 for(int j = 0 ; j < kind ; j++){
                      if(id[next[i][j]] == 0){
                           s.x[i][next[i][j]]++ ;
                      }
                 }
             }
             for(int i = 0 ; i < matn ; i++) s.x[i][n] = 1 ;
             return s ;
        }
}ac ;
/*EndAc---------------*/

char  word[8] ;

int   main(){
      int t , n , i , j , m ;
      while(cin>>n>>m){
           ac.Init() ;
           for(i = 1 ; i <= n ; i++){
                scanf("%s" , word) ;
                ac.Insert(word) ;
           }
           ac.makeAc() ;
           Mat a = ac.getMat() ;
           a = Pow(a , m) ;
           ULL sum = 0 ;
           for(i = 0 ; i < matn ; i++)
               sum += a.x[0][i] ;
           sum-- ;
           ULL  ans = 0 ;
           matn = 2 ;
           Mat b ;
           b.x[0][0] = 26 , b.x[0][1] = 1 ;
           b.x[1][0] = 0  , b.x[1][1] = 1 ;
           b = Pow(b , m) ;
           for(i = 0 ; i < matn ; i++)
               ans += b.x[0][i] ;
           ans-- ;
           ans -= sum ;
           cout<<ans<<endl ;
      }
      return 0 ;
}