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∣<=5∗105,1<=m<=5∗104,1<=q<=5∗105
题解
考虑暴力,我们可以建立m个后缀自动机,然后暴力匹配, 复杂度是O(nmq)的
这样无论如何都要枚举m个后缀自动机,复杂度是无法优化的
我们考虑另一种思路,建立广义后缀自动机,每个节点记录一下属于哪个串bel,那么如果我们匹配之后到了某个点,我们需要在这个点的前缀树的子树内找到一个出现次数最多的bel且bel尽量小(靠左)
也就是找子树最大值以及位置,我们考虑对前缀树上的每个点开一个动态开点线段树,维护子树内bel的最大值以及位置,这个刚开始可以先在extend中记录维护自己的东西,然后dfs前缀树,把子树内的线段树合并,这样每个点维护的就是子树内的线段树了
于是对于一个询问,我们暴力匹配它的字串,跳到那个点,然后在那个点的线段树上查询就行了
于是我们的复杂度由O(nmq)降到了O(q∗n∗logm)
但是这样依然是过不了,时间浪费在了匹配上
我们考虑优化匹配这个过程
考虑在前缀树上倍增,因为每次跳父亲就是删去前面若干字符,所以我们可以先预处理出S的每个前缀在后缀自动机上的匹配情况,记录一下这个前缀的最长匹配后缀和匹配到的节点
对于一个询问, 字串[l,r],我们直接找到S[1...r]的匹配节点,然后倍增往上跳,删去l前面的节点, 就是我们匹配的节点,然后再线段树查询就行了
这样O(q∗logn∗logm)就能过了
#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;
}
----olinr
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】博客园携手 AI 驱动开发工具商 Chat2DB 推出联合终身会员
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· .NET 依赖注入中的 Captive Dependency
· .NET Core 对象分配(Alloc)底层原理浅谈
· 聊一聊 C#异步 任务延续的三种底层玩法
· 敏捷开发:如何高效开每日站会
· 为什么 .NET8线程池 容易引发线程饥饿
· 终于决定:把自己家的能源管理系统开源了!
· C#实现 Winform 程序在系统托盘显示图标 & 开机自启动
· 了解 ASP.NET Core 中的中间件
· 实现windows下简单的自动化窗口管理
· 【C语言学习】——命令行编译运行 C 语言程序的完整流程