HDOJ 2243 考研路茫茫——单词情结

AC自动机+矩阵快速幂+递归求和.....

从反面考虑,不含有任何词根的单词数可以用AC自动机构建矩阵求出.....所有单词数-不含有任何词根的单词数就是答案.

考研路茫茫——单词情结

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

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
  
  

 

Author

linle

 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;

typedef unsigned long long int uLL;
typedef long long int LL;

#pragma comment(linker, "/STACK:102400000,102400000")

/************ac_****************/

const int maxn=55;
int ch[maxn][26],fail[maxn],end[maxn];
int root,sz;
char str[maxn];

int N;
LL L;

int newnode()
{
    memset(ch[sz],-1,sizeof(ch[sz]));
    end[sz++]=0;
    return sz-1;
}

void ac_init()
{
    sz=0;
    root=newnode();
}

void ac_insert(char str[])
{
    int len=strlen(str);
    int now=root;
    for(int i=0;i<len;i++)
    {
        if(ch[now][str[i]-'a']==-1)
            ch[now][str[i]-'a']=newnode();
        now=ch[now][str[i]-'a'];
    }
    end[now]++;
}

void ac_build()
{
    queue<int> q;
    fail[root]=root;
    for(int i=0;i<26;i++)
    {
        if(ch[root][i]==-1)
            ch[root][i]=root;
        else
        {
            fail[ch[root][i]]=root;
            q.push(ch[root][i]);
        }
    }
    while(!q.empty())
    {
        int now=q.front(); q.pop();
        if(end[fail[now]]) end[now]++;
        for(int i=0;i<26;i++)
        {
            if(ch[now][i]==-1)
                ch[now][i]=ch[fail[now]][i];
            else
            {
                fail[ch[now][i]]=ch[fail[now]][i];
                q.push(ch[now][i]);
            }
        }
    }
}

/***********MATRIX***************/

struct MARTRIX
{
    int n;
    uLL martrix[maxn][maxn];

    MARTRIX(int x)
    {
        n=x; memset(martrix,0,sizeof(martrix));
    }

    void getONE()
    {
        for(int i=0;i<n;i++)
            martrix[i][i]=1LL;
    }

    MARTRIX operator * (const MARTRIX & b ) const
    {
        MARTRIX ret(n);
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                uLL temp=0;
                for(int k=0;k<n;k++)
                {
                    temp+=martrix[i][k]*b.martrix[k][j];
                }
                ret.martrix[i][j]=temp;
            }
        }
        return ret;
    }

    MARTRIX operator + (const MARTRIX & b ) const
    {
        MARTRIX ret(n);
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                ret.martrix[i][j]=martrix[i][j]+b.martrix[i][j];
            }
        }
        return ret;
    }
};

/***************QuickPow********************/

uLL QuickPOW26(LL k)
{
    uLL ts=26,e=1;
    while(k)
    {
        if(k&1) e=e*ts;
        ts=ts*ts;
        k>>=1LL;
    }
    return e;
}

uLL getSUM26(LL L)
{
    if(L==1LL)
    {
        return 26LL;
    }
    LL half=L/2;
    if(L%2==0)
    {
        return getSUM26(half)*(1LL+QuickPOW26(half));
    }
    else
    {
        return getSUM26(half)*(1LL+QuickPOW26(half))+QuickPOW26(L);
    }
}

MARTRIX QuickPOWmatrix(MARTRIX mt,LL k)
{
    MARTRIX e(mt.n);
    e.getONE();

    while(k)
    {
        if(k&1) e=e*mt;
        mt=mt*mt;
        k>>=1LL;
    }

    return e;
}

MARTRIX getSUMmartrix(MARTRIX mt,LL k)
{
    if(k==1LL) return mt;
    LL half=k/2;
    MARTRIX halfmat=getSUMmartrix(mt,half);
    MARTRIX halfpow=QuickPOWmatrix(mt,half);

    if(k&1)
    {
        return halfmat+halfmat*halfpow+QuickPOWmatrix(mt,k);
    }
    else
    {
        return halfmat+halfmat*halfpow;
    }
}

int main()
{
    while(scanf("%d%I64u",&N,&L)!=EOF)
    {
        ac_init();
        for(int i=0;i<N;i++)
        {
            scanf("%s",str);
            ac_insert(str);
        }
        ac_build();

        MARTRIX mt(sz);
        for(int i=0;i<sz;i++)
        {
            if(end[i]) continue;
            for(int j=0;j<26;j++)
            {
                int p=ch[i][j];
                if(end[p]||end[fail[p]]) continue;
                mt.martrix[i][p]++;
            }
        }

        uLL all=getSUM26(L);

        MARTRIX RS=getSUMmartrix(mt,L);
        uLL jian=0;
        for(int i=0;i<sz;i++)
        {
            jian+=RS.martrix[0][i];
        }

        printf("%I64u\n",all-jian);
    }
    return 0;
}