hdu 2243 AC自动机+矩阵快速幂

考研路茫茫——单词情结

题意：这题和poj2778没有本质区别，都是通过AC自动机得到递推矩阵，然后矩阵快速幂。递推的状态都是长度和单词结尾在trie树上的位置（最长公共字串，trie上是前缀，在递推的单词上则是后缀）。但这题会多些线性代数的技巧，例如求26^1+……+26^n要用二阶矩阵，还要用长度恰好为l的矩阵去构造长度小于等于l的递推矩阵。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;

#define pb push_back
#define ull unsigned long long
struct node {
    int son[26],fail;
    bool flag;
    node(){memset(son,0,sizeof(son));}
    node(bool f):flag(f){memset(son,0,sizeof(son));}
};
vector<node> ac;
int hash[256];
struct matrix {
    int n;
    ull a[101][101];
    matrix(){clear();}
    matrix(int _n):n(_n) {memset(a,0,sizeof(a));}
    void set(ull p) {
        for(int i=0;i<n;++i)
                a[i][i]=p;
    }
    matrix operator*(const matrix &p) const{
        matrix res(n);
        for(int i=0;i<n;++i)
            for(int j=0;j<n;++j) {
                for(int k=0;k<n;++k)
                    res.a[i][j]+=a[i][k]*p.a[k][j];
            }
        return res;
    }
    ull sum() const{
        ull res=0;
        for(int i=0;i<n/2;++i)
                res+=a[n>>1][i];
        return res;
    }
    ull sum1() const{
        ull res=0;
        for(int i=0;i<n;++i)
            for(int j=0;j<n;++j)
                res+=a[i][j];
        return res;
    }
    void clear() {memset(a,0,sizeof(a));n=0;}
    void resize(int p) {clear();n=p;}
    int size() const {return n;}
    void print() const {
        for(int i=0;i<n;++i) {
            for(int j=0;j<n;++j)
                cout << a[i][j] << " ";
            cout << endl;
        }
    }
}dp;

void insert(char *str) {
    int p=0,i=0;
    while(str[p]) {
        if(ac[i].flag) break;//危险节点后不用再加儿子
        if(!ac[i].son[hash[str[p]]]) {
            ac[i].son[hash[str[p]]]=ac.size();
            ac.pb(node(false));
        }
        i=ac[i].son[hash[str[p]]];
        p++;
    }
    ac[i].flag=true;
}

void getFail() {
    ac[0].fail=-1;
    queue<int> qu;
    qu.push(0);
    while(!qu.empty()) {
        int cur=qu.front();qu.pop();
        if(ac[cur].flag) continue;
        for(int i=0;i<26;++i) {
            int nex=ac[cur].son[i];
            if(nex) {
                qu.push(nex);
                int p=ac[cur].fail;
                while(~p&&!ac[p].son[i]) p=ac[p].fail;
                if(~p) ac[nex].fail=ac[p].son[i],ac[nex].flag|=ac[ac[nex].fail].flag;//若fail指向的节点是危险节点,则nex包含危险节点,不用计入答案
                else ac[nex].fail=0;
            }
            if(nex&&!ac[nex].flag) ++dp.a[cur][nex];
            else if(!nex) {
                int p=ac[cur].fail;
                while(~p&&!ac[p].son[i]) p=ac[p].fail;//遇到第一个匹配点就应跳出,而不是碰到匹配的危险节点后继续往上走,这相当于掩耳盗铃
                if(~p&&!ac[ac[p].son[i]].flag) ++dp.a[cur][ac[p].son[i]];//如果fail指向的节点是危险节点,就不应计入答案
                else if(!~p) ++dp.a[cur][0];
            }
        }
    }
}

matrix qpow(int p,matrix tmp) {
    matrix res(tmp.size());
    res.set(1);
    while(p) {
        if(p&1) res=res*tmp;
        tmp=tmp*tmp;
        p>>=1;
    }
    return res;
}

matrix getDp1(const matrix &dp) {
    matrix res(dp.size()<<1);
    res.set(1);
    for(int i=dp.size();i<dp.size()*2;++i)
        for(int j=0;j<dp.size();++j)
            res.a[i][j]=res.a[i][j+dp.size()]=dp.a[i-dp.size()][j];
    return res;
}

int main() {
    ios::sync_with_stdio(false);
    for(int i=0;i<26;++i) hash['a'+i]=i;
    int m,n;
    matrix calcn(2);
    calcn.a[0][0]=calcn.a[1][0]=26;
    calcn.a[1][1]=1;
    while(~scanf("%d%d",&m,&n)) {
        ac.clear();
        ac.pb(node(false));
        char str[20];
        while(m--) {
            scanf("%s",str);
            insert(str);
        }
        dp.resize(ac.size());
        getFail();
        matrix dp1=getDp1(dp);
        cout << qpow(n,calcn).a[1][0] - qpow(n,dp1).sum()<< endl;
    }
    return 0;
}