HDU 2243 考研路茫茫——单词情结 AC自动机 + 矩阵快速幂

最新推荐文章于 2020-01-27 10:07:07 发布

SolarDomo

最新推荐文章于 2020-01-27 10:07:07 发布

阅读量520

点赞数

CC 4.0 BY-SA版权

分类专栏： ----------- 算法 ---------- 字符串 -------- AC自动机字符串

本文链接：https://blog.youkuaiyun.com/SolarDomo/article/details/52199128

----------- 算法 ---------- 同时被 3 个专栏收录

138 篇文章

订阅专栏

字符串

35 篇文章

订阅专栏

字符串 -------- AC自动机

8 篇文章

订阅专栏

本文介绍了一种结合AC自动机与矩阵快速幂的方法来高效解决字符串匹配问题及求解特定模式出现次数的问题。文章详细展示了如何构建AC自动机，并通过矩阵运算加速求解过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目链接： http://acm.hdu.edu.cn/showproblem.php?pid=2243

代码：

#include <cstdio>
#include <iostream>
#include <cstring>
#include <queue>
#define sf scanf
#define pf printf
//#define LOCAL
using namespace std;
typedef unsigned long long int LL;
const int maxn = 111;
struct Matrix{
    LL C[maxn][maxn];
    int n;
};
Matrix operator*(Matrix a,Matrix b){
    Matrix ret;
    memset(ret.C,0,sizeof(ret.C));
    ret.n = a.n;
    for(int i = 1;i <= a.n;++i){
        for(int j = 1;j <= a.n;++j){
            for(int k = 1;k <= a.n;++k){
                ret.C[i][j] += a.C[i][k] * b.C[k][j];
            }
        }
    }
    return ret;
}

Matrix operator^(Matrix a,LL n){
    Matrix ret;
    ret.n = a.n;
    for(int i = 1;i <= ret.n;++i){
        for(int j = 1;j <= ret.n;++j){
            ret.C[i][j] = (i == j);
        }
    }

    while(n){
        if(n & 1){
            ret = ret * a;
            n--;
        }
        a = a * a;
        n >>= 1;
    }
    return ret;
}
namespace AcAutomation {
const int sigma_size = 26;
const int maxnode = 100;
struct AcTrie {
    int ch[maxnode][sigma_size];
    int value[maxnode];
    int fail[maxn];
    int sz;
    void Init(){
        sz = 1;
        memset(ch[0],0,sizeof(ch[0]));
        value[0] = 0;
        fail[0] = -1;
    }
    int IDX(char c){
        return c - 'a';
    }
    void Insert(char* s,int v){             //插入模式串
        int cur = 0;
        while(*s){
            int idx = IDX(*s);
            if(!ch[cur][idx]){
                memset(ch[sz],0,sizeof(ch[sz]));
                value[sz] = 0;
                ch[cur][idx] = sz++;
            }
            cur = ch[cur][idx];
            s++;
        }
        value[cur] = v;
    }

    void GetFail(){                         //得到Fail指针
        queue<int> Q;
        int f,cur;

        Q.push(0);
        while( !Q.empty() ){
            cur = Q.front();Q.pop();
            for(int i = 0;i < sigma_size;++i){
                if(ch[cur][i]){
                    f = fail[cur];
                    while(f != -1 && !ch[f][i]) f = fail[f];
                    fail[ch[cur][i]] = (f != -1) ? ch[f][i] : 0;
                    Q.push(ch[cur][i]);
                    value[ch[cur][i]] = value[ch[cur][i]] | value[fail[ch[cur][i]]] | value[cur];
                }
            }
        }
    }

    void Search(int cur,Matrix& Met){                                   //构建矩阵
        for(int i = 0;i < sigma_size;++i){
            if(ch[cur][i] && !value[ch[cur][i]]){
                Met.C[cur + 1][ch[cur][i] + 1]++;
                Search(ch[cur][i],Met);
            }
            else if(!ch[cur][i]){
                int f = fail[cur];
                while( f != -1 && !ch[f][i] ) {f = fail[f];}
                if(f != -1){
                    if(!value[ch[f][i]]) Met.C[cur + 1][ch[f][i] + 1]++;
                }
                else Met.C[cur + 1][1]++;
            }
        }
    }

};
}

LL get_Total(LL n){
    Matrix M;
    M.n = 2;
    M.C[1][1] = 26;
    M.C[1][2] = 1;
    M.C[2][1] = 0;
    M.C[2][2] = 1;

    M = M ^ n;
    LL ret = M.C[1][1]  + M.C[1][2];
    return ret;
}
AcAutomation::AcTrie Trie;
int main() {
#ifdef LOCAL
    freopen("read.txt","r",stdin);
#endif // LOCAL

    int n,m;
    char word[15];
    while( ~sf("%d%d",&n,&m) ){
        Trie.Init();
        for(int i = 0;i < n;++i){
            sf("%s",word);
            Trie.Insert(word,1);
        }
        Trie.GetFail();
        Matrix met;
        memset(met.C,0,sizeof(met.C));
        met.n = Trie.sz;
        Trie.Search(0,met);
        for(int i = 1;i <= met.n;++i){
            if(!Trie.value[i - 1]) met.C[i][met.n + 1]++;
        }met.C[met.n + 1][met.n + 1]++;
        met.n++;
        met = met ^ m;
        LL ret = 0;
        for(int i = 1;i <= met.n;++i) ret += met.C[1][i];
        pf("%I64u\n",get_Total(m) - ret);
    }
    return 0;
}