莫队算法合集

最新推荐文章于 2024-03-31 14:08:11 发布

hipamp

最新推荐文章于 2024-03-31 14:08:11 发布

阅读量582

点赞数 1

分类专栏： # 莫队

本文链接：https://blog.csdn.net/iamhpp/article/details/115212966

版权

莫队专栏收录该内容

2 篇文章 0 订阅

订阅专栏

前言

莫队算法，是一种离线的根号算法，可以解决一类区间询问问题，适用范围很广。莫队算法的本质就是分块 + 暴力，通过适当的操作把时间复杂度降为 $O(n\sqrt{n})$ 。

普通莫队

一、适用问题

用于不带修改的询问问题，且由区间 $[L, R]$ 可以 $O (1)$ 或 $O (l o g n)$ 扩展到 $[L - 1, R], [L + 1, R], [L, R - 1], [L, R + 1]$ .

二、算法实现

先将原序列按照 $\sqrt{n}$ 大小进行分块，总共分成 $\sqrt{n}$ 块。
对询问按照以下方式排序：
①：如果左端点所在的块编号不同，按左端点所在块的编号排序
②：如果左端点所在的块编号相同，按右端点所在块的编号排序
每次从上一次询问 $[L, R]$ 暴力转移至下一次询问 $[L^{'}, R^{'}]$

三、时间复杂度分析

对于每一块内的询问，其右端点单调增，因此右端点移动次数为 $O (n)$ 次，总共有 $\sqrt{n}$ 块，因此右端点移动的总复杂度为 $O(n\sqrt{n})$ 。对于左端点，每次询问要么在块内移动，要么跳到下一个块，每次询问的移动次数为 $O(\sqrt{n})$ ，总的复杂度为 $O(m\sqrt{n})$ 。
因此，普通莫队算法的复杂度为 $O(n\sqrt{n}+m\sqrt{n})$ 。

四、习题

[SDOI 2009] HH的项链

给出长度为 $n(n\le 10^5)$ 的序列 $\{a_n\}(a_i\le10^6)$ 和 $m(m\le 10^5)$ 次询问，每次询问给出 $l, r$ ，求 $[l, r]$ 中 $a_i$ 的种类数。

根据上面所说的的直接做即可。

带修改莫队

一、适用问题

在普通莫队的基础上增加了单点修改操作，复杂度为 $O(n^{\frac{5}{3}})$ 。
在普通莫队的基础上加入一个时间轴，即从普通莫队的 $(l, r)$ 变为 $(l, r, t i m e)$ 。每次往下面几个位置移动：

$(l - 1, r, t i m e)$
$(l + 1, r, t i m e)$
$(l, r - 1, t i m e)$
$(l, r + 1, t i m e)$
$(l, r, t i m e - 1)$
$(l, r, t i m e + 1)$

这样的转移也是 $O (1)$ 的。

二、算法实现

先将原序列按 $n^\frac{2}{3}$ 进行分块，分成 $n^\frac{1}{3}$ 块。
对询问按以下方式排序，第一关键字是左端点所在块，第二关键字是右端点所在块，第三关键字是时间。
对于 $l, r$ 的移动，我们按普通莫队那样子做就行了。
对于修改操作，也就是 $t i m e$ 的移动，假设是把位置 $a_p$ 的值改成 $x$ 。我们先看 $p$ 是否在 $[L, R]$ 内，如果在 $[L, R]$ 内，则要进行一次 $d e l$ 和 $a d d$ 操作。然后我们交换 $a_p$ 和 $x$ 的值，为了方便撤销操作的时候用到，因为下一次撤销这个操作，就相当于把 $x$ 改成 $a_p$ 。

三、时间复杂度分析

左右端点 $L, R$ 会移动 $O(mn^\frac{2}{3})$ 次。
时间 $t i m e$ 会移动 $O(n^{1\over 3}n^{1\over 3}n)=O(n^\frac{5}{3})$ 次。
因此总复杂度为 $O(mn^\frac{2}{3}+n^\frac{5}{3})$ 。

四、习题

[国家集训队]数颜色 / 维护队列

给出长度为 $n(n\le 10^5)$ 的序列 $\{a_n\}(a_i\le 10^5)$ 和 $m(m\le 10^5)$ 次操作，每次操作为以下两种：

给出 $l, r$ ，求区间 $[l, r]$ 的颜色种类数
给出 $p, x$ ，将 $a_p$ 修改为 $x$

做法已在算法实现中完整提及，下面给出代码。

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;

