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

考研路茫茫——单词情结

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 3952    Accepted Submission(s): 1150

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
   
   
   
   

  既然要找出包含这些串的有多少个，那就用总个数减去不包含的个数。

  poj2778是求出固定长度的串不包含给的串，方法是构造矩阵，mat[i][j]代表节点i走到节点j走一步的合法路径数，i和j应该是合法节点。矩阵n次方就是i到j走n步的合法路径数。把第一行求和得到从起点开始走n步的合法路径数。

  这道题要求长度从1到n的合法路径数的和，一个很棒的办法是在矩阵最后加一列，全是1，mat[i][sz]=1，0<=i<=sz，这样矩阵n次幂之后，mat[i][sz]就是从节点i出发长度从1到n-1的路径数的和+1。这个自己列一列，应该是挺明显的。

  不包含的个数后，还要求总个数。1+26+26^2...+26^L，相当于f[n]=f[n-1]*26+1，这个构造二维矩阵，同样快速幂解决。

  对2^26取模用unsigned long long 就好了，自动溢出。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>
#include<iostream>
#include<queue>
using namespace std;

typedef unsigned long long ULL;

const int MAXN=32;
const int MAXM=10;
const int MAXNODE=32;
const int LOGMAXN=50;
const int INF=0x3f3f3f3f;
const int SIGMA_SIZE=26;

int N,L;

struct AC{
    int ch[MAXNODE][SIGMA_SIZE];
    int val[MAXNODE];
    int f[MAXNODE];
    int sz;

    void clear(){
        memset(ch[0],0,sizeof(ch[0]));
        val[0]=0;
        sz=1;
    }
    int idx(char c){
        return c-'a';
    }
    void insert(char* s,int v){
        int u=0;
        for(int i=0;s[i];i++){
            int c=idx(s[i]);
            if(!ch[u][c]){
                memset(ch[sz],0,sizeof(ch[sz]));
                val[sz]=0;
                ch[u][c]=sz++;
            }
            u=ch[u][c];
        }
        val[u]=v;
    }
    void get_fail(){
        queue<int> q;
        f[0]=0;
        for(int c=0;c<SIGMA_SIZE;c++){
            int u=ch[0][c];
            if(u){
                f[u]=0;
                q.push(u);
            }
        }
        while(!q.empty()){
            int r=q.front();
            q.pop();
            for(int c=0;c<SIGMA_SIZE;c++){
                int u=ch[r][c];
                if(!u){
                    ch[r][c]=ch[f[r]][c];
                    continue;
                }
                q.push(u);
                f[u]=ch[f[r]][c];
                val[u]|=val[f[u]];
            }
        }
    }
}ac;

struct Mat{
    ULL mat[MAXN][MAXN];
    Mat(){
        memset(mat,0,sizeof(mat));
    }
};
Mat operator * (const Mat& a,const Mat& b){
    int sz=ac.sz+1;
    Mat ret;
    for(int k=0;k<sz;k++)
        for(int i=0;i<sz;i++){
            if(a.mat[i][k]==0) continue;
            for(int j=0;j<sz;j++) ret.mat[i][j]+=a.mat[i][k]*b.mat[k][j];
        }
    return ret;
}
Mat operator ^ (const Mat& a,int n){
    Mat ret,t=a;
    int sz=ac.sz+1;
    for(int i=0;i<sz;i++)
        for(int j=0;j<sz;j++) ret.mat[i][j]=(i==j);
    while(n){
        if(n&1) ret=ret*t;
        t=t*t;
        n>>=1;
    }
    return ret;
}

Mat get_mat(){
    Mat ret;
    for(int u=0;u<ac.sz;u++)
        for(int c=0;c<SIGMA_SIZE;c++) if(!ac.val[u]&&!ac.val[ac.ch[u][c]]){
            ret.mat[u][ac.ch[u][c]]++;
        }
    for(int i=0;i<=ac.sz;i++) ret.mat[i][ac.sz]=1;
    return ret;
}
Mat get_mat2(){
    Mat ret;
    ret.mat[0][0]=26;
    ret.mat[0][1]=1;
    ret.mat[1][0]=0;
    ret.mat[1][1]=1;
    return ret;
}

char str[MAXM];

int main(){
    freopen("in.txt","r",stdin);
    while(scanf("%d%d",&N,&L)!=EOF){
        ac.clear();
        for(int i=1;i<=N;i++){
            scanf("%s",str);
            ac.insert(str,i);
        }
        ac.get_fail();
        Mat tmp=get_mat();
        tmp=tmp^L;
        Mat tmp2=get_mat2();
        tmp2=tmp2^L;
        ULL ans=tmp2.mat[0][0]+tmp2.mat[0][1];
        for(int i=0;i<=ac.sz;i++) ans-=tmp.mat[0][i];
        cout<<ans<<endl;
    }
    return 0;
}