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

题意

中文题，不解释

题解

这道题其实和POJ 2778是一样的，只是需要对矩阵有着更深刻的理解而已。我们很容易便能像POJ 2778一样求出来不包含条件字符串的字符串方案。只是题目中要求长度小于等于L，所以我们可以在矩阵中手动加一个点，这个点允许从任何状态转移而来。这点的意义表示字符串终止。也就是说如果字符串转移到这个点时候小于L，那么字符串最终长度小于L。求出来小于等于L，不包含条件字符串的方案数以后，只要求出来总方案数就可以解决问题。
总方案数递推公式很容易求出来。f[n]=26*f[n-1]+1。（+1表示上一位终止，26表示补充一个字符）如果递推去求，超时是必然的。这时候又要用到矩阵的性质，将递推公式转化为矩阵。因为递推公式里有两项，所以矩阵就转化为一个二维矩阵。[26,1;0,1]^n[f(0),1]。利用矩阵快速幂搞出来，减去不包含条件字符串的方案数就可以了。

代码

#include <iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<vector>
#include<cmath>
#include<queue>
#include<string>
#include<set>
#include<map>
#include<bitset>
#include<stack>
#define UP(i,l,h) for(int i=l;i<h;i++)
#define DOWN(i,h,l) for(int i=h-1;i>=l;i--)
#define W(a) while(a)
#define MEM(a,b) memset(a,b,sizeof(a))
#define INF 0x3f3f3f3f3f3f3f3f
#define LL long long
#define ULL unsigned long long
#define MAXN 10000
#define EPS 1e-10
#define MOD 100000
#define N 26

using namespace std;

typedef unsigned LL MATRIX[35][35];
int ch[35][26];
char st[35];
int sz;
int val[35],f[35];
MATRIX a,ans,temp;
void insert() {
    int len=strlen(st);
    int u=0;
    UP(i,0,len) {
        int x=st[i]-'a';
        if(!ch[u][x]) {
            val[sz]=0;
            ch[u][x]=sz++;
        }
        u=ch[u][x];
    }
    val[u]=1;
}

void getFail() {
    MEM(f,0);
    queue<int> q;
    UP(i,0,26) {
        if(ch[0][i]) {
            q.push(ch[0][i]);
        }
    }
    W(!q.empty()) {
        int r=q.front();
        q.pop();
        UP(x,0,26) {
            int u=ch[r][x];
            if(!u) {
                ch[r][x]=ch[f[r]][x];
                continue;
            }
            q.push(u);
            int v=f[r];
            f[u]=ch[v][x];
            if(val[f[u]]) {
                val[u]=1;
            }
        }
    }
}

void buildMatrix() {
    MEM(a,0);
    UP(i,0,sz) {
        UP(j,0,26) {
//            cout<<val[i]<<" "<<i<<endl;
            if(val[i]||val[ch[i][j]])
                continue;
            a[i][ch[i][j]]++;
        }
    }
    UP(i,0,sz+1) {
        a[i][sz]=1;
    }
}

void matrixMulti(MATRIX a,MATRIX b) {
    MEM(temp,0);
    UP(i,0,sz+1) {
        UP(j,0,sz+1) {
            UP(k,0,sz+1) {
                temp[i][j]+=a[i][k]*b[k][j];
            }
        }
    }
    memcpy(a,temp,sizeof(temp));
}

void quick(int n) {
    MEM(ans,0);
    UP(i,0,sz+1) {
        ans[i][i]=1;
    }
    W(n) {
        if(n&1) {
            matrixMulti(ans,a);
        }
        matrixMulti(a,a);
        n>>=1;
    }
}

int main() {
    int n,l;
    W(~scanf("%d%d",&n,&l)) {
        sz=1;
        MEM(ch,0);
        MEM(val,0);
        W(n--) {
            scanf("%s",st);
            insert();
        }
        getFail();
        buildMatrix();
        int k=0;
        UP(i,0,sz){
            UP(j,0,sz){
                if(a[i][j]>0)
                    k++;
            }
        }
        quick(l);
        ULL ansNum=0;
        UP(i,0,sz+1) {
            ansNum+=ans[0][i];
        }
        MEM(a,0);
        a[0][0]=26;
        a[0][1]=a[1][1]=1;
        quick(l);
        printf("%I64u\n",(ans[0][0]+ans[0][1]-ansNum));
    }
}