Processing math: 100%

CF666E Forensic Examination SAM+线段树合并+前缀树倍增

给你一个串S以及一个字符串数组T[1..m]q次询问,每次问S的子串S[pl..pr]T[l..r]中的哪个串里的出现次数最多,并输出出现次数。

如有多解输出最靠前的那一个。

第一行一个个字符串表示S
第二行一个数字m
接下来m行每行一个字符串表示T[i]
接下来一行一个数字q表示询问次数
接下来q行每行四个数字l,r,ql,qr表示一个询问

q行每行两个数字表示出现位置和次数

suffixtree
3
suffixtreesareawesome
cartesiantreeisworsethansegmenttree
nyeeheeheee
2
1 2 1 10
1 3 9 10

1 1
3 4

1<=∣s∣<=5105,1<=m<=5104,1<=q<=5105

考虑暴力,我们可以建立m个后缀自动机,然后暴力匹配, 复杂度是O(nmq)

这样无论如何都要枚举m个后缀自动机,复杂度是无法优化的

我们考虑另一种思路,建立广义后缀自动机,每个节点记录一下属于哪个串bel,那么如果我们匹配之后到了某个点,我们需要在这个点的前缀树的子树内找到一个出现次数最多的bel且bel尽量小(靠左)

也就是找子树最大值以及位置,我们考虑对前缀树上的每个点开一个动态开点线段树,维护子树内bel的最大值以及位置,这个刚开始可以先在extend中记录维护自己的东西,然后dfs前缀树,把子树内的线段树合并,这样每个点维护的就是子树内的线段树了

于是对于一个询问,我们暴力匹配它的字串,跳到那个点,然后在那个点的线段树上查询就行了

于是我们的复杂度由O(nmq)降到了O(qnlogm)

但是这样依然是过不了,时间浪费在了匹配上

我们考虑优化匹配这个过程

考虑在前缀树上倍增,因为每次跳父亲就是删去前面若干字符,所以我们可以先预处理出S的每个前缀在后缀自动机上的匹配情况,记录一下这个前缀的最长匹配后缀和匹配到的节点

对于一个询问, 字串[l,r],我们直接找到S[1...r]的匹配节点,然后倍增往上跳,删去l前面的节点, 就是我们匹配的节点,然后再线段树查询就行了

这样O(qlognlogm)就能过了

