P8451 题解

显然，题面明摆着让你写一个可持久化 AC 自动机。

但是从空间来说这是不可能的。

想起做 不强制在线 的可持久化数据结构的一种方法，建立“时光树”，具体来说，假若版本 \(x\) 由版本 \(y\) 更改而来，建边 \(x \to y\)。最后在建出的树上遍历并回答询问。

到此我们只需要一个可以支持加入和撤销的 AC 自动机即可。

考虑维护失配树，具体来说，一个字符串出现的次数等于其所有前缀节点在失配树上的祖先中终止节点数量之和，这是一个点修链查，将其转变为子树修单点查，用树状数组维护即可。

#include<bits/stdc++.h>
#define lowbit(x) (x&(-x))
using namespace std;
const int maxn = 1e6+5;
class AC_automaton{
public:
    int son[maxn][26],fail[maxn],rt,tot,dfncnt;
    vector<int> edge[maxn];//fail 树
    vector<int> fa[maxn];//原树上的祖先
    int L[maxn],R[maxn],len,now;
    void insert(string &s,int pos){
        len=s.size(),now=rt;
        for(int i=0;i<len;i++){
            if(son[now][s[i]-'a']==0) son[now][s[i]-'a']=++tot;
            now=son[now][s[i]-'a'];
            fa[pos].push_back(now);
        }
    }
    void build(){
        queue<int> q;
        for(int i=0;i<26;i++) if(son[rt][i]) fail[son[rt][i]]=rt,q.push(son[rt][i]);
        while(q.size()>0){
            int u=q.front();
            q.pop();
            for(int i=0;i<26;i++){
                if(son[u][i]){
                    fail[son[u][i]]=son[fail[u]][i];
                    q.push(son[u][i]);
                }
                else son[u][i]=son[fail[u]][i];
            }
        }
        for(int i=1;i<=tot;i++){
        	edge[fail[i]].push_back(i);
		}
    }
    inline void dfs(int u){
    	L[u]=++dfncnt;
		for(int v:edge[u]){
			if(!L[v]) dfs(v);
		}
        R[u]=dfncnt;
	}//处理子树信息
}AC;
int tr[maxn];
inline void add(int x,int v){
    while(x<=AC.dfncnt) tr[x]+=v,x+=lowbit(x);
}
inline int pre(int x){
    int res=0;
    while(x>0) res+=tr[x],x-=lowbit(x);
    return res;
}
int answer[maxn>>1];
struct Edge{
    int v,nxt;
}e[maxn];
int head[maxn>>1],cnt;
void add_edge(int u,int v){
    e[++cnt].v=v;
    e[cnt].nxt=head[u];
    head[u]=cnt;
}
vector<int> Query[maxn>>1];
bitset< 500005 > opt;
inline void dfs(int u){
    for(int now:Query[u]){
        for(int u:AC.fa[now]){
            answer[now]+=pre(AC.L[u]);
        }
    }
    Query[u].clear();
    for(int i=head[u];i;i=e[i].nxt){
        int now=e[i].v;
        if(opt[now]==1){
            add(AC.L[AC.fa[now].back()],1);
            add(AC.R[AC.fa[now].back()]+1,-1);
        }
        dfs(now);
        if(opt[now]==1){
            add(AC.L[AC.fa[now].back()],-1);
            add(AC.R[AC.fa[now].back()]+1,1);
        }
    }
}
inline int found(int u){
    return tr[u]==u?u:tr[u]=found(tr[u]);
}
int q;
int main(){
    cin>>q;
    for(int i=1;i<=q;i++){
        tr[i]=i;
        int lst,op;
        string s;
        cin>>op>>lst>>s;
        opt[i]=(op==1?1:0);
        lst=found(lst);
        AC.insert(s,i);
        if(opt[i]==1) add_edge(lst,i);
        else Query[lst].push_back(i),tr[i]=lst;
    }
    for(int i=0;i<=q;i++) tr[i]=0;
    AC.build();
    AC.dfs(AC.rt);
    dfs(0);
    for(int i=1;i<=q;i++) if(opt[i]==0) cout<<answer[i]<<'\n';
    return 0;
}