BZOJ 3881 [COCI2015]Divljak (Trie图+Fail树+树链的并+树状数组维护dfs序)

题目大意：

Alice有n个字符串S_1,S_2...S_n，Bob有一个字符串集合T，一开始集合是空的。

接下来会发生q个操作，操作有两种形式：

“1 P”，Bob往自己的集合里添加了一个字符串P。

“2 x”，Alice询问Bob，集合T中有多少个字符串包含串S_x。（我们称串A包含串B，当且仅当B是A的子串）

Bob遇到了困难，需要你的帮助。

 

最先想歪了，想把$T$里的串建自动机，最后失败了..

正解是对Alice的字符串建AC自动机，再建$Fail$树

那么对于操作1，每加入一个字符串，就把这个串放到AC自动机上跑

再把路径上的所有点记下来，新加入的字符串会对连接这些节点的树链上的所有点产生1点贡献

即求树链的并，用树状数组维护$dfs$序

先把这些节点按照$dfs$序排序，然后在树上打差分，树状数组维护前缀和，单点修改

每个节点都+1，$dfs$序中相邻节点的$lca$-1，最后在全局$lca$的父节点-1

询问就是子树查询

 #include <cmath>
 #include <queue>
 #include <vector>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #define NN 2001000
 #define MM 1510
 #define ll long long
 #define dd double
 #define uint unsigned int
 #define mod 1000000007
 #define idx(X) (X-'a')
 #define eps (1e-9)
 using namespace std;

 int n,m,cte;
 int head[NN];
 struct Edge{int to,nxt;}edge[NN];
 void ae(int u,int v){
     cte++;edge[cte].nxt=head[u];
     head[u]=cte,edge[cte].to=v;
 }
 struct BIT{
 int sum[NN*],tot;
 void update(int x,int w){
     for(int i=x;i<=tot;i+=(i&(-i)))
         sum[i]+=w;}
 int query(int x){
     int ans=;
     for(int i=x;i>;i-=(i&(-i)))
         ans+=sum[i];
     return ans;}
 }b;
 namespace AC{
 int ch[NN][],fail[NN],tot,ed[NN],dep[NN];
 void Build_Trie(char *str,int len,int id)
 {
     int x=;
     for(int i=;i<=len;i++){
         if(!ch[x][idx(str[i])])
             ch[x][idx(str[i])]=++tot,
             dep[tot]=dep[x]+;
         x=ch[x][idx(str[i])];
     }ed[id]=x;
 }
 void Build_Fail()
 {
     queue<int>q;
     for(int i=;i<;i++)
         if(ch[][i]) q.push(ch[][i]);
     while(!q.empty())
     {
         int x=q.front();q.pop();
         ae(fail[x],x);
         for(int i=;i<;i++)
         {
             if(ch[x][i]){
                 fail[ch[x][i]]=ch[fail[x]][i];
                 q.push(ch[x][i]);
             }else{
                 ch[x][i]=ch[fail[x]][i];
             }
         }
     }
 }
 };
 char str[NN];
 namespace T{
 int son[NN],sz[NN],tp[NN],fa[NN],dep[NN];
 int st[NN],ed[NN],tot;
 void dfs1(int u,int dad)
 {
     for(int j=head[u];j;j=edge[j].nxt){
         int v=edge[j].to;
         if(v==dad) continue;
         fa[v]=u;dep[v]=dep[u]+;
         dfs1(v,u);
         son[u]=sz[v]>sz[son[u]]?v:son[u];
     }sz[u]++;
 }
 void dfs2(int u)
 {
     st[u]=++tot;
     if(son[u]) tp[son[u]]=tp[u],dfs2(son[u]);
     for(int j=head[u];j;j=edge[j].nxt){
         int v=edge[j].to;
         if(v==fa[u]||v==son[u]) continue;
         tp[v]=v,dfs2(v);
     }ed[u]=++tot;
 }
 int LCA(int x,int y)
 {
     while(tp[x]!=tp[y]){
         if(dep[tp[x]]<dep[tp[y]]) swap(x,y);
         x=fa[tp[x]];
     }return dep[x]<dep[y]?x:y;
 }
 int stk[NN],num;
 int cmp(int x,int y){return st[x]<st[y];}
 void update(char *str,int len)
 {
     int x=,y,ff,v;
     for(int i=;i<=len;i++){
         v=AC::ch[x][idx(str[i])];
         if((!v)) break;
         x=v;stk[++num]=x;
     }
     sort(stk+,stk+num+,cmp);
     x=stk[];
     if(num==){
         b.update(st[x],);
         b.update(st[fa[x]],-);
     }else{
         b.update(st[x],);
         for(int i=;i<=num;i++)
         {
             y=stk[i];ff=LCA(x,y);
             b.update(st[y],);
             b.update(st[ff],-);
             x=stk[i];
         }ff=LCA(stk[],stk[num]);
         b.update(st[fa[ff]],-);
     }
     while(num) stk[num--]=;
 }
 int query(int x)
 {return b.query(ed[x])-b.query(st[x]-);}
 void solve()
 {
     dep[]=;dfs1(,-);
     tp[]=;dfs2();
     scanf("%d",&m);
     int fl,x;
     b.tot=tot;
     for(int i=;i<=m;i++)
     {
         scanf("%d",&fl);
         if(fl==){
             scanf("%s",str+);
             int len=strlen(str+);
             update(str,len);
         }else{
             scanf("%d",&x);
             printf("%d\n",query(AC::ed[x]));
         }
     }
 }
 };

 int main()
 {
     scanf("%d",&n);
     for(int i=;i<=n;i++){
         scanf("%s",str+);
         int len=strlen(str+);
         AC::Build_Trie(str,len,i);
     }AC::Build_Fail();
     T::solve();
     return ;
 }