【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=100000+50;
int  ppos[MAXN];//第i个P对应的栈顶位置编号
char str[MAXN];
int m,len,step,cnt=0,e[MAXN],start[MAXN],end[MAXN],ans[MAXN];
struct ACauto
{
    ACauto* next[lnum];
    ACauto* fail;
    int id,ed,order; 
    ACauto()
    {
        for (int i=0;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=0;
    int i=p;
    while (i>0)
    {
        s+=e[i];
        i-=lowbit(i);
    }
    return s;
}

void init()
{
    scanf("%s",str);
    len=strlen(str);
    int top=0,n=0;
    ACauto* stack[MAXN];
    stack[++top]=p[1]=rt;//不要忘记给p[1]赋值 
    for (int i=0;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-1]->next[index];
                }
    }
    
    scanf("%d",&m);
    for (int i=0;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=0;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=0;i<E[pos].size();i++) dfs(E[pos][i]);
    if (tmp->ed) end[tmp->ed]=step;
}

void query()
{
    memset(e,0,sizeof(e));
    int top=0,n=0;
    ACauto* stack[MAXN];
    stack[++top]=rt;
    for (int i=0;i<len;i++)
    {
        if (str[i]=='P')
        {
            n++;
            for (int i=0;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]-1);
            }
        }
        else if (str[i]=='B')
        {
            modify(stack[top]->order,-1);
            top--;
        }
        else
        {
            int index=str[i]-'a';
            stack[++top]=stack[top-1]->next[index];
            modify(stack[top]->order,1);
        }
    }
}

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

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