HDU2243 考研路茫茫——单词情结

考研路茫茫——单词情结

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

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

 
分析：和poj2778很相似，poj2778求的是不包含的，这里要求求包含的，所以用总数减去不包含的就是包含的了，这里要求模2的64次方，直接用unsigned  __int64就可以了，这个越界了相当于自动取模2的64次方,再根据矩阵乘法的特性，计算就是。。。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
#define LL unsigned __int64
struct node
{
    node *fail;
    node *next[26];
    node *jump[26];
    int cnt;
};
node root[33];
queue<node *> q;
int num,n,m;
char s[10];
void insert(char *str)  //插入字符
{
    int i=0,index;
    node *p=root;
    while(str[i])
    {
        index=str[i]-'a';
        if(p->next[index]==NULL)
        {
            p->next[index]=root+num;
            memset(root+num,0,sizeof(struct node));
            num++;
        }
        p=p->next[index];
        i++;
    }
    p->cnt=1;   //每个字符串的结尾cnt为1
}
void build_ac_autuomation()
{
    int i;
    q.push(root);
    root->fail=NULL;
    while(!q.empty())
    {
        node *temp=q.front();
        q.pop();
        for(i=0;i<26;i++)
        {
            node *p=temp->fail; //p是temp沿失败指针返回的位置
            while(p!=NULL&&p->next[i]==NULL)    //返回的位置后面没有节点了，再沿他的失败指针返回
                p=p->fail;
            if(temp->next[i]!=NULL)
            {
                if(p==NULL) //p为空，连到根节点
                    temp->next[i]->fail=root;
                else
                {
                    temp->next[i]->fail=p->next[i]; //不为空，相同的字符连起来
                    if(p->next[i]->cnt) //fail指针指向的危险，所以原节点危险，fail代表从根节点到这个节点的最长后缀
                        temp->next[i]->cnt=1;
                }
                q.push(temp->next[i]);
                temp->jump[i]=temp->next[i];
            }
            else
            {
                if(p==NULL)
                    temp->jump[i]=root; //失败指针指向的是空指针，就相当于指向根节点，所以这个节点跳转到根节点
                else
                    temp->jump[i]=p->next[i];   //不为空，跳转到失败指针指向的那个节点
            }
        }
    }
}
//下面是关于矩阵的运算
struct Matrix
{
    LL mat[26*2][26*2];
    void init()
    {
        for(int i=0;i<26*2;i++)
            for(int j=0;j<26*2;j++)
            mat[i][j]=0;
    }
};
int len;
Matrix e;
Matrix mul(Matrix a,Matrix b)
{
    Matrix res;
    int i,j,k;
    for(i=0;i<2*len;i++)
        for(j=0;j<2*len;j++)
    {
        res.mat[i][j]=0;
        for(k=0;k<2*len;k++)
            res.mat[i][j]+=a.mat[i][k]*b.mat[k][j];
    }
    return res;
}
LL solve(Matrix a,int k)
{
    Matrix b,ans=e;
    int i,j;
    b.init();
    for(i=0;i<len;i++)
        for(j=0;j<len;j++)
        b.mat[i][j]=a.mat[i][j];
    for(i=0;i<len;i++)
        for(j=len;j<2*len;j++)
        if(i+len==j)
        b.mat[i][j]=1;
    for(i=len;i<2*len;i++)
        for(j=len;j<2*len;j++)
        if(i==j)
        b.mat[i][j]=1;
    k++;
    while(k)
    {
        if(k&1)
            ans=mul(ans,b);
        b=mul(b,b);
        k/=2;
    }
    LL res=0;
    for(i=0;i<len;i++)
        res+=ans.mat[i][len];
    return res-1;
}
LL sum(LL a,int k)
{
    Matrix b,ans=e;
    b.init();
    b.mat[0][0]=26;
    b.mat[0][1]=1;
    b.mat[1][1]=1;
    b.mat[1][0]=0;
    k++;
    while(k)
    {
        if(k&1)
            ans=mul(ans,b);
        b=mul(b,b);
        k/=2;
    }
    return ans.mat[0][1]-1;
}
int main()
{
    int i,j,k;
    for(i=0;i<26*2;i++)
        for(j=0;j<26*2;j++)
        if(i==j)
            e.mat[i][j]=1;
    while(scanf("%d%d",&n,&m)==2)
    {
        num=1;
        memset(root,0,sizeof(struct node));
        for(i=0;i<n;i++)
        {
            scanf("%*c%s",s);
            insert(s);
        }
        build_ac_autuomation();
        int id=0,id1;
        Matrix res;
        for(i=0;i<num;i++)
        {
            if(root[i].cnt==0)  //节点本身不危险才进行判断
            {
                id1=0;
                for(j=0;j<num;j++)
                {
                    if(root[j].cnt==0)  //这个节点也不危险
                    {
                        LL count=0;
                        for(k=0;k<26;k++)   //查询j节点中有多少个节点能跳转到i;
                        {
                            if(root[j].jump[k]==root+i)
                                count++;
                        }
                        res.mat[id][id1]=count; //id同i节点，id1同j节点
                        id1++;
                    }
                }
                id++;
            }
        }
        len=id;
        LL all=sum(26,m);   //计算m长度总共有多少种序列，26^1+26^2+.....+26^m;
        LL left=solve(res,m);   //计算不包含的序列总数
        all-=left;
        printf("%I64u\n",all);
    }
    return 0;
}