AC自动机初探

AC自动机

AC自动机是$kmp$和$Trie$的结合，它处理了单串匹配多模式串的问题。
之所以这么因为它引入了$fail$指针处理相同后缀的信息，利用$Trie$处理多模式串的问题。

从Trie的0结点开始往外延伸，对于每个结点都有自己的指针指向自己的后缀。
后缀一定是小于自己的长度的，所以后缀的后缀事先应该是处理好的。
先把所有模式串插入，再求fail指针，由于上述的性质，我们求解的时候可以用bfs去扩展。

在最后处理的时候，每次匹配到需要同时处理后缀，匹配不到，就一直跳后缀fail直到跳到下一个可以匹配的地方，最终是指向开头0的。

我们可以进行两处优化:

Trie图优化：

每次处理到不能匹配的时候，我们可以直接令其指向其后缀的下一个此结点，如果还是不可以的话，后缀肯定是先处理过的，所以可以以线性方式指回去。类似于并查集的那种路径压缩方式。

last优化：

每次处理这个点匹配不到过后指向的单词结点，而不是一个一个去看是否是单词结点。处理方式就是：
对于这个结点直接跳到自己后缀的last指针，自然是个递归过程，前面的一定是求出来的。

理解了这些还是很简单的。

代码：

const int maxn = 2000050;
const int sigma_size = 26;
char ss[maxn],tt[maxn];
int num[100050];

struct ACauto{
    int sz;
    int ch[maxn][sigma_size];
    int f[maxn],last[maxn],val[maxn],cnt[maxn];//cnt统计模板匹配数
    void init(){
        sz=1;
        memset(ch[0],0,sizeof(ch[0]));
        memset(cnt,0,sizeof(cnt));
    }

    int idx(char c){return c-'a';}

    void insert(char *s,int x){
        int u=0,len=strlen(s);
        for(int i=0;i<len;i++){
            int c=idx(s[i]);
            if(!ch[u][c]){
                memset(ch[sz],0,sizeof(ch[sz]));
                val[sz]=0;
                ch[u][c]=sz++;
            }
            u=ch[u][c];
        }
        if(!val[u])num[x]=val[u]=x;
        else num[x]=val[u];
    }

    void slove(int x){
        for(int j=x;j;j=last[j]){
            cnt[val[j]]++;
        }
    }

    void getFail(){
        queue<int>q;
        f[0]=0;
        for(int c=0;c<sigma_size;c++){
            int u=ch[0][c];
            if(u){f[u]=0;q.push(u);last[u]=0;}
        }
        while(!q.empty()){
            int r=q.front();q.pop();
            for(int c=0;c<sigma_size;c++){
                int u=ch[r][c];
                if(!u){
                    ch[r][c]=ch[f[r]][c];
                    continue;
                }
                q.push(u);
                f[u]=ch[f[r]][c];
                last[u]=val[f[u]]?f[u]:last[f[u]];
            }
        }
    }

    void query(char *T){
        int len=strlen(T);
        int j=0;
        for(int i=0;i<len;i++){
            int c=idx(T[i]);
            j=ch[j][c];
            if(val[j])slove(j);
            else if(last[j])slove(last[j]);
        }
    }
}ac;