P4094 [HEOI2016/TJOI2016]字符串后缀数组+主席树+二分答案

$ \color{#0066ff}{ 题目描述 }$

佳媛姐姐过生日的时候，她的小伙伴从某东上买了一个生日礼物。生日礼物放在一个神奇的箱子中。箱子外边写了一个长为n的字符串s，和m个问题。佳媛姐姐必须正确回答这m个问题，才能打开箱子拿到礼物，升职加薪，出任CEO，嫁给高富帅，走上人生巅峰。每个问题均有a,b,c,d四个参数，问你子串s[a..b]的所有子串和s[c..d]的最长公共前缀的长度的最大值是多少？佳媛姐姐并不擅长做这样的问题，所以她向你求助，你该如何帮助她呢？

$\color{#0066ff}{输入格式}$

输入的第一行有两个正整数n,m，分别表示字符串的长度和询问的个数。接下来一行是一个长为n的字符串。接下来m行，每行有4个数a,b,c,d，表示询问s[a..b]的所有子串和s[c..d]的最长公共前缀的最大值。

$\color{#0066ff}{输出格式}$

对于每一次询问，输出答案。

$\color{#0066ff}{输入样例}$

$\color{#0066ff}{输出样例}$

$\color{#0066ff}{数据范围与提示}$

对于10%的数据，1<=n,m<=3,00,

对于40%的数据，1<=n,m<=3,000,字符串中仅有a,b

对于100%的数据，1<=n,m<=100,000,字符串中仅有小写英文字母，a<=b,c<=d,1<=a,b,c,d<=n

$\color{#0066ff}{题解}$

要求LCP，当然是SA啦

考虑暴力，枚举$[l,r]$每个位置，每次取max（注意卡边界）

因为LCP是区间的min，所以我们找到$rk[c]$的前驱后继RMQ一下不就行啦？

不行！

需要二分答案！！

为什么呢？？

举个栗子

$a = 1, b= 10, c =20, d = 30,即[1,10],[20,30]$

20位置和9位置的LCP的长度为200

但是由于区间限制，答案就成了$10-9+1=2$

而1位置和20位置的LCP为3，没有超过边界，所以就是3，显然更优

也就是说，LCP最大，答案不一定最优！！！

所以我们二分答案，假设当前二分的是mid，那么显然合法的端点区间为$[a,b-mid+1]$

我们在这个区间找前驱后继即可

怎么找？？区间前驱后继？？树套树？？

主席树不得了。。

TM，RMQ写错调了1.5h

// luogu-judger-enable-o2

#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 = 1e5 + 10;

int sa[maxn], rk[maxn], x[maxn], y[maxn], c[maxn], n, q, h[maxn], f[maxn][20], lg[maxn];

char s[maxn];

struct node {

	node *ch[2];

	int num;

	node() { num = 0; ch[0] = ch[1] = NULL; }

}*root[maxn];

void init() {

	root[0] = new node();

	root[0]->ch[0] = root[0]->ch[1] = root[0];

}

void add(node *&o, node *lst, int l, int r, int p) {

	o = new node();

	*o = *lst;

	o->num++;

	if(l == r) return;

	int mid = (l + r) >> 1;

	if(p <= mid) add(o->ch[0], lst->ch[0], l, mid, p);

	else add(o->ch[1], lst->ch[1], mid + 1, r, p);

}

int pre(node *x, node *y, int l, int r, int p) {

	if(x->num == y->num) return -1;

	if(l == r) return l;

	int mid = (l + r) >> 1;

	if(p <= mid + 1) return pre(x->ch[0], y->ch[0], l, mid, p);

	int ans = pre(x->ch[1], y->ch[1], mid + 1, r, p);

	if(~ans) return ans;

	return pre(x->ch[0], y->ch[0], l, mid, p);

}

int nxt(node *x, node *y, int l, int r, int p) {

	if(x->num == y->num) return -1;

	if(l == r) return l;

	int mid = (l + r) >> 1;

	if(p >= mid) return nxt(x->ch[1], y->ch[1], mid + 1, r, p);

	int ans = nxt(x->ch[0], y->ch[0], l, mid, p);

	if(~ans) return ans;

	return nxt(x->ch[1], y->ch[1], mid + 1, r, p);

}

void SA() {

	int m = 122;

	for(int i = 1; i <= n; i++) c[x[i] = s[i]]++;

	for(int i = 1; i <= m; i++) c[i] += c[i - 1];

	for(int i = n; i >= 1; i--) sa[c[x[i]]--] = i;

	for(int k = 1; k <= n; k <<= 1) {

		int num = 0;

		for(int i = n - k + 1; i <= n; i++) y[++num] = i;

		for(int i = 1; i <= n; i++) if(sa[i] > k) y[++num] = sa[i] - k;

		for(int i = 1; i <= m; i++) c[i] = 0;

		for(int i = 1; i <= n; i++) c[x[i]]++;

		for(int i = 1; i <= m; i++) c[i] += c[i - 1];

		for(int i = n; i >= 1; i--) sa[c[x[y[i]]]--] = y[i], y[i] = 0;

		std::swap(x, y);

		x[sa[1]] = 1, num = 1;

		for(int i = 2; i <= n; i++) x[sa[i]] = (y[sa[i - 1]] == y[sa[i]] && y[sa[i - 1] + k] == y[sa[i] + k])? num : ++num;

		if(num == n) break;

		m = num;

	}

	for(int i = 1; i <= n; i++) rk[i] = x[i];

	int H = 0;

	for(int i = 1; i <= n; i++) {

		if(rk[i] == 1) continue;

		if(H) H--;

		int j = sa[rk[i] - 1];

		while(i + H <= n && j + H <= n && s[i + H] == s[j + H]) H++;

		h[rk[i]] = H;

	}

	for(int i = 1; i <= n; i++) f[i][0] = h[i];

	for(int j = 1; j <= 18; j++)

		for(int i = 1; i + (1 << j) - 1 <= n; i++)

			f[i][j] = std::min(f[i][j - 1], f[i + (1 << (j - 1))][j - 1]);

	lg[0] = -1;

	for(int i = 1; i <= n; i++) lg[i] = lg[i >> 1] + 1;

}

int query(int l, int r) {

	if(l > r) std::swap(l, r);

	if(l == r) return n - sa[l] + 1;

	l++;

	int len = lg[r - l + 1];

	assert(l != 1);

	return std::min(f[l][len], f[r - (1 << len) + 1][len]);

}

bool ok(int a, int b, int c, int d, int mid) {

	int l = a, r = b - mid + 1, ans = 0;

	if(l > r) return false;

	int L = rk[c] == 1? -1 : pre(root[l - 1], root[r], 1, n, rk[c]);

	int R = rk[c] == n? -1 : nxt(root[l - 1], root[r], 1, n, rk[c]);

	if(~L) ans = std::max(ans, query(L, rk[c]));

	if(~R) ans = std::max(ans, query(rk[c], R));

	return ans >= mid;

}

void predoit() {

	init();

	for(int i = 1; i <= n; i++) add(root[i], root[i - 1], 1, n, rk[i]);

}

int main() {

	n = in(), q = in();

	scanf("%s", s + 1);

	SA();

	predoit();

	int a, b, c, d;

	while(q --> 0) {

		a = in(), b = in(), c = in(), d = in();

		int l = 1, r = std::min(d - c, b - a) + 1, ans = 0;

		while(l <= r) {

			int mid = (l + r) >> 1;

			if(ok(a, b, c, d, mid)) ans = mid, l = mid + 1;

			else r = mid - 1;

		}

		printf("%d\n", ans);

	}

	return 0;

}

巴特西

P4094 [HEOI2016/TJOI2016]字符串后缀数组+主席树+二分答案

$ \color{#0066ff}{ 题目描述 }$

\(\color{#0066ff}{输入格式}\)

\(\color{#0066ff}{输出格式}\)

\(\color{#0066ff}{输入样例}\)

\(\color{#0066ff}{输出样例}\)

\(\color{#0066ff}{数据范围与提示}\)

\(\color{#0066ff}{题解}\)

要求LCP，当然是SA啦

考虑暴力，枚举\([l,r]\)每个位置，每次取max（注意卡边界）

因为LCP是区间的min，所以我们找到\(rk[c]\)的前驱后继RMQ一下不就行啦？

不行！

需要二分答案！！

为什么呢？？

举个栗子

20位置和9位置的LCP的长度为200

但是由于区间限制，答案就成了\(10-9+1=2\)

而1位置和20位置的LCP为3，没有超过边界，所以就是3，显然更优

也就是说，LCP最大，答案不一定最优！！！

所以我们二分答案，假设当前二分的是mid，那么显然合法的端点区间为\([a,b-mid+1]\)

我们在这个区间找前驱后继即可

怎么找？？区间前驱后继？？树套树？？

主席树不得了。。

TM，RMQ写错调了1.5h

最新文章

热门文章

巴特西

P4094 [HEOI2016/TJOI2016]字符串 后缀数组+主席树+二分答案

$ \color{#0066ff}{ 题目描述 }$

\(\color{#0066ff}{输入格式}\)

\(\color{#0066ff}{输出格式}\)

\(\color{#0066ff}{输入样例}\)

\(\color{#0066ff}{输出样例}\)

\(\color{#0066ff}{数据范围与提示}\)

\(\color{#0066ff}{题解}\)

要求LCP，当然是SA啦

考虑暴力，枚举\([l,r]\)每个位置，每次取max（注意卡边界）

因为LCP是区间的min，所以我们找到\(rk[c]\)的前驱后继RMQ一下不就行啦？

不行！

需要二分答案！！

为什么呢？？

举个栗子

20位置和9位置的LCP的长度为200

但是由于区间限制，答案就成了\(10-9+1=2\)

而1位置和20位置的LCP为3，没有超过边界，所以就是3， 显然更优

也就是说，LCP最大，答案不一定最优！！！

所以我们二分答案，假设当前二分的是mid，那么显然合法的端点区间为\([a,b-mid+1]\)

我们在这个区间找前驱后继即可

怎么找？？区间前驱后继？？树套树？？

主席树不得了。。

TM，RMQ写错调了1.5h

最新文章

热门文章

P4094 [HEOI2016/TJOI2016]字符串后缀数组+主席树+二分答案

而1位置和20位置的LCP为3，没有超过边界，所以就是3，显然更优