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 
#include 
#include 

using namespace std;

const int MAX_N = 100005;

char p[MAX_N];
int len, m, tot, pos[MAX_N];
vector < pair > 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;
}