void debug_out(){
    cerr << endl;
}
template<typename Head, typename... Tail>
void debug_out(Head H, Tail... T){
    cerr << " " << to_string(H);
    debug_out(T...);
}
#ifdef local
#define debug(...) cerr<<"["<<#__VA_ARGS__<<"]:",debug_out(__VA_ARGS__)
#else
#define debug(...) 55
#endif

const int N = 3e6 + 5;
int bl[N], a[N], ans[N], cnt[N], B, tot;
struct node{
	int l, r, t, o;
	bool operator < (const node& A) const{
		if(bl[l] != bl[A.l]) return bl[l] < bl[A.l];
		if(bl[r] != bl[A.r]) return bl[r] < bl[A.r];
		return t < A.t;
	}
}q[N], Q[N];
void add(int x){
	if(!cnt[x]) tot++;
	cnt[x]++;
}
void del(int x){
	cnt[x]--;
	if(!cnt[x]) tot--;
}
int main(){
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);
	int n, m;
	cin >> n >> m;
	B = pow(n, 0.666);
	for(int i = 1; i <= n; i++) cin >> a[i], bl[i] = (i - 1) / B + 1;
	int m1 = 0, m2 = 0;
	for(int i = 1, l, r; i <= m; i++){
		char o[3];
		cin >> o >> l >> r;
		if(o[0] == 'Q') q[++m1] = {l, r, i, m2};
		if(o[0] == 'R') Q[++m2] = {l, r, i, 1};
	}
	sort(q + 1, q + m1 + 1);
	int L = 1, R = 0, T = 0;
	for(int i = 1; i <= m1; i++){
		while(L > q[i].l) L--, add(a[L]);
		while(L < q[i].l) del(a[L]), L++;
		while(R > q[i].r) del(a[R]), R--;
		while(R < q[i].r) R++, add(a[R]);
		while(T < q[i].o){
			T++;
			if(Q[T].l >= L && Q[T].l <= R) del(a[Q[T].l]), add(Q[T].r);
			swap(Q[T].r, a[Q[T].l]);
		}
		while(T > q[i].o){
			if(Q[T].l >= L && Q[T].l <= R) del(a[Q[T].l]), add(Q[T].r);
			swap(Q[T].r, a[Q[T].l]);	
			T--;
		}
		ans[q[i].t] = tot; 
	}
	for(int i = 1; i <= m; i++) if(ans[i]) cout << ans[i] << '\n';
	return 0;
}

树上莫队

一、适用问题

这里的树上莫队指的是解决询问是链的情况。如果询问问的是子树，那么直接对 $d f s$ 序莫队即可。树上莫队本质上是通过欧拉序将问题转化为普通莫队，复杂度也是 $O(n\sqrt{n})$ 。

二、欧拉序

在讲树上莫队之前，我们得先了解一棵树的欧拉序。
从根开始进行 $d f s$ ，每个节点进栈和出栈时分别记入序列，这个序列就是这棵树的欧拉序。
在这里插入图片描述
例如上面这棵以 $1$ 为根的树，其欧拉序为 $123325665441$ 。
求欧拉序的代码如下。

void dfs(int a, int pre){
	s[a] = ++dft;
	Seq[dft] = a;
	for(int b: E[a]){
		if(b == pre) continue;
		st[b][0] = a;
		dep[b] = dep[a] + 1;
		dfs(b, a);
	}
	t[a] = ++dft;
	Seq[dft] = a;
}

我们记 $s_x$ 表示 $x$ 入栈的编号， $t_x$ 表示 $x$ 出栈的编号。
接下来我们考虑树上的某一条链 $(u, v)$ ，不妨令 $s_u<s_v$ ，分两种情况讨论：

$l c a (u, v) = u$ ，那么其对应的欧拉序为 $s_u,s_v]$ ，比如 $(1, 6)$ ，其欧拉序为 $1233256$ ，可以看到在这条链上的 $1, 5, 6$ 只出现了 $1$ 次，而不在这条链上的 $2, 3$ 则出现了两次。
$l c a (u, v)! = u$ ，那么其对应的欧拉序为 $t_u,s_v]$ ，比如 $(3, 6)$ ，其对应的欧拉序为 $3256$ ，发现还缺少了 $l c a (3, 6) = 1$ ，因此要把 $l c a$ 额外加上。

三、算法实现

先求出欧拉序，然后按普通莫队来做即可。但是有一点要注意，我们要记录一个数出现了多少次，如果出现了 $2$ 次，那么此时的操作应该为抵消前面的贡献，否则应该为加上一个贡献。

四、习题

[WC2013] 糖果公园

给出一棵树，每次操作为修改一个数的值，或查询 $(x, y)$ 这条链上的答案，答案为 $\sum\limits_xV_x\sum\limits_{i=1}^{cnt_x}W_i$ 。 $n,m\le 2\times 10^5$ 。

