BZOJ Coci2015 Divljak

提示：
1. 如何处理“被包含”关系呢？ 其实可以反过来想，包含关系，也就是说，匹配！

代码后会详细谈谈几点见解：

#include <bits/stdc++.h>

using namespace std;
const int maxn = 4100000;

int pro[maxn] , t;
struct ACautomata
{
    int n;
    int ch[maxn][26] , q[maxn] , fa[maxn] , l , r;

    ACautomata(){ n = fa[0] = 0; memset(ch[0] , 0 , sizeof ch[0]); }
    int extend(char* s , int m , bool e = true)
    {
        int x = t = 0;
        for(int i=0,c;i<m;i++)
        {
            if(!ch[x][c = s[i] - 'a'] && e) 
            {
                ch[x][c] = ++n; fa[n] = 0;
                memset(ch[n] , 0 , sizeof ch[0]);
            }
            x = ch[x][c];
            pro[++t] = x;
        }
        return x;
    }

    void getFail()
    {
        l = r = 0;
        for(int i=0;i<26;i++) if(ch[0][i]) q[r++] = ch[0][i];
        while(l < r)
        {
            int x = q[l++] , y;
            for(int i=0;i<26;i++) 
            {
                y = ch[x][i];
                if(!y) ch[x][i] = ch[fa[x]][i];
                else 
                {
                    fa[y] = ch[fa[x]][i];
                    q[r++] = y;
                }
            }
        }
    }
}solver;

vector<int> g[maxn];
int id[maxn] , Size[maxn] , bl[maxn] , fa[maxn] , dep[maxn] , sum[maxn] , dfsCnt , m;

void modify(int x , int v=1) { while(x<=m+1) sum[x] += v , x += x&-x; }
int query(int x) { int res = 0; while(x) res += sum[x] , x -= x&-x; return res; } 

void dfs(int x)
{
    Size[x] = 1;
    for(unsigned int i=0,t;i<g[x].size();i++)
    {
        t = g[x][i];

        fa[t] = x;
        dep[t] = dep[x]+1;
        dfs(t);
        Size[x] += Size[t];
    }
}

void dfs(int x , int num)
{
    id[x] = ++dfsCnt;
    bl[x] = num;

    int mx = 0 , w;
    for(int i=0,t;i<g[x].size();i++)
    {
        t = g[x][i];
        if(Size[t] > mx) mx = Size[w = t];
    }

    if(mx) dfs(w, num);

    for(int i=0,t;i<g[x].size();i++)
    {
        t = g[x][i];
        if(t == w) continue;
        dfs(t, t);
    }
}

int lca(int x , int y)
{
    while(bl[x] != bl[y])
    {
        if(dep[bl[x]] > dep[bl[y]]) swap(x, y);
        y = fa[bl[y]];
    }
    return dep[x] < dep[y] ? x : y;
}

bool cmp(int x , int y) { return id[x] < id[y]; }

char s[maxn];
int n , q , p[maxn];
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        scanf("%s" , s);
        p[i] = solver.extend(s , strlen(s));
    }
    solver.getFail();
    m = solver.n;   
    for(int i=1;i<=m;i++) g[solver.fa[i]].push_back(i);
    dfs(0);
    dfs(0, 0);

    cin>>q;
    for(int i=1,x,y;i<=q;i++)
    {
        scanf("%d" , &x);
        if(x == 1)
        {
            scanf("%s" , s); 
            solver.extend(s , strlen(s) , false);
            sort(pro+1, pro+1+t, cmp);
            modify(id[pro[1]]);
            for(int j=2,l;j<=t;j++) 
            {
                l = lca(pro[j-1], pro[j]);
                modify(id[l] , -1);
                modify(id[pro[j]]);
            }
        }
        else 
        {
            scanf("%d" , &y); y = p[y];
            printf("%d\n" , query(id[y]+Size[y]-1) - query(id[y]-1));
        }
    }


    return 0;
}

不难想到用AC自动机处理A集合里的字符串。然后每次修改在自动机上跑匹配修改会匹配到的节点的权值，每次查询直接查点权。
但如果在自动机上经过的每个节点都暴力返回 $fail$ 指针的话应该是会超时的（这玩意看数据出的怎么样， 比如喵星球上点名那题就数据极弱）。

我们可以利用树链剖分，LCT等数据结构来每次把经过的节点到根的树链都加上一个值，但这里有一个重复计算的问题。 我们需要求树链的并！这并不是个新鲜的问题，可以参照 $popoqqq$ 的博客。

几点对AC自动机的理解：
1. AC自动机中有两类边， 转移边，也就是我们在匹配的时候在 $Trie$ 上走的边。还有就是失配边 ，也就是连接 $fail$ 树上的父亲的边。这两类边其实从某种意义上来说把图以两种树的形式体现出来啦。
2. 本题强化了 $fail$ 树的意义，沿着某个节点的失配边，我们能到达哪些点呢？ 如果我们当前到达节点对应的字符串是 $s$ ， 沿着失配边到达的点所对应的字符串是 $s^{'}$ , 那么$s^{'}$ 是 $s$的后缀。
3. 现在的一个匹配串是 $s$ ， 我们沿着 $Trie$ 树到达了 $s$对应的节点， 对于沿途中我们碰到的节点，我们还依次沿着失配边返回那么我们遍历到的节点就是所有这个AC自动机能够识别的 $s$ 的子串。