HDOJ 2243 考研路茫茫——单词情结（自动机DP+矩阵快速幂和）

题意：给出N个词根，求长不超过L的且至少包含一个上述词根的单词的个数。

数据范围：0<N<6，0<L<2^31

这题与上一题差不多，但比上题要繁琐的多，关键的区别在于"不超过L" 和"至少包含一个"

因为"至少包含一个"，所以刚好是求上一题的反面；

因为"不超过L"，所以要求的是矩阵幂和S = A + A² + A³ + … + A^k

View Code

#include <stdio.h>

#include <string.h>

#include <queue>

#include <math.h>

using namespace std;



#define N 6

#define LEN 6

#define SIZE (N*LEN)

typedef unsigned __int64 LL;

int n,l,node;

int next[SIZE][26];

int fail[SIZE];

bool isend[SIZE];



LL mat[SIZE][SIZE];

LL ans[SIZE][SIZE];



void mat_add(LL a[][SIZE],LL b[][SIZE])

{

    for(int i=0;i<node;i++)

    {

        for(int j=0;j<node;j++) a[i][j]+=b[i][j];

    }

}

void mat_mul(LL a[][SIZE],LL b[][SIZE])

{

    LL tmp[SIZE][SIZE];

    for(int i=0;i<node;i++)

    {

        for(int j=0;j<node;j++)

        {

            tmp[i][j]=0;

            for(int k=0;k<node;k++) tmp[i][j]+=a[i][k]*b[k][j];

        }

    }

    memcpy(a,tmp,sizeof(mat));

}

void mat_pow(LL a[][SIZE],LL b[][SIZE],int k)

{

    memset(a,0,sizeof(mat));

    for(int i=0;i<node;i++) a[i][i]=1;



    LL mm[SIZE][SIZE];

    memcpy(mm,b,sizeof(mat));

    while(k)

    {

        if(k&1)

        {

            mat_mul(a,mm);

        }

        k>>=1;

        mat_mul(mm,mm);

    }

}

void pow_sum(LL a[][SIZE],LL b[][SIZE],int k)

{

    if(k==1)

    {

        memcpy(a,b,sizeof(mat));

        return;

    }

    LL c[SIZE][SIZE],d[SIZE][SIZE];

    pow_sum(a,b,k>>1);

    memcpy(d,a,sizeof(mat));

    mat_pow(c,b,k>>1);

    mat_mul(a,c);

    mat_add(a,d);

    if(k&1)

    {

        mat_mul(c,c);

        mat_mul(c,b);

        mat_add(a,c);

    }

}

void init()

{

    node=1;

    memset(next[0],0,sizeof(next[0]));

}

void add(int cur,int k)

{

    memset(next[node],0,sizeof(next[node]));

    isend[node]=0;

    next[cur][k]=node++;

}

void insert(char *s)

{

    int i,cur,k;

    for(i=cur=0;s[i];i++)

    {

        k=s[i]-'a';

        if(!next[cur][k])   add(cur,k);

        cur=next[cur][k];

    }

    isend[cur]=1;

}

void get_fail()

{

    queue<int>q;

    int cur,nxt,tmp;



    fail[0]=0;

    q.push(0);



    while(!q.empty())

    {

        cur=q.front(),q.pop();

        for(int k=0;k<26;k++)

        {

            nxt=next[cur][k];

            if(nxt)

            {

                if(!cur)    fail[nxt]=0;

                else

                {

                    for(tmp=fail[cur];tmp && !next[tmp][k];tmp=fail[tmp]);

                    fail[nxt]=next[tmp][k];

                }

                if(isend[fail[nxt]]) isend[nxt]=1;

                q.push(nxt);

            }

            else    next[cur][k]=next[fail[cur]][k];

        }

    }

}

void get_mat()

{

    memset(mat,0,sizeof(mat));

    for(int i=0;i<node;i++)

    {

        if(isend[i])    continue;

        for(int k=0;k<26;k++)

        {

            int j=next[i][k];

            if(!isend[j])   mat[i][j]++;

        }

    }

}

void solve()

{

    get_fail();

    get_mat();



    pow_sum(ans,mat,l);

    LL ret=0;

    for(int i=0;i<node;i++) ret-=ans[0][i];



    mat[0][0]=26;

    node=1;

    pow_sum(ans,mat,l);

    ret+=ans[0][0];

    printf("%I64u\n",ret);

}

int main()

{

    char s[LEN];

    while(~scanf("%d%d",&n,&l))

    {

        init();

        for(int i=0;i<n;i++)

        {

            scanf("%s",s);

            insert(s);

        }

        solve();

    }

    return 0;

}