这题就是把带修改莫队搬到了树上，如果你学会了带修改莫队，且明白了树上莫队的原理，那么就很容易打出代码了。

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;

void debug_out(){
    cerr << endl;
}
template<typename Head, typename... Tail>
void debug_out(Head H, Tail... T){
    cerr << " " << to_string(H);
    debug_out(T...);
}
#ifdef local
#define debug(...) cerr<<"["<<#__VA_ARGS__<<"]:",debug_out(__VA_ARGS__)
#else
#define debug(...) 55
#endif

const int N = 2e5 + 5, M = 1e6 + 5;
vector<int> E[N];
int V[N], W[N], vis[N], a[N], s[N], t[N], bl[N], dep[N], st[N][21], cnt[M], dft, Seq[N];
LL ans[N];
void dfs(int a, int pre){
	s[a] = ++dft;
	Seq[dft] = a;
	for(int b: E[a]){
		if(b == pre) continue;
		st[b][0] = a;
		dep[b] = dep[a] + 1;
		dfs(b, a);
	}
	t[a] = ++dft;
	Seq[dft] = a;
}
void build_st(int n){
	for(int i = 1; i <= 20; i++){
		for(int j = 1; j <= n; j++) st[j][i] = st[st[j][i - 1]][i - 1];
	}
}
int lca(int a, int b){
	if(dep[a] < dep[b]) swap(a, b);
	int D = dep[a] - dep[b];
	for(int i = 20; i >= 0; i--) if(D >> i & 1) a = st[a][i];
	if(a == b) return a;
	for(int i = 20; i >= 0; i--) if(st[a][i] != st[b][i]) a = st[a][i], b = st[b][i];
	return st[a][0];
}
struct node{
	int l, r, t, i, o;
	bool operator < (const node& A) const{
		if(bl[l] != bl[A.l]) return bl[l] < bl[A.l];
		if(bl[r] != bl[A.r]) return bl[r] < bl[A.r];
		return t < A.t;
	}
}q[N], Q[N];
LL tot = 0;
void Add(int x){
	cnt[x]++;
	tot += (LL)W[cnt[x]] * V[x];
}
void Del(int x){
	tot -= (LL)W[cnt[x]] * V[x];
	cnt[x]--;
}
void add(int i, int x){
	if(!vis[i]) Add(x);
	else Del(x);
	vis[i] ^= 1;
}
int main(){
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);
	int n, m, qq;
	cin >> n >> m >> qq;
	for(int i = 1; i <= m; i++) cin >> V[i];
	for(int i = 1; i <= n; i++) cin >> W[i];
	for(int i = 1, u, v; i < n; i++){
		cin >> u >> v;
		E[u].push_back(v);
		E[v].push_back(u);
	}
	for(int i = 1; i <= n; i++) cin >> a[i];
	dfs(1, 0);
	build_st(n);
	int n_ = dft;
	const int B = pow(n_, 2.0 / 3);
	for(int i = 1; i <= n_; i++) bl[i] = (i - 1) / B + 1;
	int m1 = 0, m2 = 0;
	for(int i = 1, o, l, r; i <= qq; i++){
		cin >> o >> l >> r;
		if(o == 0) Q[++m2] = {l, r, i};
		else{
			int Lca = lca(l, r), L, R, f = (Lca == l || Lca == r)? 0: Lca;
			if(s[l] > s[r]) swap(l, r);
			if(l == Lca) L = s[l], R = s[r];
			else L = t[l], R = s[r];
			q[++m1] = {L, R, m2, i, f};
		}
	}
	sort(q + 1, q + m1 + 1);
	int L = 1, R = 0, T = 0;
	for(int i = 1; i <= m1; i++){
		while(L < q[i].l) add(Seq[L], a[Seq[L]]), L++;
		while(L > q[i].l) L--, add(Seq[L], a[Seq[L]]);
		while(R < q[i].r) R++, add(Seq[R], a[Seq[R]]);
		while(R > q[i].r) add(Seq[R], a[Seq[R]]), R--;
		while(T < q[i].t){
			T++;
			if(vis[Q[T].l]) add(Q[T].l, a[Q[T].l]), add(Q[T].l, Q[T].r);
			swap(Q[T].r, a[Q[T].l]);
		}
		while(T > q[i].t){
			if(vis[Q[T].l]) add(Q[T].l, a[Q[T].l]), add(Q[T].l, Q[T].r);
			swap(Q[T].r, a[Q[T].l]);
			T--;
		}
		if(q[i].o) assert(vis[q[i].o] == 0), add(q[i].o, a[q[i].o]), ans[q[i].i] = tot, add(q[i].o, a[q[i].o]);
		else ans[q[i].i] = tot;
	}
	for(int i = 1; i <= qq; i++) if(ans[i]) cout << ans[i] << '\n';
	return 0;
}