#include<bits/stdc++.h>
#define LL long long
LL in() {
	char ch; LL x = 0, f = 1;
	while(!isdigit(ch = getchar()))(ch == '-') && (f = -f);
	for(x = ch ^ 48; isdigit(ch = getchar()); x = (x << 1) + (x << 3) + (ch ^ 48));
	return x * f;
}
const int maxn = 7e5 + 100;
struct Tree {
	protected:
		struct node {
			node *ch[2];
			int max, pos;
			node(int max = 0, int pos = 0): max(max), pos(pos) { ch[0] = ch[1] = NULL; }
			void upd() {
				if(!ch[0] && !ch[1]) return;
				if(!ch[0]) max = ch[1]->max, pos = ch[1]->pos;
				else if(!ch[1]) max = ch[0]->max, pos = ch[0]->pos;
				else { 
					if(ch[0]->max >= ch[1]->max) max = ch[0]->max, pos = ch[0]->pos;
					else max = ch[1]->max, pos = ch[1]->pos;
				}
			}
		}*root[maxn];
		int n;
		void add(node *&o, int l, int r, int pos, int val) {
			if(!o) o = new node();
			if(l == r) return (void)(o->max += val, o->pos = l);
			int mid = (l + r) >> 1;
			if(pos <= mid) add(o->ch[0], l, mid, pos, val);
			else add(o->ch[1], mid + 1, r, pos, val);
			o->upd();
		}
		std::pair<int, int> query(node *o, int l, int r, int ql, int qr) {
			if(!o) return std::make_pair(0, ql);
			if(ql <= l && r <= qr) return std::make_pair(o->max, o->pos);
			int mid = (l + r) >> 1;
			if(qr <= mid) return query(o->ch[0], l, mid, ql, qr);
			if(ql > mid) return query(o->ch[1], mid + 1, r, ql, qr);
			std::pair<int, int> ansl = query(o->ch[0], l, mid, ql, qr);
			std::pair<int, int> ansr = query(o->ch[1], mid + 1, r, ql, qr);
			if(ansl.first >= ansr.first) return ansl;
			return ansr;
		}
		node *merge(node *x, node *y, int l, int r) {
			if(!x || !y) return x? x : y;
			node *o = new node();
			if(l == r) return o->max = x->max + y->max, o->pos = l, o;
			int mid = (l + r) >> 1;
			o->ch[0] = merge(x->ch[0], y->ch[0], l, mid);
			o->ch[1] = merge(x->ch[1], y->ch[1], mid + 1, r);
			return o->upd(), o;
		}
	public:
		void set(int n) { this->n = n; }
		void add(int id, int pos, int val) { add(root[id], 1, n, pos, val); }
		std::pair<int, int> query(int id, int l, int r) { return query(root[id], 1, n, l, r); }
		void merge(int x, int y) { root[x] = merge(root[x], root[y], 1, n); }
}T;
struct node {
	node *ch[26], *fa;
	std::vector<node *> treech;
	int len;
	node(int len = 0): len(len) { 
		memset(ch, 0, sizeof ch); fa = NULL; treech.clear(); 
	}
}pool[maxn << 1], *tail, *lst, *root;
void init() {
	tail = pool;
	root = lst = new(tail++) node();
}
void extend(int c, int id) {
	node *o = new(tail++) node(lst->len + 1), *v = lst;
	T.add(o - pool, id, 1);
	for(; v && !v->ch[c]; v = v->fa) v->ch[c] = o;
	if(!v) o->fa = root;
	else if(v->len + 1 == v->ch[c]->len) o->fa = v->ch[c];
	else {
		node *n = new(tail++) node(v->len + 1), *d = v->ch[c];
		std::copy(d->ch, d->ch + 26, n->ch);
		n->fa = d->fa, d->fa = o->fa = n;
		for(; v && v->ch[c] == d; v = v->fa) v->ch[c] = n;
	}
	lst = o;
}
int f[maxn << 1][22];
void build() {
	for(node *o = pool + 1; o != tail; o++) {
		o->fa->treech.push_back(o);
		f[o - pool][0] = o->fa - pool;
	}
}
void dfs(node *o) {
	for(node *to : o->treech) dfs(to), T.merge(o - pool, to - pool);
}
char s[maxn], ls[maxn];
int len, m, matchmax[maxn], matchpos[maxn];
void match() {
	int nowlen = 0; node *o = root;
	for(int i = 1; i <= len; i++) {
		int p = s[i] - 'a';
		if(o->ch[p]) o = o->ch[p], nowlen++;
		else {
			while(o != root && !o->ch[p]) o = o->fa, nowlen = o->len;
			if(o->ch[p]) o = o->ch[p], nowlen++;
		}
		matchmax[i] = nowlen;
		matchpos[i] = o - pool;
	}
}
void getans(int ql, int qr, int l, int r) {
	if(matchmax[r] < r - l + 1) return (void)(printf("%d %d\n", ql, 0));
	int x = matchpos[r];
	for(int i = 20; i >= 0; i--) if((pool + f[x][i])->len >= r - l + 1) x = f[x][i];
	std::pair<int, int> ans = T.query(x, ql, qr);
	printf("%d %d\n", ans.second, ans.first);
}

int main() {
	scanf("%s", s + 1);
	len = strlen(s + 1);
	T.set(m = in()); init();
	for(int i = 1; i <= m; i++) {
		scanf("%s", ls);
		lst = root;
		for(char *p = ls; *p; p++) extend(*p - 'a', i);
	}
	build();
	dfs(root);
	match();
	for(int j = 1; j <= 20; j++)
		for(int i = 1; i <= tail - pool - 1; i++)
			f[i][j] = f[f[i][j - 1]][j - 1];
	int l, r, ql, qr;
	for(int T = in(); T --> 0;) {
		l = in(), r = in(), ql = in(), qr = in();
		getans(l, r, ql, qr);
	}
	return 0;
}
posted @   olinr  阅读(288)  评论(1编辑  收藏  举报
编辑推荐:
· .NET 依赖注入中的 Captive Dependency
· .NET Core 对象分配(Alloc)底层原理浅谈
· 聊一聊 C#异步 任务延续的三种底层玩法
· 敏捷开发:如何高效开每日站会
· 为什么 .NET8线程池 容易引发线程饥饿
阅读排行:
· 终于决定:把自己家的能源管理系统开源了!
· C#实现 Winform 程序在系统托盘显示图标 & 开机自启动
· 了解 ASP.NET Core 中的中间件
· 实现windows下简单的自动化窗口管理
· 【C语言学习】——命令行编译运行 C 语言程序的完整流程
点击右上角即可分享
微信分享提示