NOI 2011 阿狸的打字机 (AC自动机+dfs序+树状数组)

题目大意：略(太长了不好描述) 良心LOJ传送门

先对所有被打印的字符串建一颗Trie树

观察数据范围，并不能每次打印都从头到尾暴力建树，而是每遍历到一个字符就在Trie上插入这个字符，然后记录每次打印后字符串最后一个字符在Trie树上的位置

然后建立AC自动机，再建立Fail树。注意还要另外存一下原来Trie树的结构

Fail树就是把Fail指针倒着跑，因为每个点只有一个Fail指针，所以最后所有Fail指针会形成一棵树

Fail树有一个神奇的性质，即父节点表示的字符串(从Trie树的根节点一直到这个点所表示的字符串)，一定是子节点表示的字符串的一个后缀

原问题是求x号字符串在y号字符串内出现的次数

问题可以转化为，求x作为后缀，出现在y的所有前缀的次数

根据Fail树的性质：父节点一定是子节点的后缀

那么从Trie根节点到y结尾节点的所有点，都能分别表示y的一个前缀串

而如果x是某个串的后缀，那么这个串一定在x的Fail树的子树内

如果对所有问题暴力匹配x,y又不可取

查询y的所有前缀出现在x子树内的次数，相当于在x子树内求和，貌似可以用DFS序+树状数组优化

我们可以对问题进行离线处理，把问题挂在Trie树上以y的结尾的位置上。然后跑出Fail树DFS序。再在Tire树上跑DFS，搜索到这个节点，就在它dfs序入栈的位置上+1，回溯过这个节点，就-1，这个操作其实是在表示所有可能的y的所有前缀

再回溯过这个节点之前，处理挂在这个点上所有的询问。

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <queue>
 #define idx(x) x-'a'+1
 #define lowbit(x) (x&(-x))
 #define N 100100
 using namespace std;

 char str[N];
 int n,m,len,num,cte,ctq,tot,dfn,qs;
 int use[N],pos[N],head[N],st[N],ed[N],s[N*],hq[N];
 struct Edge{int to,nxt;}edge[N*],ques[N];
 void ae(int u,int v){cte++;edge[cte].to=v,edge[cte].nxt=head[u],head[u]=cte;}
 void aq(int u,int v){ctq++;ques[ctq].to=v,ques[ctq].nxt=hq[u],hq[u]=ctq;}
 struct AC{
     int fa[N],son[N][],ch[N][],fail[N];
     int cre(int w,int ff){tot++;fa[tot]=ff;return tot;}
     void Build()
     {
         int x=;
         for(int i=;i<=len;i++)
         {
             if('a'<=str[i]&&str[i]<='z'){
                 int w=idx(str[i]);
                 if(!ch[x][w]) ch[x][w]=son[x][w]=cre(w,x);
                 x=ch[x][w];
             }else if(str[i]=='B'){
                 x=fa[x];
             }else pos[++num]=x;
         }
     }
     void Fail()
     {
         queue<int>q;
         for(int i=;i<=;i++)
             if(ch[][i]) q.push(ch[][i]),ae(,ch[][i]);
         while(!q.empty())
         {
             int x=q.front();q.pop();
             for(int i=;i<=;i++)
                 if(ch[x][i]){
                     fail[ch[x][i]]=ch[fail[x]][i];
                     ae(fail[ch[x][i]],ch[x][i]);
                     q.push(ch[x][i]);
                 }else{
                     ch[x][i]=ch[fail[x]][i];
                 }
         }
     }
     void dfs(int u)
     {
         st[u]=++dfn;
         for(int j=head[u];j;j=edge[j].nxt){
             int v=edge[j].to;
             dfs(v);
         }ed[u]=++dfn;
     }
     void main()
     {
         Build();
         Fail();
         dfs();
     }
 }ac;
 struct Ques{int x,y,id,ans;}q[N];
 void update(int x,int w){for(int i=x;i<=dfn;i+=lowbit(i))s[i]+=w;}
 int query(int x){int ans=;for(int i=x;i>;i-=lowbit(i))ans+=s[i];return ans;}
 void dfs_ans(int x)
 {
     update(st[x],);
     for(int i=;i<=;i++)
     {
         if(ac.son[x][i])
             dfs_ans(ac.son[x][i]);
     }
     for(int j=hq[x];j;j=ques[j].nxt){
         int v=ques[j].to;
         q[v].ans=query(ed[pos[q[v].x]])-query(st[pos[q[v].x]]-);
     }
     update(ed[x],-);
 }

 int main()
 {
     scanf("%s",str+);
     len=strlen(str+);
     ac.main();
     int x,y;
     scanf("%d",&m);
     for(int i=;i<=m;i++)
     {
         scanf("%d%d",&x,&y);
         qs++,q[qs].x=x,q[qs].y=y,q[qs].id=i;
         aq(pos[y],qs);
     }
     dfs_ans();
     for(int i=;i<=m;i++){printf("%d\n",q[i].ans);}
     return ;
 }