【dfs序+AC自动机+树状数组】BZOJ2434-[Noi2011]阿狸的打字机

【题目大意】

输入一个字符串，其中：(1)a..z:在字符串末尾添加当前字符(2)P:输出当前字符串(3)B:从当前字符串末尾删去一个字符。

给出m组查询，输出第i个输出的字符串在第j个输出的字符串内出现了几次。

【思路】

卡了好久，写完不想调试，调试完不想提交，期间颓颓颓地弄了下博客的界面，弄成了粉嫩少女风(划掉)。结果提交完1A有点迷醉迷醉的……

首先我们要借用BZOJ3172的结论：★←戳这里，这个结论66666，是本次解题的关键。

“建立AC自动机，对于路径上的每一个点sum++，表示出现的次数。fail指针指向的后缀，如果从fail指针指向的点开始方向建立fail树，其子树的sum之和就等于以它作为后缀的串的总数，相当于它在文章中出现的个数。”

显然我们要把m组询问(i,j)调换位置，同一组j,对i建立一个链表存放。为什么要这么做呢?先继续往下看。

首先，我们建立一个AC自动机，并建立fail树。这里和一般的建立有点区别，因为有删除操作，可以用一个栈来维护当前位于Trie的位置，如果B删除就弹出栈顶，如果为字母就建立新节点并压入栈中，如果是P就在当前位置打上ed的标记，表示这是第ed次打印的字符终止位置。

由于树中节点和子树的dfs序是连续的，我们跑一次dfs记录下fail树上每个点的dfs序，记录下第i个输出字符串，它的末尾节点及其子树在dfs序中的start和end位置。

最后，重新跑一次Trie，和先前一样用栈维护。如果遇到B，就将当前节点-1，弹出栈顶；遇到字母就将当前节点+1；如果遇到P，说明现在恰巧输出了第j个字符串，枚举每一个查询中的i，查询结果=当前i对应的节点和它子树之和。

没错，这是一个单点修改，区间求和，可以用树状数组来维护一下，每个节点在树状数组中的位置就等于它的dfs序。那么当前i对应的节点及其子树之和=sum[start[i]..end[i]]，搞定！

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<vector>
 #include<queue>
 #define lnum 26
 using namespace std;
 const int MAXN=+;
 int  ppos[MAXN];//第i个P对应的栈顶位置编号
 char str[MAXN];
 int m,len,step,cnt=,e[MAXN],start[MAXN],end[MAXN],ans[MAXN];
 struct ACauto
 {
     ACauto* next[lnum];
     ACauto* fail;
     int id,ed,order;
     ACauto()
     {
         for (int i=;i<lnum;i++) next[i]=NULL;
         fail=NULL;
         id=++cnt;
     }
 };
 struct node
 {
     int to,id;
 };
 ACauto* rt=new ACauto();
 ACauto* p[MAXN];//编号为i的节点指向的位置
 vector<node> Q[MAXN];
 vector<int> E[MAXN];

 void addedge(int u,int v)
 {
     E[u].push_back(v);
 }

 int lowbit(int x)
 {
     return (x&(-x));
 }

 void modify(int p,int x)
 {
     int i=p;
     while (i<=len)
     {
         e[i]+=x;
         i+=lowbit(i);
     }
 }

 int sum(int p)
 {
     int s=;
     int i=p;
     while (i>)
     {
         s+=e[i];
         i-=lowbit(i);
     }
     return s;
 }

 void init()
 {
     scanf("%s",str);
     len=strlen(str);
     int top=,n=;
     ACauto* stack[MAXN];
     stack[++top]=p[]=rt;//不要忘记给p[1]赋值
     for (int i=;i<len;i++)
     {
         if (str[i]=='P')
         {
             stack[top]->ed=++n;
             ppos[n]=stack[top]->id;
         }
             else if (str[i]=='B') top--;
                 else
                 {
                     int index=str[i]-'a';
                     if (stack[top]->next[index]==NULL)
                     {
                         stack[top]->next[index]=new ACauto();
                         p[cnt]=stack[top]->next[index];
                     }
                     stack[++top]=stack[top-]->next[index];
                 }
     }

     scanf("%d",&m);
     for (int i=;i<m;i++)
     {
         int x,y;
         scanf("%d%d",&x,&y);
         Q[y].push_back((node){ppos[x],i});
     }
 } 

 void buildfail()
 {
     queue<ACauto*> que;
     que.push(rt);
     while (!que.empty())
     {
         ACauto* head=que.front();que.pop();
         for (int i=;i<lnum;i++)
         {
             if (head->next[i]!=NULL)
             {
                 if (head==rt)
                 {
                     head->next[i]->fail=rt;
                     addedge(rt->id,head->next[i]->id);
                 }
                 else
                 {
                     ACauto* tmp=head->fail;
                     while (tmp!=NULL)
                     {
                         if (tmp->next[i]!=NULL)
                         {
                             head->next[i]->fail=tmp->next[i];
                             addedge(tmp->next[i]->id,head->next[i]->id);
                             break;
                         }
                         else tmp=tmp->fail;
                     }
                     if (tmp==NULL)
                     {
                         head->next[i]->fail=rt;
                         addedge(rt->id,head->next[i]->id);
                     }
                 }
                 que.push(head->next[i]);
             }
         }
     }
 }

 void dfs(int pos)
 {
     ACauto* tmp=p[pos];
     tmp->order=++step;
     if (tmp->ed) start[tmp->ed]=step;
     for (int i=;i<E[pos].size();i++) dfs(E[pos][i]);
     if (tmp->ed) end[tmp->ed]=step;
 }

 void query()
 {
     memset(e,,sizeof(e));
     int top=,n=;
     ACauto* stack[MAXN];
     stack[++top]=rt;
     for (int i=;i<len;i++)
     {
         if (str[i]=='P')
         {
             n++;
             for (int i=;i<Q[n].size();i++)
             {
                 ACauto* to=p[Q[n][i].to];
                 ans[Q[n][i].id]=sum(end[to->ed])-sum(start[to->ed]-);
             }
         }
         else if (str[i]=='B')
         {
             modify(stack[top]->order,-);
             top--;
         }
         else
         {
             int index=str[i]-'a';
             stack[++top]=stack[top-]->next[index];
             modify(stack[top]->order,);
         }
     }
 }

 void printans()
 {
     for (int i=;i<m;i++) printf("%d\n",ans[i]);
 }

 int main()
 {
     init();
     buildfail();
     dfs(rt->id);
     query();
     printans();
     return ;
 }