[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][],fail[N];
     void get_trie()
     {
         cnt=;
         int i,now=,v,p=;
         for (i=;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=;i<;i++) son[][i]=;
     }
     void get_fail()
     {
         int i,j,x;
         q.push();
         while (!q.empty())
         {
             x=q.front(),q.pop();
             for (i=;i<;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=;
         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+);
         for (int i=;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=;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]-);
 }

 void answer()
 {
     int m,i,j,y,v,p;
     scanf("%d",&m);
     memset(now,,sizeof(now));
     for (i=;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=,i=;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],-);
                 p=aca.fa[p];
                 break;
             }
             default:
             {
                 v=s[i]-'a';
                 p=aca.son[p][v];
                 bit.add(bit.l[p],);
             }
         }
     }
     for (i=;i<=m;i++)
         printf("%d\n",ans[i]);
 }

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