BZOJ2434 [Noi2011]阿狸的打字机（AC自动机 + fail树 + DFS序 + 线段树）

题目这么说的：

阿狸喜欢收藏各种稀奇古怪的东西，最近他淘到一台老式的打字机。打字机上只有28个按键，分别印有26个小写英文字母和'B'、'P'两个字母。
经阿狸研究发现，这个打字机是这样工作的：

1. 输入小写字母，打字机的一个凹槽中会加入这个字母(这个字母加在凹槽的最后)。
2. 按一下印有'B'的按键，打字机凹槽中最后一个字母会消失。
3. 按一下印有'P'的按键，打字机会在纸上打印出凹槽中现有的所有字母并换行，但凹槽中的字母不会消失。

例如，阿狸输入aPaPBbP，纸上被打印的字符如下：
a
aa
ab
我们把纸上打印出来的字符串从1开始顺序编号，一直到n。打字机有一个非常有趣的功能，在打字机中暗藏一个带数字的小键盘，在小键盘上输入两个数(x,y)（其中1≤x,y≤n），打字机会显示第x个打印的字符串在第y个打印的字符串中出现了多少次。
阿狸发现了这个功能以后很兴奋，他想写个程序完成同样的功能，你能帮助他么？

• 把AC自动机的结点作为树结点，将fail指针的方向取反设为树边，这样除了AC自动机头结点外每个结点都有且仅有一条进入它的边，这样就得到一棵叫fail树的树。
• 在AC自动机中如果y的fail指针指向x，可知x表示的字符串前缀是y结点表示的字符串前缀的后缀；因此可以知道在fail树中x为根的子树的所有结点表示的字符串前缀都包含x结点所表示的字符串前缀。
• 对于，询问一个字符串x在另一个字符串y出现了多少次，就可以这样：在fail树中标记字符串y的所有前缀结点，然后看x为根的子树有多少个被标记结点就是答案，这个可以用DFS序+线段树实现。
• 而对于这题的具体实现：
  1. 首先可以顺着输入的字符串序列B往父亲走，P标记这样建立AC自动机
  2. 然后把查询离线处理，用邻接表记录每一组查询<x,y>中每个y有哪几个x
  3. 最后再顺着输入的字符串序列，遇到B和小写字符更新线段树，遇到P去查询出当前y的所有x的答案

#include<cstdio>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;
#define MAXN 111111

struct Edge{
    int v,next;
}edge[MAXN];
int NE,head[MAXN];
void addEdge(int u,int v){
    edge[NE].v=v; edge[NE].next=head[u];
    head[u]=NE++;
}

int tn,ch[MAXN][26],fa[MAXN],flag[MAXN],fail[MAXN];
int belong[MAXN],bn,rbelong[MAXN];
char str[111111];
void insert(){
    int x=0;
    for(int i=0; str[i]; ++i){
        if(str[i]=='B'){
            x=fa[x];
        }else if(str[i]=='P'){
            flag[x]=1;
            belong[x]=++bn;
            rbelong[bn]=x;
        }else{
            int y=str[i]-'a';
            if(ch[x][y]==0) ch[x][y]=++tn,fa[ch[x][y]]=x;
            x=ch[x][y];
        }
    }
}
void getfail(){
    queue<int> que;
    for(int i=0; i<26; ++i){
        if(ch[0][i]){
            que.push(ch[0][i]);
            addEdge(0,ch[0][i]);
        }
    }
    while(!que.empty()){
        int x=que.front(); que.pop();
        for(int i=0; i<26; ++i){
            if(ch[x][i]){
                que.push(ch[x][i]);
                fail[ch[x][i]]=ch[fail[x]][i];
                addEdge(fail[ch[x][i]],ch[x][i]);
            }else ch[x][i]=ch[fail[x]][i];
        }
    }
}

int dfn,l[MAXN],r[MAXN],par[MAXN];
void dfs(int u){
    l[u]=++dfn;
    for(int i=head[u]; i!=-1; i=edge[i].next){
        int v=edge[i].v;
        par[v]=u;
        dfs(v);
    }
    r[u]=dfn;
}

int tree[MAXN<<2],N,x,y;
void update(int i,int j,int k){
    if(i==j){
        tree[k]+=y;
        return;
    }
    int mid=i+j>>1;
    if(x<=mid) update(i,mid,k<<1);
    else update(mid+1,j,k<<1|1);
    tree[k]=tree[k<<1]+tree[k<<1|1];
}
int query(int i,int j,int k){
    if(x<=i && j<=y){
        return tree[k];
    }
    int mid=i+j>>1,res=0;
    if(x<=mid) res+=query(i,mid,k<<1);
    if(y>mid) res+=query(mid+1,j,k<<1|1);
    return res;
}

struct Query{
    int x,y,ans,next;
}que[MAXN];
int qhead[MAXN],qNE,order[MAXN];
void addQuery(int x,int y){
    que[qNE].x=x; que[qNE].y=y; que[qNE].next=qhead[y];
    qhead[y]=qNE++;
}

void doit(){
    int now=0;
    for(int i=0; str[i]; ++i){
        if(str[i]=='B'){
            x=l[now]; y=-1;
            update(1,N,1);
            now=fa[now];
        }else if(str[i]=='P'){
            for(int j=qhead[belong[now]]; j!=-1; j=que[j].next){
                x=l[rbelong[que[j].x]]; y=r[rbelong[que[j].x]];
                que[j].ans=query(1,N,1);
            }
        }else{
            now=ch[now][str[i]-'a'];
            x=l[now]; y=1;
            update(1,N,1);
        }
    }
}
int main(){
    scanf("%s",str);
    insert();
    memset(head,-1,sizeof(head));
    getfail();
    dfs(0);
    for(N=1; N<dfn; N<<=1);
    memset(qhead,-1,sizeof(qhead));
    int m,a,b;
    scanf("%d",&m);
    for(int i=0; i<m; ++i){
        scanf("%d%d",&a,&b);
        order[i]=qNE;
        addQuery(a,b);
    }
    doit();
    for(int i=0; i<m; ++i){
        printf("%d\n",que[order[i]].ans);
    }
    return 0;
}