洛谷 P4137 Rmq Problem / mex 可持久化线段树 / 莫队

https://www.luogu.com.cn/problem/P4137

 

解法1：可持久化线段树

因为需要查询区间内未出现过的自然数，维护的是数是否有出现，所以大概要往权值线段树那个方向靠

用tre[i]表示树节点  root[i]表示每一棵树的树根

对于第i颗树，其树上的叶子节点表示 ： 数组的第1~第i个数中，叶子节点所代表的那个数x出现的最靠右的距离

其余节点则维护节点儿子的最小值

对于l，r区间查询的时候，我们只需要对第r棵树查询，查询的时候可以直接查询其左儿子里面维护的值，假如这个值小于l，则表示左儿子所覆盖的数中至少有一个数出现的最靠右位置小于l，此时可以确定答案就在左儿子中，递归处理就可以了。否则递归处理右儿子。

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 4e5 + 7;
struct node {
	int l, r;
	int v;
}tre[MAXN * 20];
int root[MAXN];
int b[MAXN], num[MAXN];
int ind; 
int get_id(int x,int len) {
	return lower_bound(b + 1, b + 1 + len, x) - b;
}
void update(int l, int r, int &root,int las, int val, int aim) {
	tre[++ind] = tre[las];
	root = ind;
	//存1~i中最晚出现的下标
	if (l == r) {
		//tre[ind].v = val;
		tre[root].v = val;
		return;
	}
	int mid = l + r >> 1;
	if (aim <= mid)
		update(l, mid, tre[root].l, tre[las].l, val, aim);
	else
		update(mid + 1, r, tre[root].r, tre[las].r, val, aim);
	tre[root].v = min(tre[tre[root].l].v, tre[tre[root].r].v);
}
int query(int l, int r, int now, int lef) {
	if (!now || l == r) {
		return l;
	}
	int mid = l + r >> 1;
	if (tre[tre[now].l].v < lef)
		return query(l, mid, tre[now].l, lef);
	else
		return query(mid + 1, r, tre[now].r, lef);
}
int main() {
	int n, m;
	cin >> n >> m;
	int len = 0, inp;
	//b[++len] = 0;
	for (int i = 1; i <= n; i++) {
		scanf("%d", &inp);
		b[++len] = inp; 
		b[++len] = inp + 1;
		num[i] = inp;
	}
	sort(b + 1, b + 1 + len); //离散化
	len = unique(b + 1, b + 1 + len) - (b + 1);
	for (int i = 1; i <= n; i++) {
		//构建树
		update(1, len, root[i], root[i - 1], i, get_id(num[i], len));
	}
	int res;
	int l, r;
	while (m--) {
		scanf("%d %d", &l, &r);
		res = query(1, len, root[r], l);
		cout << b[res] << endl;
	}
	return 0;
}

 

 

解法2：莫队

莫队的解法我有一个点T了没过。。

在这里也厚颜无耻的贴出来。

莫队只有一个地方需要注意，就是add和del函数里面要注意flag数组可能数值为负

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 7;
int n, m, blo_siz, ans;
int num[MAXN], belong[MAXN], res[MAXN];
//flag[i]：记录数字i出现次数
int flag[MAXN];
struct query {
	int l, r, id;
}q[MAXN];
inline void add(int x) {
	flag[num[x]] ++;
	if (flag[num[x]] == 1 && num[x] == ans) {
		int ind = num[x];
		while (flag[ind])
			ind++;
		ans = ind;
	}
}
inline void del(int x) {
	if (flag[num[x]] == 1) {
		if (num[x] < ans)
			ans = num[x];
	}
	flag[num[x]]--;
}
//奇偶排序优化
bool cmp(query a, query b) {
	return (belong[a.l] ^ belong[b.l]) ? belong[a.l] < belong[b.l] : ((belong[a.l] & 1) ?
		a.r<b.r : a.r>b.r);
}
inline int read() {
	int x = 0, f = 1; register char ch = getchar();
	for (; ch<'0' || ch>'9'; ch = getchar()) if (ch == '-') f = -1;
	for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
	return x * f;
}

int main() {
	//cin >> n >> m;
	scanf("%d %d", &n, &m);
	blo_siz = (int)sqrt(n); //分块大小
	for (int i = 1; i <= n; i++)
		belong[i] = ceil(i / blo_siz);
	for (int i = 1; i <= n; i++)
		scanf("%d", num + i);
	for (int i = 1; i <= m; i++)
		//scanf("%d %d", &q[i].l, &q[i].r), q[i].id = i;
		q[i].l = read(), q[i].r = read(), q[i].id = i;
	sort(q + 1, q + 1 + m, cmp);
	int l, r;
	l = r = 0;
	l = 1;
	for (int i = 1; i <= n; i++) {
		while (l < q[i].l)
			del(l++);
		while (l > q[i].l)
			add(--l);
		while (r > q[i].r)
			del(r--);
		while (r < q[i].r)
			add(++r);
		res[q[i].id] = ans;
	}
	for (int i = 1; i <= m; i++)
		cout << res[i] << endl;
}