bzoj2434(NOI2011).阿狸的打字机(AC自动机 && DFS序 && 树状数组)

阿狸喜欢收藏各种稀奇古怪的东西，最近他淘到一台老式的打字机。打字机上只有28个按键，分别印有26个小写英文字母和 'B'、'P'两个字母。经阿狸研究发现，这个打字机是这样工作的：

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

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

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

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

a

aa

ab

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

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

第一想法：暴力。首先按规则生成出字符串，然后暴力的计算x 在y 中出现了多少次，时间复杂度 O(nL^2)；优化：KMP 可优化到O(nL)。但是因为数据都是 10^5级别的，所以依然无法通过。

又因为是多串匹配问题，想到了AC自动机。如果一个字符串x 在字符串y 中出现了
n 次，那么在从 Trie 树中从 root 到y 的结尾节点的这条链上有
n 个点的 fail 指针指向了x 的结尾节点。但是如果这样转移还是会 TLE。这时候就要用神奇的传说中的fail树：其实也就是把
fail 指针反向建出来一棵树，为什么一定会是树呢，因为原 Trie 树中的节点必定有且仅有一个fail 指针，那么现在将
fail 指针反向，每个点的入度一定为1，所以一定是一棵树。然后如果一个字符串 x在字符串 y 中出现了n次，就意味着在 fail树中以x
结尾节点为根的子树中，有 n 个属于 y 字符串的节点。同时我们知道一个树的子树在这棵树的先序DFS序中是连续的一段，那么根据这个性质，我们就可以用树状数组，在O(log n) 的时间复杂度内修改并统计答案。这道题就解决了。

具体见CODE：

#include <cstdio>
#include <vector>
#include <cstring>

using namespace std;

const int MAX_N = 100005;

char p[MAX_N];
int len, m, tot, pos[MAX_N];
vector < pair<int, int> > vec[MAX_N];

struct Trie {
int ch[26], fl, fa, ed;
} t[MAX_N];
int sz = 0;

void build()
{
int u = 0;
for (int i = 1; i <= len; i ++) {
if (p[i] == 'B') u = t[u].fa;
else if (p[i] == 'P') t[u].ed = 1, tot ++, pos[tot] = u;
else {
int c = p[i] - 'a';
if (!t[u].ch[c]) t[u].ch[c] = ++ sz, t[t[u].ch[c]].fa = u;
u = t[u].ch[c];
}
}
}

void init()
{
scanf("%s", p + 1);
len = strlen(p + 1);
scanf("%d", &m);
for (int i = 1, x, y; i <= m; i ++)
scanf("%d%d", &x, &y),
vec[y].push_back(make_pair(x, i));
build();
}

int q[MAX_N * 10];
struct Tree {
int v, next;
} E[MAX_N << 1];
int head[MAX_N], top = 0;

void add(int u, int v)
{
E[++ top].v = v; E[top].next = head[u]; head[u] = top;
}

void get_Fail()
{
int hd = 0, tl = 0;
t[0].fl = 0;
for (int c = 0; c < 26; c ++)
if (t[0].ch[c]) {
t[t[0].ch[c]].fl = 0;
q[++ tl] = t[0].ch[c];
}
while (hd < tl) {
int r = q[++ hd];
for (int c = 0; c < 26; c ++) {
if (!t[r].ch[c]) {
t[r].ch[c] = t[t[r].fl].ch[c];
continue;
}
q[++ tl] = t[r].ch[c];
int u = t[r].ch[c], v = t[r].fl;
while (v && !t[v].ch[c]) v = t[v].fl;
t[u].fl = t[v].ch[c];
}
}
memset(head, -1, sizeof(head));
for (int i = 1; i <= sz; i ++)
add(t[i].fl, i), add(i, t[i].fl);
}

int L[MAX_N], R[MAX_N], tm = 0;

void dfs(int x, int last)
{
L[x] = ++ tm;
for (int i = head[x]; i != -1; i = E[i].next)
if (E[i].v != last) dfs(E[i].v, x);
R[x] = tm;
}

int c[MAX_N * 10], ans[MAX_N];

void Add(int x, int cnt) { for (; x <= tm; x += (x & -x)) c[x] += cnt; }
int Qry(int x) { int ret = 0; for (; x > 0; x -= (x & -x)) ret += c[x]; return ret; }

void doit()
{
get_Fail();
dfs(0, 0);
int u = 0, now = 0;
for (int i = 1; i <= len; i ++) {
if (p[i] == 'P') {
now ++;
//printf("%d:\n", now);
//for (int i = 1; i <= tm; i ++) printf("%d ", c[i]); printf("\n");
for (int j = 0; j < vec[now].size(); j ++) {
int x = vec[now][j].first, id = vec[now][j].second;
//printf("%d %d\n", x, id);
//printf("%d %d~%d\n", id, L[pos[x]], R[pos[x]]);
ans[id] += Qry(R[pos[x]]) - Qry(L[pos[x]] - 1);
}
} else if (p[i] == 'B') {
//printf("%d~%d -1\n", L[u], R[u]);
Add(L[u], -1);
u = t[u].fa;
} else {
u = t[u].ch[p[i] - 'a'];
//printf("%d~%d +1\n", L[u], R[u]);
Add(L[u], 1);
}
}
for (int i = 1; i <= m; i ++) printf("%d\n", ans[i]);
}

int main()
{
init();
doit();
return 0;
}