hdu2243 ac自動機+矩陣連乘

life4711發表於2015-04-30
矩陣

http://acm.hdu.edu.cn/showproblem.php?pid=2243

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





 





/***
hdu2243 ac自動機+矩陣連乘
題目大意：給定n個單詞，求長度不大於m的字串中所有含給定單詞的字串的個數
解題思路：利用ac自動機可以夠造出矩陣，矩陣的幾次冪就可以統計長度為多少的所有不含模式串的字串的個數。然後，矩陣加一列，並給該列的數全部賦1，
          就可以在轉移過程中統計出字首和（很巧妙的）。然後用總的個數減去所有不含模式串的就是所有含模式串的。總的個數求法見程式碼註釋。個數需要
          對2^64取餘，直接定義unsigned long long 讓其自然溢位就可以了
*/
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <queue>
#include <iostream>
using namespace std;
typedef unsigned long long ULL;
struct Matrix///構造矩陣
{
    ULL mat[40][40];
    int n;
    Matrix() {}
    Matrix(int _n)
    {
        n=_n;
        for(int i=0; i<n; i++)
        {
            for(int j=0; j<n; j++)
            {
                mat[i][j]=0;
            }
        }
    }
    Matrix operator *(const Matrix &b)const
    {
        Matrix ret=Matrix(n);
        for(int i=0; i<n; i++)
        {
            for(int j=0; j<n; j++)
            {
                for(int k=0; k<n; k++)
                {
                    ret.mat[i][j]+=mat[i][k]*b.mat[k][j];
                }
            }
        }
        return ret;
    }
};
ULL pow_m(ULL a,int n)///快速冪
{
    ULL ret=1;
    ULL tmp=a;
    while(n)
    {
        if(n&1)ret*=tmp;
        tmp*=tmp;
        n>>=1;
    }
    return ret;
}

Matrix pow_M(Matrix a,int n)///矩陣快速冪
{
    Matrix ret=Matrix(a.n);
    for(int i=0; i<a.n; i++)
    {
        ret.mat[i][i]=1;
    }
    Matrix tmp=a;
    while(n)
    {
        if(n&1)ret=ret*tmp;
        tmp=tmp*tmp;
        n>>=1;
    }
    return ret;
}

struct Trie
{
    int next[40][26],fail[40];
    bool end[40];
    int root,L;
    int newnode()
    {
        for(int i=0; i<26; i++)
            next[L][i]=-1;
        end[L++]=false;
        return L-1;
    }
    void init()
    {
        L=0;
        root=newnode();
    }
    void insert(char *buf)
    {
        int len=strlen(buf);
        int now=root;
        for(int i=0; i<len; i++)
        {
            if(next[now][buf[i]-'a']==-1)
                next[now][buf[i]-'a']=newnode();
            now=next[now][buf[i]-'a'];
        }
        end[now]=true;
    }
    void build()
    {
        queue<int>Q;
        fail[root]=root;
        for(int i=0; i<26; i++)
        {
            if(next[root][i]==-1)
            {
                next[root][i]=root;
            }
            else
            {
                fail[next[root][i]]=root;
                Q.push(next[root][i]);
            }
        }
        while(!Q.empty())
        {
            int now=Q.front();
            Q.pop();
            if(end[fail[now]])end[now]=true;
            for(int i=0; i<26; i++)
            {
                if(next[now][i]==-1)
                {
                    next[now][i]=next[fail[now]][i];
                }
                else
                {
                    fail[next[now][i]]=next[fail[now]][i];
                    Q.push(next[now][i]);
                }
            }
        }
    }
    Matrix getMatrix()///獲得狀態轉移矩陣，加一列，每次相乘可以求前面所有數的和mat[0][L+1]
    {
        Matrix ret=Matrix(L+1);
        for(int i=0; i<L; i++)
        {
            for(int j=0; j<26; j++)
            {
                if(end[next[i][j]]==false)
                    ret.mat[i][next[i][j]]++;
            }
        }
        for(int i=0; i<L+1; i++)
        {
            ret.mat[i][L]=1;
        }
        return ret;
    }
} ac;

char buf[10];
int main()
{
    int n,L;
    while(~scanf("%d%d",&n,&L))
    {
        ac.init();
        for(int i=0; i<n; i++)
        {
            scanf("%s",buf);
            ac.insert(buf);
        }
        ac.build();
        Matrix a=ac.getMatrix();
        a=pow_M(a,L);
        ULL res=0;
        for(int i=0; i<a.n; i++)
        {
            res+=a.mat[0][i];
        }
        res--;
        /*
         * f[n]=1 + 26^1 + 26^2 +...26^n
         * f[n]=26*f[n-1]+1
         * {f[n] 1} = {f[n-1] 1}[26 0;
                                  1 1]
         * 數是f[L]-1;
         * 此題的L<2^31.矩陣的冪不能是L+1次，否則就超時了
         */
        a=Matrix(2);
        a.mat[0][0]=26;
        a.mat[1][0]=a.mat[1][1]=1;
        a=pow_M(a,L);
        ULL ans=a.mat[1][0]+a.mat[0][0];
        ans--;
        ans-=res;
        cout << ans<<endl;
    }
    return 0;
}




            




相關文章