BZOJ2434 [Noi2011]阿狸的打字机【AC自动机 + fail树 + 树状数组】

2434: [Noi2011]阿狸的打字机

Time Limit: 10 Sec Memory Limit: 256 MB

Submit: 3610 Solved: 1960

[Submit][Status][Discuss]

Description

阿狸喜欢收藏各种稀奇古怪的东西，最近他淘到一台老式的打字机。打字机上只有28个按键，分别印有26个小写英文字母和’B’、’P’两个字母。

经阿狸研究发现，这个打字机是这样工作的：

l 输入小写字母，打字机的一个凹槽中会加入这个字母(这个字母加在凹槽的最后)。

l 按一下印有’B’的按键，打字机凹槽中最后一个字母会消失。

l 按一下印有’P’的按键，打字机会在纸上打印出凹槽中现有的所有字母并换行，但凹槽中的字母不会消失。

例如，阿狸输入aPaPBbP，纸上被打印的字符如下：

我们把纸上打印出来的字符串从1开始顺序编号，一直到n。打字机有一个非常有趣的功能，在打字机中暗藏一个带数字的小键盘，在小键盘上输入两个数(x,y)（其中1≤x,y≤n），打字机会显示第x个打印的字符串在第y个打印的字符串中出现了多少次。

阿狸发现了这个功能以后很兴奋，他想写个程序完成同样的功能，你能帮助他么？

Input

输入的第一行包含一个字符串，按阿狸的输入顺序给出所有阿狸输入的字符。

第二行包含一个整数m，表示询问个数。

接下来m行描述所有由小键盘输入的询问。其中第i行包含两个整数x, y，表示第i个询问为(x, y)。

Output

输出m行，其中第i行包含一个整数，表示第i个询问的答案。

Sample Input

aPaPBbP

1 2

1 3

2 3

Sample Output

HINT

1<=N<=10^5

1<=M<=10^5输入总长<=10^5

写出这道题，用裸的AC自动机肯定T

由题目字符串构建的形式，我们很容易想到trie树，可以很快建好一个AC自动机

对于询问(x,y)，我们只要找出根到y末节点有多少个节点的fail指向x末端就好了【因为fail指针指向最长等于后缀的字符串】

直接统计？那也会T

直接统计是拿y以上节点去统计x，是多对一，非常浪费时间，但如果我们转化为一对多呢？就是拿x去找有多少属于y 的节点的fail指针指向x

这就引进了fail树

fail数，实质上就是把AC自动机的原边去掉，用fail边建立成的树

这样的树有一个很优美的性质，就是所有fail指针间接或直接指向u节点的节点共同组成u的子树，我们对于每个询问(x,y)，我们只需查找x的子树中有多少个节点属于y就好了

怎么做呢？

求一个dfs序，可以用树状数组维护节点值，我们将属于y的询问放一起，属于y的节点全部+1，这样子只需要统计x子树之和就好了

具体操作时我们可以重新走一遍构造trie的路程，将路过的节点对应的值+1，向上时-1，每遇到一个单词末尾就将它的所有询问算出来

完美解决【md调了我一个下午= =，我代码能力还是太弱了】

调试点：

①树状数组的边界弄错

②节点+1 与节点向下的次序弄反

③根节点标号不统一

我**真是太弱了

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cctype>
#include<queue>
#include<algorithm>
#define LL long long int
#define REP(i,n) for (int i = 1; i <= (n); i++)
#define fo(i,x,y) for (int i = (x); i <= (y); i++)
#define Redge(u) for (int k = head[u]; k != -1; k = edge[k].next)
#define lbt(x) (x & -x)
using namespace std;
const int maxn = 100005,maxm = 100005,INF = 1000000000;
inline int read(){
int out = 0,flag = 1;char c = getchar();
while (c < 48 || c > 57) {if (c == '-') flag = -1; c = getchar();}
while (c >= 48 && c <= 57) {out = out * 10 + c - 48; c = getchar();}
return out * flag;
}
int m,head[maxn],qh[maxn],ch[maxn][26],siz = 0,E[maxn],pre[maxn],fail[maxn],cnt = 0;
int id[maxn],Siz[maxn],nedge = 0,nq = 0;
int A[maxn],ans[maxn];
char s[maxn];
struct EDGE{int to,next;}edge[maxn],q[maxn];
inline void build(int u,int v){edge[nedge] = (EDGE){v,head[u]}; head[u] = nedge++;}
inline void add(int u,int v){while (u <= cnt) {A[u] += v; u += lbt(u);}}
inline int Query(int u){int ans = 0; while (u > 0) {ans += A[u]; u -= lbt(u);} return ans;}
inline int sum(int l,int r){return Query(r) - Query(l - 1);}
void insert(){
int u = 0,T = 0,i = 0,id;
while (isalpha(s[i])){
if (s[i] == 'P') E[++T] = u;
else if (s[i] == 'B') u = pre[u];
else {
if (!ch[u][id = s[i] - 'a']) {ch[u][id] = ++siz; pre[siz] = u;}
u = ch[u][id];
}
i++;
}
}
void getf(){
queue<int> q; int u,v;
for (int i = 0; i < 26; i++) if (ch[0][i]) q.push(ch[0][i]);
while (!q.empty()){
u = q.front();
q.pop();
for (int i = 0; i < 26; i++){
v = ch[u][i];
if (!v) ch[u][i] = ch[fail[u]][i];
else fail[v] = ch[fail[u]][i],q.push(v);
}
}
}
void dfs(int u){
id[u] = ++cnt; Siz[u] = 1; int to;
Redge(u) {
dfs(to = edge[k].to);
Siz[u] += Siz[to];
}
}
void solve(){
int u = 0,i = 0,p = 0;
while (isalpha(s[i])){
if (s[i] == 'B') add(id[u],-1),u = pre[u];
else if (s[i] == 'P'){
p++;
for (int k = qh[p]; k != -1; k = q[k].next){
int v = E[q[k].to]; /*cout<<q[k].to<<' '<<p<<endl;
cout<<"   "<<u<<' '<<v<<endl;
cout<<"      "<<id[v]<<' '<<id[v] + Siz[v] - 1<<endl;
cout<<sum(id[v],id[v] + Siz[v] - 1)<<endl;*/
ans[k] = sum(id[v],id[v] + Siz[v] - 1);
}
}else u = ch[u][s[i] - 'a'],add(id[u],1);
i++;
}
}
void init(){
memset(head,-1,sizeof(head));
memset(qh,-1,sizeof(qh));
scanf("%s",s);
insert(); getf();
for (int i = 1; i <= siz; i++) build(fail[i],i);
dfs(0);
m = read(); int x,y;
REP(i,m){
x = read(); y = read();
q[nq] = (EDGE){x,qh[y]}; qh[y] = nq++;
}
}
int main()
{
init();
//for (int i = 0; i <= siz; i++) cout<<id[i]<<' ';cout<<endl;
solve();
for (int i = 0; i < m; i++) printf("%d\n",ans[i]);
return 0;
}