BZOJ2434: [Noi2011]阿狸的打字机

阿狸的打字过程实际上是在建一个trie树，对这棵trie建立ac自动机的fail树后，问第x个串在第y个串中出现了多少次，相当于问y串有多少个前缀，在fail树中位于x的子树里
到这里其实好像离线一下就可以了？但还有另一种资瓷在线询问的做法
我们不可能对y串的每个前缀处理，因为这个trie树的建立可以让所有串的总长是n^2级别的
但其实在trie树上这样走造字符串，很多串有着很长的LCP，比如在t1时刻我从节点x走了下去，在t2时刻退出了节点x，那么t1~t2时刻造出的所有字符串的前缀都有x，我们在trie树上走进一个节点时记录当前在造第x个串，离开时若当前在造第y个串，那么x就是串[x,y)的前缀，x的子树中[x,y)的出现次数就+1，这样得到的区间[x,y)的数量是O(n)个的，对每个点p的[x,y)，在p的线段树上对[x,y)区间+1，然后在fail树上线段树合并，就可以求出每个点p的子树内每个串的出现次数，就可以O(log)做到在线询问了

code：

#include<set>
#include<map>
#include<deque>
#include<queue>
#include<stack>
#include<cmath>
#include<ctime>
#include<bitset>
#include<string>
#include<vector>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<climits>
#include<complex>
#include<iostream>
#include<algorithm>
#define ll long long
using namespace std;

const int maxn = 210000;

int n,m,to[maxn];
int ans[maxn],qi[maxn];
vector<int>query[maxn];
struct segment
{
    int seg[maxn*25],lc[maxn*25],rc[maxn*25],root[maxn],cnt;
    int lx,rx;
    void add(int &x,const int l,const int r)
    {
        if(rx<l||r<lx) return;
        if(!x) x=++cnt;
        if(lx<=l&&r<=rx) { seg[x]++; return; }
        int mid=l+r>>1;
        add(lc[x],l,mid); add(rc[x],mid+1,r);
    }
    void merge(int &x,const int y)
    {
        if(!y) return;
        if(!x) { x=y; return; }
        seg[x]+=seg[y];
        merge(lc[x],lc[y]);
        merge(rc[x],rc[y]);
    }
    int loc,c;
    int query(const int x,const int l,const int r)
    {
        c+=seg[x];
        if(l==r||!x) return c;
        int mid=l+r>>1;
        if(loc<=mid) return query(lc[x],l,mid);
        else return query(rc[x],mid+1,r);
    }
}seg;
struct interval{int l,r;};
vector<interval>V[maxn];

struct edge{int y,nex;}a[maxn]; int len,fir[maxn];
inline void ins(const int x,const int y){a[++len]=(edge){y,fir[x]};fir[x]=len;}
void dfs(const int x)
{
    for(int i=0;i<V[x].size();i++)
    {
        const interval now=V[x][i];
        seg.lx=now.l,seg.rx=now.r-1;
        if(seg.lx<=seg.rx) seg.add(seg.root[x],1,n);
    }
    for(int k=fir[x],y=a[k].y;k;k=a[k].nex,y=a[k].y)
    {
        dfs(y);
        seg.merge(seg.root[x],seg.root[y]);
    }
    for(int i=0;i<query[x].size();i++)
    {
        int j=query[x][i],y=qi[j];
        seg.loc=y; seg.c=0;
        ans[j]=seg.query(seg.root[x],1,n);
    }
}

struct trie{int son[26],fa,fail,las;}tr[maxn]; int root,tot;

char str[maxn];
queue<int>q;
void build_trie()
{
    int x=root,len=strlen(str); n=1;
    for(int i=0;i<len;i++)
    {
        char cc=str[i];
        if(cc=='P') to[++n]=x;
        else if(cc=='B') V[x].push_back((interval){tr[x].las,n}),x=tr[x].fa;
        else
        {
            int c=cc-'a';
            if(!tr[x].son[c]) tr[tr[x].son[c]=++tot].fa=x;
            x=tr[x].son[c]; tr[x].las=n;
        }
    }
    while(1)
    {
        V[x].push_back((interval){tr[x].las,n});
        if(x==root) break;
        x=tr[x].fa;
    }
    q.push(root);
    while(!q.empty())
    {
        const int x=q.front(); q.pop();
        int fl=tr[x].fail;
        for(int i=0;i<26;i++)
        {
            int &y=tr[x].son[i];
            if(y)
            {
                if(x!=root) tr[y].fail=tr[fl].son[i];
                q.push(y);
            }
            else y=tr[fl].son[i];
        }
    }
}
void build_failtree()
{
    len=0; //memset(fir,0,sizeof fir);
    for(int i=1;i<=tot;i++) ins(tr[i].fail,i);
}

int main()
{
    scanf("%s",str);
    build_trie();
    build_failtree();

    scanf("%d",&m);
    for(int i=1;i<=m;i++)
    {
        int x,y; scanf("%d%d",&x,&y);
        qi[i]=y;
        query[to[x+1]].push_back(i);
    }
    dfs(0);
    for(int i=1;i<=m;i++) printf("%d\n",ans[i]);

    return 0;
}