bzoj 2434: [Noi2011]阿狸的打字机

题面

题意

给出一个字符串,表示一系列操作,对于被操作串(初始为空串)一共有一下三种操作:
1.给出a~z中的一个字符,表示在后面加上这个字符
2.B,删去一个字符
3.P,记录下此时的操作串
最后多次询问i串在j串中出现了几次

做法

根据数据范围,如果暴力模拟,记录下每次操作后的字符串,空间立刻就炸了,所以肯定要用字典树来存.
还可以发现如果对每次询问都暴力匹配或是在AC自动机上直接匹配,绝对会T.
因此要思考其他方法:
不难发现i串在j串中出现的次数就是AC自动机的fail树中,j串的所有属于i节点子树的节点数量之和.,所以在dfs序上子树就是一段区间,需要查询区间和,可以用树状数组来维护.
但是如何快速将一个字符串的所有节点在dfs序中的位置加入树状数组呢?
此题还要注意它的操作方式,相邻两串相似度很高(一半有一段较长的公告前缀),所以我们不仅可以边输入边建AC自动机,还可以直接在上一个字符串得到的树状数组中在遍历的同时修改(不用修改lcp),这样就能得到答案了.

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<algorithm>
#define N 100100
using namespace std;

int n,m,tt,now,first[N],bb,in[N],out[N],ti,sz[N],ans[N],pos[N];
char str[N];
struct Node
{
    int son[26],fa,fail;
}node[N];
struct Bn
{
    int to,next;
}bn[N];
struct Qu
{
    int x,y,id;
    bool operator < (const Qu &u) const
    {
        return y<u.y;
    }
}qu[N];
queue<int>que;

inline int lb(int u){return u&(-u);}

inline void ad(int u,int v)
{
    bb++;
    bn[bb].to=v;
    bn[bb].next=first[u];
    first[u]=bb;
}

inline void add(int u)
{
    if(!node[now].son[u])
    {
        node[now].son[u]=++tt;
        node[tt].fa=now;
    }
    now=node[now].son[u];
}

inline void ads(int u,int v)
{
    for(;u<=ti;u+=lb(u))
    {
        sz[u]+=v;
    }
}

inline int ask(int u)
{
    int res=0;
    for(;u;u-=lb(u))
    {
        res+=sz[u];
    }
    return res;
}

inline void build()
{
    int i,j,p,q,k;
    for(i=0;i<26;i++)
    {
        if(node[0].son[i])
        {
            node[node[0].son[i]].fail=0;
            ad(0,node[0].son[i]);
            que.push(node[0].son[i]);
        }
    }
    for(;!que.empty();)
    {
        q=que.front();
        que.pop();
        for(i=0;i<26;i++)
        {
            if(!node[q].son[i]) continue;
            for(k=node[q].fail;k&&!node[k].son[i];k=node[k].fail);
            node[node[q].son[i]].fail=node[k].son[i];
            ad(node[k].son[i],node[q].son[i]);
            que.push(node[q].son[i]);
        }
    }
}

void dfs(int now,int last)
{
    int p,q;
    in[now]=++ti;
    for(p=first[now];p!=-1;p=bn[p].next)
    {
        if(bn[p].to==last) continue;
        dfs(bn[p].to,now);
    }
    out[now]=ti;
}

int main()
{
    memset(first,-1,sizeof(first));
    int i,j,k;
    scanf("%s",str+1);
    n=strlen(str+1);
    for(i=j=1;i<=n;i++)
    {
        if(str[i]=='B')
        {
            now=node[now].fa;
        }
        else if(str[i]=='P')
        {
            pos[j++]=now;
        }
        else
        {
            add(str[i]-'a');
        }
    }
    build();
    dfs(0,-1);
    cin>>m;
    for(i=1;i<=m;i++)
    {
        scanf("%d%d",&qu[i].x,&qu[i].y);
        qu[i].id=i;
    }
    sort(qu+1,qu+m+1);
    now=0;
    for(i=j=k=1;i<=n;i++)
    {
        if(str[i]=='B')
        {
            ads(in[now],-1);
            now=node[now].fa;
        }
        else if(str[i]=='P')
        {
            for(;j<=m&&qu[j].y==k;j++)
            {
                ans[qu[j].id]=ask(out[pos[qu[j].x]])-ask(in[pos[qu[j].x]]-1);
            }
            k++;
        }
        else
        {
            now=node[now].son[str[i]-'a'];
            ads(in[now],1);
        }
    }
    for(i=1;i<=m;i++)
    {
        printf("%d\n",ans[i]);
    }
}