回滚莫队

一、适用问题

是普通莫队的一种改版。当可以 $O (1)$ 或 $O (l o g n)$ 实现添加操作而无法轻易实现删除操作或可以 $O (1)$ 或 $O (l o g n)$ 实现删除操作而无法轻易实现添加操作时，就要用到回滚莫队了，复杂度也是 $O(n\sqrt{n})$ 的。
下面的讨论基于容易实现添加操作而不容易实现删除操作的莫队。

二、算法实现

先将原序列按照 $\sqrt{n}$ 大小进行分块，总共分成 $\sqrt{n}$ 块。
如果询问的 $l, r$ 在同一个块内，则直接暴力操作，复杂度为 $O(n\sqrt{n})$ 。
现在的询问 $l, r$ 都不在同一块内了，我们按 $l$ 所在块为第一关键字， $r$ 为第二关键字排序。
我们集中处理每一个左端点所在块的询问，设该块的右端点为 $R^{'}$ 。我们一开始先将 $L$ 置为 $R^{'} + 1$ ，将 $R$ 置为 $R^{'}$ 。然后对于每一个询问 $l, r$ ，先移动 $R$ 到 $r$ ，记录下此时的状态，记为 $l s t$ ，然后将 $L$ 从 $R^{'}$ 移动到 $l$ ，得到当前询问的答案 $a n s$ 。接下来就是回滚操作了，我们把 $L$ 一步一步移回 $R^{'} + 1$ ，并撤销 $[L, R^{'}]$ 的所有数的贡献，最后将 $a n s$ 置为 $l s t$ 。

三、时间复杂度分析

注意到，对于每一个块的询问，其右端点总共只会移动 $O (n)$ 次，因此右端点总共移动 $O(n\sqrt{n})$ 次。对于左端点，对于每一个询问，都会移动 $O(\sqrt{n})$ 次（从 $R^{'} + 1$ 移动到块内的某一个点），因此左端点总移动次数为 $O(m\sqrt{n})$ 。因此总的时间复杂度是 $O(n\sqrt{n}+m\sqrt{m})$ 的。

四、习题

AT1219 歴史の研究

有长度为 $n(n\le 10^5)$ 的序列 $\{a_n\}(a_i\le 10^9)$ 和 $m(m\le 10^5)$ 次询问，每次询问区间 $[L, R]$ 中每个数贡献的最大值，其中一个数 $x$ 的贡献为 $cnt_x\times v_x$ 。

由于是求最大值，因此添加操作很好更新，但是删除操作就很难更新。因此需要使用回滚莫队。代码如下。

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;

void debug_out(){
    cerr << endl;
}
template<typename Head, typename... Tail>
void debug_out(Head H, Tail... T){
    cerr << " " << to_string(H);
    debug_out(T...);
}
#ifdef local
#define debug(...) cerr<<"["<<#__VA_ARGS__<<"]:",debug_out(__VA_ARGS__)
#else
#define debug(...) 55
#endif

const int N = 1e5 + 5;
int a[N], b[N], bl[N], cnt[N], tot;
LL mx, ans[N];
struct node{
	int l, r, i;
	bool operator < (const node& A) const{
		if(bl[l] != bl[A.l]) return bl[l] < bl[A.l];
		return r < A.r;
	}
}q[N];
void add(int x){
	cnt[x]++;
	mx = max(mx, (LL)cnt[x] * b[x]);
}
int main(){
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);
	int n, m;
	cin >> n >> m;
	for(int i = 1; i <= n; i++) cin >> a[i], b[i] = a[i];
	sort(b + 1, b + n + 1);
	int n_ = unique(b + 1, b + n + 1) - b - 1;
	for(int i = 1; i <= n; i++) a[i] = lower_bound(b + 1, b + n_ + 1, a[i]) - b;
	const int B = sqrt(n);
	for(int i = 1; i <= n; i++) bl[i] = (i - 1) / B + 1;
	for(int i = 1, l, r; i <= m; i++){
		cin >> l >> r;
		if(bl[l] == bl[r]){
			LL mx = 0;
			for(int j = l; j <= r; j++){
				cnt[a[j]]++;
				mx = max(mx, (LL)cnt[a[j]] * b[a[j]]);
			}
			for(int j = l; j <= r; j++) cnt[a[j]]--;
			ans[i] = mx;
		}
		else{
			q[++tot] = {l, r, i};
		}
	}
	sort(q + 1, q + tot + 1);
	for(int i = 1, j = 1; i <= tot; i = j + 1, j = i){
		while(bl[q[j + 1].l] == bl[q[j].l]) j++;
		int K = min(n, bl[q[j].l] * B) + 1, L = K, R = K - 1;
		for(int k = i; k <= j; k++){
			while(R < q[k].r) R++, add(a[R]);
			LL lst = mx;
			while(L > q[k].l) L--, add(a[L]);
			ans[q[k].i] = mx;
			mx = lst;
			while(L < K) cnt[a[L]]--, L++;
		}
		mx = 0;
		memset(cnt, 0, sizeof(cnt));
	}
	for(int i = 1; i <= m; i++) cout << ans[i] << '\n';
	return 0;
}

