[NOI 2011][BZOJ 2434] 阿狸的打字机

传送门

AC自动机 + 树状数组

建成AC自动机后，设end[i]为第i个串的末尾在Trie树上的节点。

可以发现，对于一个询问(x,y)，ans等于Trie树上root到end[y]这条链上fail指针指向end[x]的节点数，我们把这些点记为特殊点

因为Trie树上每个节点fail指针仅指向一个值，

因此可以将fail指针反转构建一棵树，以下称为fail树。

于此答案可以等价于在fail树上以end[x]为根的子树中存在的特殊点个数。

然而这样暴力做还是过不了。于是需要一些优化。

可以知道将一个树的节点按dfs序排列后，

树的任意一颗子树的节点在序列中都是连续的一段区间。

我们把特殊的点记为1，非特殊点记为0，

于是求某子树上的特殊点个数可以转化成求某区间的和，

于是就可以用树状数组来优化了。（线段树应该也可以吧，不过似乎会比较麻烦）。

代码：

#include<cstdio>
#include<queue>
#include<algorithm>
#include<cstring>

using namespace std;

#define N ((1<<17)-1)
#define M ((1<<17)-1)
#define lowbit(x) ((x)&(-(x)))

queue<int>q;
char s[N];
int end[N],n;

struct ACA
{
    int cnt;
    int fa[N],son[N][26],fail[N];
    void get_trie()
    {
        cnt=1;
        int i,now=1,v,p=0;
        for (i=0;i<n;i++)
            switch(s[i])
            {
                case 'P':{end[++p]=now;break;}
                case 'B':{now=fa[now];break;}
                default:
                {
                    v=s[i]-'a';
                    if (!son[now][v])
                    {
                        son[now][v]=++cnt;
                        fa[cnt]=now;    
                    }
                    now=son[now][v];
                }
            }
        for (i=0;i<26;i++) son[0][i]=1; 
    }
    void get_fail()
    {
        int i,j,x;
        q.push(1);
        while (!q.empty())
        {
            x=q.front(),q.pop();
            for (i=0;i<26;i++)
                if (son[x][i])
                {
                    for (j=fail[x];j&&!son[j][i];j=fail[j]);
                    fail[son[x][i]]=son[j][i];
                    q.push(son[x][i]);
                }
        }
    }
}aca;

struct BIT
{
    int arr[N],l[N],r[N];
    int sum(int i)
    {
        int re=0;
        while (i)
        {re+=arr[i];i-=lowbit(i);}
        return re;
    }
    void add(int i,int k)
    {
        while (i<=aca.cnt)
        {arr[i]+=k;i+=lowbit(i);}    
    }
}bit;


struct Tree
{
    vector<vector<int> >son;
    void addedge(int u,int v)
    {
        son[u].push_back(v);
    }
    void build()
    {
        son.resize(aca.cnt+1);
        for (int i=2;i<=aca.cnt;i++)
        addedge(aca.fail[i],i);
    }
    void dfs_order(int x,int &k)
    {
        bit.l[x]=bit.r[x]=k++;
        for (int i=0;i<son[x].size();i++)
        {
            dfs_order(son[x][i],k);
            bit.r[x]=max(bit.r[x],bit.r[son[x][i]]);
        }
    }
}tree;

int x[M],ans[M],pre[N],now[N];

inline int val(int x)
{
    return bit.sum(bit.r[x])-bit.sum(bit.l[x]-1);
}

void answer()
{
    int m,i,j,y,v,p;
    scanf("%d",&m);
    memset(now,0,sizeof(now));
    for (i=1;i<=m;i++)
    {
        scanf("%d%d",&x[i],&y);
        x[i]=end[x[i]];
        y=end[y];
        pre[i]=now[y];
        now[y]=i;
    }
    for (p=1,i=0;i<n;i++)
    {
        switch(s[i])
        {
            case 'P':
            {
                for (j=now[p];j;j=pre[j])
                    ans[j]=val(x[j]);
                break;
            }
            case 'B':
            {
                bit.add(bit.l[p],-1);
                p=aca.fa[p];
                break;
            }
            default:
            {
                v=s[i]-'a';
                p=aca.son[p][v];
                bit.add(bit.l[p],1);
            }
        }
    }
    for (i=1;i<=m;i++)
        printf("%d
",ans[i]);
}

int main()
{
    scanf("%s",s);
    n=strlen(s);
    aca.get_trie();
    aca.get_fail();
    tree.build();
    int k=1;
    tree.dfs_order(1,k);
    answer();
}