@bzoj - 3881@ [Coci2015]Divljak


@description@

Alice有n个字符串S_1,S_2...S_n,Bob有一个字符串集合T,一开始集合是空的。
接下来会发生q个操作,操作有两种形式:
“1 P”,Bob往自己的集合里添加了一个字符串P。
“2 x”,Alice询问Bob,集合T中有多少个字符串包含串S_x。(我们称串A包含串B,当且仅当B是A的子串)
Bob遇到了困难,需要你的帮助。

Input
第1行,一个数n;接下来n行,每行一个字符串表示S_i;
下一行,一个数q;接下来q行,每行一个操作,格式见题目描述。

Output
对于每一个Alice的询问,帮Bob输出答案。

Sample Input
3
a
bc
abc
5
1 abca
2 1
1 bca
2 2
2 3
Sample Output
1
2
1

HINT
1 <= n,q <= 100000;
Alice和Bob拥有的字符串长度之和各自都不会超过 2000000;
字符串都由小写英文字母组成。

@solution@

如果考虑将 T 用个什么东西维护起来,然后把 S 拿上去跑,无论在线还是离线都没什么办法快速维护。

我们考虑对所有 S 串建 AC 自动机,然后把 T 拿上去跑。
因为 T 的每一个前缀的后缀都是 T 的子串,而 AC 自动机中的 fail 对应的正是该节点的最长可能匹配的后缀。
我们不妨把 T 的每一个前缀对应的点 x 在 fail 树上做个 x 到 root 的整体链 + 1,就可以快速地将 T 的每个子串更新。

然而。。。这样看似很棒,但其实有一点小小的问题:假如某个子串在 T 中出现了多次,那么上面那个维护方法也会累加多次。
但是我们只需要一次:即表示这个串是 T 的子串,而不是表示这个串在 T 出现了多少次。
我们可以将所有链取并集,做一个“链并加”,这样就可以达到我们的目的了。

具体到实现,我们可以类比虚树,将所有点按照 dfs 访问的时间排序。然后在每个点到根的链 + 1 后,将排序后相邻两个点的 lca 到根的链 - 1。
链加与单点查询可以简单地转为单点加与子树查询,这样就可以 dfs 序上树状数组维护。

时间复杂度 O(nlogn)。

@accepted code@

#include<queue>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN = 100000;
const int MAXS = 2000000;
struct BIT{
	int tree[MAXS + 5], tot;
	int lowbit(int x) {return x & (-x);}
	void update(int x, int k) {
		for(int i=x;i<=tot;i+=lowbit(i))
			tree[i] += k;
//		printf(". %d %d\n", x, k);
	}
	int sum(int x) {
		int ret = 0;
		for(int i=x;i;i-=lowbit(i))
			ret += tree[i];
		return ret;
	}
}T;
struct Graph{
	struct edge{
		edge *nxt;
		int to;
	}edges[MAXS + 5], *adj[MAXS + 5], *ecnt;
	Graph() {ecnt = &edges[0];}
	void addedge(int u, int v) {
		edge *p = (++ecnt);
		p->to = v, p->nxt = adj[u], adj[u] = p;
//		printf("! %d %d\n", u, v);
	}
	int siz[MAXS + 5], dep[MAXS + 5], hvy[MAXS + 5], fa[MAXS + 5];
	void dfs1(int x, int f) {
		siz[x] = 1; fa[x] = f; dep[x] = dep[f] + 1; hvy[x] = 0;
		for(edge *p=adj[x];p;p=p->nxt) {
			if( p->to == f ) continue;
			dfs1(p->to, x);
			siz[x] += siz[p->to];
			if( siz[p->to] > siz[hvy[x]] )
				hvy[x] = p->to;
		}
	}
	int tid[MAXS + 5], dfn[MAXS + 5], top[MAXS + 5], dcnt;
	void dfs2(int x, int tp) {
		top[x] = tp; dfn[++dcnt] = x; tid[x] = dcnt;
		if( hvy[x] ) dfs2(hvy[x], tp);
		for(edge *p=adj[x];p;p=p->nxt) {
			if( p->to == fa[x] || p->to == hvy[x] ) continue;
			dfs2(p->to, p->to);
		}
	}
	void build() {dfs1(1, 0); dfs2(1, 1); T.tot = dcnt;}
	int lca(int u, int v) {
		while( top[u] != top[v] ) {
			if( dep[top[u]] < dep[top[v]] ) swap(u, v);
			u = fa[top[u]];
		}
		if( dep[u] < dep[v] ) swap(u, v);
		return v;
	}
}G;
bool cmp(int x, int y) {return G.tid[x] < G.tid[y];}
struct ACM{
	struct node{int ch[26], fail;}nd[MAXS + 5];
	int root, ncnt;
	ACM() {root = ncnt = 0;}
	int add_string(char *S) {
		int lenS = strlen(S), nw = root;
		for(int i=0;i<lenS;i++) {
			if( !nd[nw].ch[S[i] - 'a'] )
				nd[nw].ch[S[i] - 'a'] = (++ncnt);
			nw = nd[nw].ch[S[i] - 'a'];
		}
		return nw + 1;
	}
	void link(int a, int b) {
		nd[b].fail = a, G.addedge(a + 1, b + 1);
	}
	int arr[MAXS + 5];
	void build() {
		int hd = 1, tl = 0;
		for(int i=0;i<26;i++)
			if( nd[root].ch[i] ) {
				arr[++tl] = nd[root].ch[i];
				link(root, nd[root].ch[i]);
			}
			else nd[root].ch[i] = root;
		while( hd <= tl ) {
			int f = arr[hd++];
			for(int i=0;i<26;i++) {
				if( !nd[f].ch[i] )
					nd[f].ch[i] = nd[nd[f].fail].ch[i];
				else {
					arr[++tl] = nd[f].ch[i];
					link(nd[nd[f].fail].ch[i], nd[f].ch[i]);
				}
			}
		}
	}
	void modify(char *S) {
		int rt = root; int lenS = strlen(S);
		for(int i=0;i<lenS;i++) {
			rt = nd[rt].ch[S[i] - 'a'];
			arr[i] = rt + 1;
//			printf("? %d %d\n", arr[i], rt - pl + 1);
		}
		sort(arr, arr + lenS, cmp);
		for(int i=0;i<lenS;i++) T.update(G.tid[arr[i]], 1);
		for(int i=1;i<lenS;i++) T.update(G.tid[G.lca(arr[i-1], arr[i])], -1);
	}
}ac;
char S[MAXS + 5];
int id[MAXN + 5];
int main() {
	int n, q; scanf("%d", &n);
	for(int i=1;i<=n;i++) {
		scanf("%s", S);
		id[i] = ac.add_string(S);
	}
	ac.build(), G.build();
	scanf("%d", &q);
	for(int i=1;i<=q;i++) {
		int op; scanf("%d", &op);
		if( op == 1 ) {
			scanf("%s", S);
			ac.modify(S);
		}
		else {
			int x; scanf("%d", &x);
			printf("%d\n", T.sum(G.tid[id[x]] + G.siz[id[x]] - 1) - T.sum(G.tid[id[x]] - 1));
		}
	}
}

@details@

这道题。。。它卡我倍增的 lca 的空间。。。我写了树链剖分求 lca 才过的。。。

顺便这道题也可以用 sam 建,不过就有些大材小用之感。。。

posted @ 2019-08-16 09:47  Tiw_Air_OAO  阅读(132)  评论(0编辑  收藏  举报