AC自动机

AC自动机

---

AC自动机

• 概念 ：
  • 用于多模式串与文本串匹配，也是字符串匹配算法之一。
  • 方法就是把模板建成一个大的状态转移图，相当于Trie树 + KMP。
• 理解 ：
  • 匹配方法：用模板串建立Trie树，给每个节点加上失配边也就是fail标记（用于失配后的转移，类似KMP中的next[ ]数组）。最后用文本串去匹配，一旦失配转移到fail标记的位置继续匹配。
  • fail指针的理解：
    1. 在Trie树中，每一个节点记录了从root到该节点的字符串，因为fail是为失配后的转移准备的，所以在给每个点确定fail指针指向时，我们就当在该节点失配了。
    2. 假设当前考虑的点为x。在匹配完 x 后失配了我们到底要将匹配位置转移到哪里呢？在考虑这个问题时我们不要忘了我们加上fail指针的目的，不加的话就相当于一段一段的匹配复杂度很高，所以我们是为了像KMP那样减少重复才加上fail指针的。
    3. x点的fail指针指向其在trie树上存在的最长后缀上。为什么这样：因为当失配时最长后缀一定已经匹配完了，所以移动到最长后缀下一个位置，也就是fail指针所指下一个位置，这样就相当于继续顺着原位置继续匹配文本串。没有重复匹配已经匹配好的字符。
• 实现步骤：
  1. Trie树部分：net[26] :记录每个节点子节点有哪些字符，cnt:记录到这个点有多少个点结束，从第一个模板串开始建树，扫描每个字符，在trie树上从root开始与每个字符比较，如果有这个字符就移动到这个字符继续在其子树上考虑要不要加模板串剩下的字符。如果这个字符在树上这个点的子节点上没有就加上然后转移到这个新的点继续添加后面的点。
  2. fail指针部分：(BFS) 开一个队列将root放进去然后扫描子节点，对每个子节点，如果子节点是连接在root上的就直接标记fail为0,若是其他节点就沿着其父亲的fail指针所指节点移动，直到fail=-1，标记为0或找到某个点子节点有x节点的字符，就将x的fail标记为这个子节点。如果找不到就标记为0.
• 代码：(模板题：HDU 2222）

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>

using namespace std;
typedef long long ll;
const int MA=1e6+5;

//AC自动机
struct Aho{
    struct state{
       int net[26];
       int fail,cnt;// 失配指针，到这个点有多少个点结束
    }stateTable[MA];

    int ac_size;

    queue<int> que;

    //初始化
    void init()
    {
        while(que.size()) que.pop();

        for(int i = 0; i < MA; ++ i){
            memset(stateTable[i].net, 0, sizeof(stateTable[i].net));
            stateTable[i].fail = stateTable[i].cnt=0;
        }
        ac_size = 1;
    }

    //建立trie树
    void ac_insert(char *S)
    {
        int n = strlen(S);
        int now = 0;

        for(int i=0;i<n;++i){
            int si=S[i] - 'a';
            if(!stateTable[now].net[si])
                stateTable[now].net[si] = ac_size++;
            now = stateTable[now].net[si];
        }
        stateTable[now].cnt++;
    }
    //建立fail指针
    void ac_build()
    {
        stateTable[0].fail=-1;
        que.push(0);

        while(que.size()){
            int u = que.front();
            que.pop();

            for(int i = 0; i < 26; ++ i){
                if(stateTable[u].net[i]){
                    if(u == 0) stateTable[stateTable[u].net[i]].fail = 0;
                    else{
                        int v = stateTable[u].fail;
                        while(v != -1){
                            if(stateTable[v].net[i]){
                               stateTable[stateTable[u].net[i]].fail = stateTable[v].net[i];
                               break;
                            }
                            v = stateTable[v].fail;
                        }
                        if(v == -1)stateTable[stateTable[u].net[i]].fail = 0;
                    }
                    que.push(stateTable[u].net[i]);
                }
            }
        }
    }

    //
    int ac_get(int u)
    {
        int res=0;
        while(u){
            res+=stateTable[u].cnt;
            stateTable[u].cnt=0;
            u=stateTable[u].fail;
        }
        return res;
    }

    //计算
    int ac_match(char *S)
    {
        int n =strlen(S);
        int res = 0, now = 0;
        for(int i=0;i<n;++i){
            int si=S[i]-'a';
            if(stateTable[now].net[si])
                now=stateTable[now].net[si];
            else{
                int p=stateTable[now].fail;
                while(p!=-1&&!stateTable[p].net[si])p = stateTable[p].fail;
                if(p==-1) now=0;
                else now=stateTable[p].net[si];
            }
            if(stateTable[now].cnt)
                res+=ac_get(now);
        }
        return res;
    }
}aho;
int T,N;

char s[MA];

int main()
{
    scanf("%d",&T);
    while(T--){
        aho.init();
        scanf("%d",&N);
        for(int i=0;i<N;++i){
            scanf("%s",s);
            aho.ac_insert(s);
        }

        aho.ac_build();

        scanf("%s",s);
        printf("%d\n",aho.ac_match(s));

    }
    return 0;
}