hdu_2243 _考研路茫茫――单词情结 (AC自动机+矩阵快速幂+...)

传送门：http://acm.hdu.edu.cn/showproblem.php?pid=2243

考研路茫茫——单词情结

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

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，在搞定poj2778后这个题就迎刃而解了。假设已经会了Poj2778.那么这个题让求的是长度在L以内的字符包含至少一个模式串的方案数是多少。先看总的方案数是多少呢？长度为1的话有26种，长度为2的话有26^2,以此类推长度为L的有26^L种，那么长度L以内的有26+26^2+..+26^L（一个位置有26中放法）种。那么不满足条件的有多少呢？也就是求长度为L以内的有多少种方案使得不会有模式串出现。那么答案就是总的-不符合的。现在来求长度为L以内的不会有模式串出现的方案数。根据poj2778可以求出长度为L的不符合的，而这让求长度是L以内的。现在给出一个矩阵：

| A     1  |

| 0     1  |

看到上面这个矩阵，这个矩阵的平方和三次方是多少呢？

| A     1  |      | A     1  |      =>    | A^2    1+A  |   | A     1  |   =>   | A^3    1+A+A^2  | 

| 0     1  |      | 0     1  |       =>    | 0            1  |   | 0     1  |    =>   | 0                   1   | 

应该可以看出来这个矩阵的L+1次方后会得到1+A+A^2+A^3+...+A^L

那么现在就好说了，把A换成26就会得到26+26^2+..+26^L的和，把换成矩阵就会得到长度是L以内的不含模式串的方案数。当然求这个矩阵是用矩阵快速幂来求。

#include <bits/stdc++.h>

using namespace std;
typedef unsigned long long LL;

struct node
{
    int is,id;
    node *fail;
    node *nex[27];
};
char s[10];
node T[1000],*root;
int idx;
struct node* Init()
{
    node *p;
    p = &T[idx];
    p->fail = NULL;
    for(int i=0;i<26;i++)
        p->nex[i]=NULL;
    p->is = 0;
    p->id = idx++;
    return p;
};
void build(char *ss)
{
    int len = strlen(ss);
    node *p = root;
    for(int i=0;i<len;i++)
    {
        int x = ss[i] - 'a';
        if(p->nex[x]==NULL)
            p->nex[x] = Init();
        p = p->nex[x];
    }
    p->is = 1;
}
void getfail()
{
    queue<node*>q;
    q.push(root);
    node *p;
    while(!q.empty())
    {
        p = q.front();
        q.pop();
        for(int i=0;i<26;i++)
        {
            if(p->nex[i]==NULL)
            {
                if(p==root)
                {
                    p->nex[i] = root;
                }
                else p->nex[i] = p->fail->nex[i];
            }
            else
            {
                if(p==root)
                {
                    p->nex[i]->fail = root;
                }
                else
                {
                    p->nex[i]->fail = p->fail->nex[i];
                    if(p->fail->nex[i]->is)
                        p->nex[i]->is = 1;
                }
                q.push(p->nex[i]);
            }
        }
    }
}
struct Matrix
{
    LL a[100][100];
    Matrix()
    {
        memset(a,0,sizeof(a));
    }
    void init()
    {
        for(int i=0;i<idx;i++)
            for(int j=0;j<idx;j++)
            a[i][j] = i==j;
    }
    Matrix operator + (const Matrix &B)const
    {
        Matrix C;
        for(int i=0;i<idx;i++)
        {
            for(int j=0;j<idx;j++)
            {
                C.a[i][j]=a[i][j]+B.a[i][j];
            }
        }
        return C;
    }
    Matrix operator * (const Matrix &B)const
    {
        Matrix C;
        for(int i=0;i<idx;i++)
        {
            for(int k=0;k<idx;k++)
            {
                for(int j=0;j<idx;j++)
                {
                    C.a[i][j]+=a[i][k]*B.a[k][j];
                }
            }
        }
        return C;
    }
    Matrix operator ^ (const LL &t)const
    {
        Matrix A=(*this),res;
        res.init();
        LL p = t;
        while(p)
        {
            if(p&1)res=res*A;
            A=A*A;
            p>>=1;
        }
        return res;
    }
};
int main()
{
    int n;
    LL L;
    while(~scanf("%d%llu",&n,&L))
    {
        idx = 0;
        root = Init();
        for(int i=1;i<=n;i++)
        {
            scanf("%s",s);
            build(s);
        }
        getfail();
        Matrix re,ans;
        for(int i=0;i<idx;i++)
        {
            for(int j=0;j<26;j++)
            {
                node *son = T[i].nex[j];
                if(!T[i].is&&!son->is)
                {
                    ans.a[i][son->id]++;
                }
            }
        }
        idx=idx+1;
        for(int i=0;i<idx;i++)
            ans.a[idx-1][i]=0;
        for(int i=0;i<idx;i++)
            ans.a[i][idx-1]=1;
        re = ans^(L+1);
        LL sum = 0,num = 0;
//        for(int i=0;i<idx-1;i++)
//        {
//            sum+=re.a[i][idx-1];
//        }
        sum = re.a[0][idx-1];
        Matrix dd,ff;
        idx = 2;
        dd.a[0][0]=26;
        dd.a[0][1]=1;
        dd.a[1][0]=0;
        dd.a[1][1]=1;
        ff = dd^(L+1);
        num = ff.a[0][1];
        //cout<<num<<" "<<sum<<endl;
        //cout<<26+26*26+26*26*26<<endl;
        LL MOD = 1;
        for(int i=1;i<=64;i++)MOD = MOD *2;
        num = (num+MOD)-sum;
        printf("%llu\n",num);
    }
    return 0;
}