AC自动机：BZOJ 2434 阿狸的打字机

2434: [Noi2011]阿狸的打字机

Time Limit: 10 Sec  Memory Limit: 256 MB
Submit: 1834  Solved: 1053
[Submit][Status][Discuss]

Description

　　阿狸喜欢收藏各种稀奇古怪的东西，最近他淘到一台老式的打字机。打字机上只有28个按键，分别印有26个小写英文字母和'B'、'P'两个字母。经阿狸研究发现，这个打字机是这样工作的：l 输入小写字母，打字机的一个凹槽中会加入这个字母(这个字母加在凹槽的最后)。l 按一下印有'B'的按键，打字机凹槽中最后一个字母会消失。l 按一下印有'P'的按键，打字机会在纸上打印出凹槽中现有的所有字母并换行，但凹槽中的字母不会消失。例如，阿狸输入aPaPBbP，纸上被打印的字符如下：
a
aa
ab
　　我们把纸上打印出来的字符串从1开始顺序编号，一直到n。打字机有一个非常有趣的功能，在打字机中暗藏一个带数字的小键盘，在小键盘上输入两个数(x,y)（其中1≤x,y≤n），打字机会显示第x个打印的字符串在第y个打印的字符串中出现了多少次。阿狸发现了这个功能以后很兴奋，他想写个程序完成同样的功能，你能帮助他么？

Input

　　输入的第一行包含一个字符串，按阿狸的输入顺序给出所有阿狸输入的字符。
　　第二行包含一个整数m，表示询问个数。
　　接下来m行描述所有由小键盘输入的询问。其中第i行包含两个整数x, y，表示第i个询问为(x, y)。

Output

　　输出m行，其中第i行包含一个整数，表示第i个询问的答案。

Sample Input

　　aPaPBbP
　　3
　　1 2
　　1 3
　　2 3

Sample Output

　　2
　　1
　　0

HINT

1<=N<=10^5

1<=M<=10^5

输入总长<=10^5

 

　　这题我很久以前见到过，当时没敢动手，现在学了AC自动机后，果断拿来练手了。

　　题意很简单，可以离线。

　　这里在建完fail树后须将fail边反向，建成一棵fail树，如果能A到B有条边，那么代表trie树上到A的字符串是到B的字符串的后缀，这时来一遍DFS，记录每一个点的时间戳，即一个时间段，be[i]指i点自己的编号，也指其开始，en[i]指其结束。

　　对于一个节点，它在fail树上的子树中，所有节点的fail都直接或间接的连向它，指它是那些的子串，被他们包含，而用时间戳可以迅速知道一个点是否是其子树。

　　之后用离线做法处理答案，用bit维护。

 

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <queue>
 #include <algorithm>
 using namespace std;
 const int maxn=1e5+;
 char S[maxn];
 int Query[maxn][],ans[maxn],cntQ;
 struct A_Cautomation{
     int ch[maxn][],fail[maxn],end[maxn],fa[maxn],ID[maxn],cnt,root,cont;
     int fir[maxn],nxt[maxn],to[maxn],cot;
     int be[maxn],en[maxn],sjc;
     void Init()
     {
         memset(ch,,sizeof(ch));
         memset(fail,,sizeof(fail));
         memset(end,,sizeof(end));
         sjc=cot=cnt=cont=root=;
     }
     void Insert()
     {
         scanf("%s",S);
         int len=strlen(S),node=root;
         for(int i=;i<len;i++)
         {
             if(S[i]>='a'&&S[i]<='z'){
                 if(ch[node][S[i]-'`']){
                     node=ch[node][S[i]-'`'];
                 }
                 else{
                     fa[++cnt]=node;
                     node=ch[node][S[i]-'`']=cnt;
                 }
             }
             else{
                 if(S[i]=='B'){
                     node=fa[node];
                 }
                 else{
                     end[node]=++cont;
                     ID[cont]=node;
                 }
             }
         }
     }
     void Build()
     {
         queue<int>q;
         for(int i=;i<=;i++){
             if(ch[root][i]){
                 fail[ch[root][i]]=root;
                 q.push(ch[root][i]);
             }
             else
                 ch[root][i]=root;
         }
         while(!q.empty())
         {
             int node=q.front();q.pop();
             for(int i=;i<=;i++){
                 if(ch[node][i]){
                     fail[ch[node][i]]=ch[fail[node]][i];
                     q.push(ch[node][i]);
                 }
                 else{
                     ch[node][i]=ch[fail[node]][i];
                 }
             }
         }
     }

     void addedge(int a,int b)
     {nxt[++cot]=fir[a];fir[a]=cot;to[cot]=b;}

     void DFS(int node)
     {
         be[node]=++sjc;
         for(int i=fir[node];i;i=nxt[i])
         DFS(to[i]);
         en[node]=sjc;
     }

     void BuildTree()
     {
         for(int i=;i<=cnt;i++)
             addedge(fail[i],i);

         DFS(root);
     }

     int bit[maxn];
     void change(int k,int x)
     {
         while(k<=)
         {
             bit[k]+=x;
             k+=k&(-k);
         }
     }

     int Quer(int k)
     {
         int ret=;
         while(k)
         {
             ret+=bit[k];
             k-=k&(-k);
         }
         return ret;
     }

     void Solve()
     {
         memset(fir,,sizeof(fir));cot=;
         memset(bit,,sizeof(bit));
         for(int i=;i<=cntQ;i++)
         Query[i][]=ID[Query[i][]],
         Query[i][]=ID[Query[i][]],
         addedge(Query[i][],Query[i][]);

         int len=strlen(S),node=root;
         for(int i=;i<len;i++)
         {
             if(S[i]>='a'&&S[i]<='z'){
                 node=ch[node][S[i]-'`'];
                 change(be[node],);
             }
             else{
                 if(S[i]=='B'){
                     change(be[node],-);
                     node=fa[node];
                 }
                 else{
                     for(int i=fir[node];i;i=nxt[i]){
                         ans[i]=Quer(en[to[i]])-Quer(be[to[i]]-);
                     }
                 }
             }
         }

         for(int i=;i<=cntQ;i++)
         printf("%d\n",ans[i]);
     }
 }AC;

 int main()
 {
     AC.Init();
     AC.Insert();
     AC.Build();
     AC.BuildTree();

     int Q;
     scanf("%d",&Q);
     while(Q--)
         scanf("%d%d",&Query[cntQ][],&Query[++cntQ][]);

     AC.Solve();
     return ;
 }