Rmq Problem / mex

给出长度为 $n$ 的序列 ${a_n\}$ ，给出 $m$ 次询问，每次询问区间 $[l, r]$ 的最小未出现的自然数。 $(n,m,a_i\le 2\times 10^5)$

由于删除操作很好更新 $a n s$ ，添加操作很难更新 $a n s$ ，因此我们使用回滚莫队。这里需要注意的是，由于区间只有内缩，我们需要将 $r$ 从大到小排序。而且在处理一个块的询问时，设 $L^{'}$ 为该块的左端点，我们把 $L$ 置为 $L^{'}$ ，把 $R$ 置为 $n$ ，同时更新下此时的状态，然后再不断将区间内缩和回滚。
代码如下。

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;

void debug_out(){
    cerr << endl;
}
template<typename Head, typename... Tail>
void debug_out(Head H, Tail... T){
    cerr << " " << to_string(H);
    debug_out(T...);
}
#ifdef local
#define debug(...) cerr<<"["<<#__VA_ARGS__<<"]:",debug_out(__VA_ARGS__)
#else
#define debug(...) 55
#endif

const int N = 2e5 + 5;
int a[N], bl[N], cnt[N], tot;
int mex, ans[N];
struct node{
	int l, r, i;
	bool operator < (const node& A) const{
		if(bl[l] != bl[A.l]) return bl[l] < bl[A.l];
		return r > A.r;
	}
}q[N];
void del(int x){
	cnt[x]--;
	if(!cnt[x]) mex = min(mex, x);
}
int main(){
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);
	int n, m;
	cin >> n >> m;
	for(int i = 1; i <= n; i++) cin >> a[i];
	const int B = sqrt(n);
	for(int i = 1; i <= n; i++) bl[i] = (i - 1) / B + 1;
	for(int i = 1, l, r; i <= m; i++){
		cin >> l >> r;
		if(bl[l] == bl[r]){
			for(int j = l; j <= r; j++) cnt[a[j]]++;
			int mex = 0;
			while(cnt[mex]) mex++;
			for(int j = l; j <= r; j++) cnt[a[j]]--;
			ans[i] = mex;
		}
		else q[++tot] = {l, r, i};
	}
	sort(q + 1, q + tot + 1);
	for(int i = 1, j = 1; i <= tot; i = j + 1, j = i){
		while(bl[q[j + 1].l] == bl[q[j].l]) j++;
		int K = (bl[q[j].l] - 1) * B + 1, L = K, R = n;
		for(int j = L; j <= R; j++) cnt[a[j]]++;
		mex = 0;
		while(cnt[mex]) mex++;
		for(int k = i; k <= j; k++){
			debug(q[k].l, q[k].r, K, L, R);
			while(R > q[k].r) del(a[R]), R--;
			int lst = mex;
			while(L < q[k].l) del(a[L]), L++;
			ans[q[k].i] = mex;
			mex = lst;
			while(L > K) L--, cnt[a[L]]++;
		}
		mex = 0;
		memset(cnt, 0, sizeof(cnt));
	}
	for(int i = 1; i <= m; i++) cout << ans[i] << '\n';
	return 0;
}

hipamp

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
莫队算法合集

前言莫队算法，是一种离线算法，可以解决一类区间询问问题，适用范围很广。莫队算法的本质就是分块 + 暴力，通过适当的操作把时间复杂度降为 O(nn)O(n\sqrt{n})O(nn)。普通莫队一、适用问题用于不带修改的询问问题，且由区间 [L,R][L,R][L,R] 可以 O(1)O(1)O(1) 或 O(logn)O(logn)O(logn) 扩展到 [L−1,R],[L+1,R],[L,R−1],[L,R+1][L-1,R],[L+1,R],[L,R-1],[L,R+1][L−1,R],[L+
复制链接

扫一扫

专栏目录