莫队全家桶

莫队

贴一个神仙博客：莫队全家桶
莫队算法是对询问进行分块的一种算法，其本质是对暴力的优化。

这个算法主要是解决区间操作的，适用于求解那种区间 $[l, r]$ 可以快速支持区间的端点移动 $+ 1, - 1$ 的问题，也是充分利用已知信息，避免重复计算的典范

莫队算法核心思想就是：对于所有查询的区间，通过合理的排序，让两个指针进行快速区间移动，达到求解所有询问的目的,需要离线操作

对于这个合理的排序，一个合理的方案是，对于所有的左端点进行分块，按块递增排序，并且对于右端点块内排序，这样做的目的是可以保证左右端点每一次在块内最多只会移动 $O (\sqrt{n})$ ，并且也最多跳 $\sqrt{n}$ 个块，总复杂度为 $O (n \sqrt{n})$

模版大致长这样

struct node{
    int l, r;
    int id;//表示这个询问是第几个，由于询问在排序后顺序会乱掉，我们要存储其原先的询问顺序。
}ask[50005];
bool cmp(node a,node b){  
    return pos[a.l]==pos[b.l]?a.r<b.r:a.l<b.l;
}
for(int i=1,l=1,r=0;i<=m;i++){//初始化为空区间
    while(l > q[i].l) add(a[-- l]);
    while(r < q[i].r) add(a[++ r]);
    while(l < q[i].l) del(a[l ++]);
    while(r > q[i].r) del(a[r --]);
    ans[q[i].id]=……;
}

一个小优化是奇偶性排序，具体的只需要更改 $c m p$ 即可

bool cmp(node a,node b){  
    return pos[a.l]==pos[b.l]?(pos[a.l]&1?a.r<b.r:a.r>b.r):a.l<b.l;
}

来看一道例题

XOR and Favorite Number

题面翻译

给定一个长度为 $n$ 的序列 $a$ ，然后再给一个数字 $k$ ，再给出 $m$ 组询问，每组询问给出一个区间，求这个区间里面有多少个子区间的异或值为 $k$ 。
- $1 \leq n, m \leq 10^{5}$ ， $0 \leq k, a_{i} \leq 10^{6}$ ， $1 \leq l_{i} \leq r_{i} \leq n$ 。

Translated by @char32_t，Reformed by @明依。

样例 #1

样例输入 #1

6 2 3
1 2 1 1 0 3
1 6
3 5

样例输出 #1

7
0

样例 #2

样例输入 #2

样例输出 #2

9
4
4

分析

看到异或区间和，条件反射式想到异或前缀和，那么我们首先构造原序列的异或前缀和 $s$ 。看本题，不难发现是个莫队，考虑如何快速实现增删一个端点

假设当前的需要增删的是区间端点是 $x$ ，那么就是求当前莫队的区间 $[l, r]$ 内有多少个数 $y$ 满足x^y=k，可以推出y=k^x，此题就变成了一道莫队的查询某个值出现的次数，由于值域在 $10^{6}$ 范围，所以可以开一个桶维护。

需要注意的是，异或前缀和查询区间异或和是需要左端点减一的，解决方案可以让所有的区间的左端点向左移动一位。

还有一些细节：在增加一个数进入区间的时候得先统计再插入，在删除的时候要先统计再删除

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#define int long long
using namespace std;
#define N 100050
struct node {
	int l, r, id;
}ask[N];
int n, m, block, ans[N], cnt[25*N], s[N], sum, k;
inline int get(int x) {
	return (x-1) / block+1;
}
bool cmp(node a, node b) {
	return get(a.l) == get(b.l) ? (get(a.l) & 1 ? a.r<b.r : a.r>b.r) : a.l < b.l;
}
void init() {
	cin >> n >> m >> k;
	block = sqrt(n);
	for (int i = 1; i <= n; i++) {
		cin >> s[i];
		s[i] ^= s[i - 1];
	}
	for (int i = 1; i <= m; i++) {
		cin >> ask[i].l >> ask[i].r;
		ask[i].id = i, ask[i].l--;
	}
	sort(ask + 1, ask + m + 1, cmp);
}
void add(int x) {
	sum += cnt[s[x] ^ k];
	cnt[s[x]]++;
}
void del(int x) {
	cnt[s[x]]--;
	sum -= cnt[s[x] ^ k];
}
signed main() {
	ios::sync_with_stdio(false);
	init();
	int l = 1, r = 0;
	for (int i = 1; i <= m; i++) {
		while (l > ask[i].l)add(--l);
		while (r < ask[i].r)add(++r);
		while (l < ask[i].l)del(l++);
		while (r > ask[i].r)del(r--);
		ans[ask[i].id] = sum;
	}
	for (int i = 1; i <= m; i++) {
		cout << ans[i] << endl;
	}
}

莫队算法的变形

带修莫队

没想到吧，这玩意还能带修，但只能单点修改

带修莫队的原理是：给每一个询问加一个时间戳 $t$ ，表示在这个询问之前进行了 $t$ 次修改，一个很暴力的思路是：

首先设计出此题若不考虑修改，普通莫队怎么做
对每一个查询打上时间戳 $t$
正常莫队，在每一次莫队的调整 $l, r$ 后，调整 $t$ 这一维度，对于修改的位置直接暴力修改
需要注意，修改的值与原序列的值要交换，因为 $t$ 可能会滚回来，改回来

需要注意的是，我们将 $t$ 作为第三维度，对于右端点在同一个块内的按照 $t$ 升序排序
光说不练假把式，上模版

void change(int l,int r,int t){//表示当前询问区间是l,r，需要进行第$t$次更改
	int id=b[t].x;//更改位置
	if(l<=id&&id<=r){
		del(s[id]);
		add(b[t].y);
	}
	swap(s[id],b[t].y);//必须交换，有可能这个位置会改回来
}
int get(int x){return (x-1)/block+1;}
bool cmp(node a,node b){
	return get(a.l)==get(b.l)?(get(a.r)==get(b.r)?a.t<b.t:a.r<b.r):a.l<b.l;
}
//main函数中
   for(int i=1;i<=n;i++)cin>>s[i];//原序列
	for(int i=1;i<=m;i++){
		int opt,l,r;
		cin>>opt>>l>>r;
		if(opt==1)b[++lst]={l,r};//修改操作，对位置为l的数进行r的修改
		else a[++tot]={l,r,lst,tot};//查询操作
	}
	sort(a+1,a+tot+1,cmp);//排序
	int l=1,r=0,t=0;
	for(int i=1;i<=tot;i++){
		while(l<a[i].l)del(s[l++]);
		while(l>a[i].l)add(s[--l]);
		while(r>a[i].r)del(s[r--]);
		while(r<a[i].r)add(s[++r]);
		while(t<a[i].t)change(l,r,++t);
		while(t>a[i].t)change(l,r,t--);
		ans[a[i].id]=sum;
	}

来分析分析复杂度：

设块长为 $b$ ，我们有 $\frac{n^{2}}{b^{2}}$ 个左端点的块的编号一致，右端点的块的编号一致组成的数对，又因为对于这样的数对中 $t$ 是单调递增的，所以最多滚 $n$ 次，故这部分算法复杂度是 $O (\frac{n^{3}}{b^{2}})$ ，然后因为左右端点的修改都会跳 $O (b)$ 次，一共有 $O (n)$ 组左右端点所属块不同的区间，总复杂度即为 $O (\frac{n^{3}}{b^{2}} + n b)$ ，由均值不等式，当 $\frac{n^{3}}{b^{2}} = n b$ 时，复杂度最小，变式换算得到 $n^{2} = b^{3}$ ，也即 $b = \sqrt[\frac{2}{3}]{n}$ 时最小，此时总复杂度为 $O (n^{\frac{5}{3}})$ ，总比暴力好。实际上由于常数较小的优点，部分 $10^{5}$ 数据是能够跑过的

来两道例题:

P2464

题目描述

小 J 是国家图书馆的一位图书管理员，他的工作是管理一个巨大的书架。虽然他很能吃苦耐劳，但是由于这个书架十分巨大，所以他的工作效率总是很低，以致他面临着被解雇的危险，这也正是他所郁闷的。

具体说来，书架由 $N$ 个书位组成，编号从 $1$ 到 $N$ 。每个书位放着一本书，每本书有一个特定的编码。

小 J 的工作有两类：

图书馆经常购置新书，而书架任意时刻都是满的，所以只得将某位置的书拿掉并换成新购的书。
小 J 需要回答顾客的查询，顾客会询问某一段连续的书位中某一特定编码的书有多少本。

例如，共 $5$ 个书位，开始时书位上的书编码为 $1, 2, 3, 4, 5$ 。

一位顾客询问书位 $1$ 到书位 $3$ 中编码为“ $2$ ”的书共多少本，得到的回答为： $1$ 。

一位顾客询问书位 $1$ 到书位 $3$ 中编码为“ $1$ ”的书共多少本，得到的回答为： $1$ 。

此时，图书馆购进一本编码为“ $1$ ”的书，并将它放到 $2$ 号书位。

一位顾客询问书位 $1$ 到书位 $3$ 中编码为“ $2$ ”的书共多少本，得到的回答为： $0$ 。

一位顾客询问书位 $1$ 到书位 $3$ 中编码为“ $1$ ”的书共多少本，得到的回答为： $2$ 。

……

你的任务是写一个程序来回答每个顾客的询问。

输入格式

第一行两个整数 $N, M$ ，表示一共 $N$ 个书位， $M$ 个操作。

接下来一行共 $N$ 个整数数 $A_{1}, A_{2}, \dots, A_{N}$ ， $A_{i}$ 表示开始时位置 $i$ 上的书的编码。

接下来 $M$ 行，每行表示一次操作，每行开头一个字符。

若字符为 C，表示图书馆购进新书，后接两个整数 $A, P$ （ $1 \leq A \leq N$ ），表示这本书被放在位置 $A$ 上，以及这本书的编码为 $P$ 。

若字符为 Q，表示一个顾客的查询，后接三个整数 $A, B, K$ （ $1 \leq A \leq B \leq N$ ），表示查询从第 $A$ 书位到第 $B$ 书位（包含 $A$ 和 $B$ ）中编码为 $K$ 的书共多少本。

输出格式

对每一个顾客的查询，输出一个整数，表示顾客所要查询的结果。

样例 #1

样例输入 #1

样例输出 #1

提示

对于 $40 %$ 的数据， $1 \leq N, M \leq 5000$ 。

对于 $100 %$ 的数据， $1 \leq N, M \leq 10^{5}$ 。

对于 $100 %$ 的数据，所有出现的书的编码为不大于 $2^{31} - 1$ 的正数。

分析

一句话题意：给定一段区间，支持单点修改和区间定值出现数量查询

套路：离线，离散化，开一个计数数组计数，然后就变成了板子。。。

例2

题意：给定一个序列，有两种操作
1 x y表示将位置为x的数改为y
2 l r表示查询区间 $[l, r]$ 中出现过的一次的数的个数.
提示：值域与 $n$ 同级

分析

很明显开个桶记录每个数出现次数，那么对于add,del,change三个函数的设置就很简单了。具体地，

#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
#define N 300500
struct node{
	int l,r,t,id;
}a[N]; 
struct Node {
	int x,y;
}b[N];
int block;
int get(int x){
	return x/block;
}
int n,m,cnt[N],tot,ans[N],s[N],sum,lst;
bool cmp(node a,node b){
	return get(a.l)==get(b.l)?(get(a.r)==get(b.r)?a.t<b.t:a.r<b.r):a.l<b.l;
}
void add(int x){
	if(cnt[x]==0)sum++;
	if(cnt[x]==1)sum--;
	cnt[x]++;
}
void del(int x){
	if(cnt[x]==1)sum--;
	if(cnt[x]==2)sum++;
	cnt[x]--;
}
void change(int l,int r,int t){
	int id=b[t].x;
	if(l<=id&&id<=r){
		del(s[id]);
		add(b[t].y);
	}
	swap(s[id],b[t].y);
}
int main(){
	ios::sync_with_stdio(false);
	cin>>n>>m;
	memset(ans,-1,sizeof ans);
	block=pow(n,0.67);
	for(int i=1;i<=n;i++)cin>>s[i];
	for(int i=1;i<=m;i++){
		int opt,l,r;
		cin>>opt>>l>>r;
		if(opt==1)b[++lst]={l+1,r};
		else a[++tot]={l+1,r+1,lst,tot};
	}
	sort(a+1,a+tot+1,cmp);
	int l=1,r=0,t=0;
	for(int i=1;i<=tot;i++){
		while(l<a[i].l)del(s[l++]);
		while(l>a[i].l)add(s[--l]);
		while(r>a[i].r)del(s[r--]);
		while(r<a[i].r)add(s[++r]);
		while(t<a[i].t)change(l,r,++t);
		while(t>a[i].t)change(l,r,t--);
		ans[a[i].id]=sum;
	}
	for(int i=1;i<=tot;i++)cout<<ans[i]<<"\n";
	return 0;
}

例三

Machine Learning

题面翻译

给你一个数组 ${a_{i}}$ 支持两种操作：

1、查询区间 $[l, r]$ 中每个数字出现次数的mex。

2、单点修改某一个位置的值。

mex指的是一些数字中最小的未出现的自然数。值得注意的是，区间 $[l, r]$ 总有数字是没有出现过的，所以答案不可能为0.

$n, Q \leq 10^{5}$

感谢@租酥雨提供的翻译

题目描述

You come home and fell some unpleasant smell. Where is it coming from?

You are given an array $a$ . You have to answer the following queries:

You are given two integers $l$ and $r$ . Let $c_{i}$ be the number of occurrences of $i$ in $a_{l : r}$ , where $a_{l : r}$ is the subarray of $a$ from $l$ -th element to $r$ -th inclusive. Find the Mex of $c_{0}, c_{1}, . . ., c_{10^{9}}$
You are given two integers $p$ to $x$ . Change $a_{p}$ to $x$ .

The Mex of a multiset of numbers is the smallest non-negative integer not in the set.

Note that in this problem all elements of $a$ are positive, which means that $c_{0}$ = 0 and $0$ is never the answer for the query of the second type.

输入格式

The first line of input contains two integers $n$ and $q$ ( $1 <= n, q <= 100000$ ) — the length of the array and the number of queries respectively.

The second line of input contains $n$ integers — $a_{1}$ , $a_{2}$ , $. . .$ , $a_{n}$ ( $1 <= a_{i} <= 10^{9}$ ).

Each of the next $q$ lines describes a single query.

The first type of query is described by three integers $t_{i} = 1$ , $l_{i}$ , $r_{i}$ , where $1 <= l_{i} <= r_{i} <= n$ — the bounds of the subarray.

The second type of query is described by three integers $t_{i} = 2$ , $p_{i}$ , $x_{i}$ , where $1 <= p_{i} <= n$ is the index of the element, which must be changed and $1 <= x_{i} <= 10^{9}$ is the new value.

输出格式

For each query of the first type output a single integer — the Mex of $c_{0}, c_{1}, . . ., c_{10^{9}}$ .

样例 #1

样例输入 #1

10 4
1 2 3 1 1 2 2 2 9 9
1 1 1
1 2 8
2 7 1
1 2 8

样例输出 #1

2
3
2

提示

The subarray of the first query consists of the single element — $1$ .

The subarray of the second query consists of four $2$ s, one $3$ and two $1$ s.

The subarray of the fourth query consists of three $1$ s, three $2$ s and one $3$ .

分析

感觉一般数据结构根本无法维护，考虑莫队。

先分析如果没有修改怎么办，即add与del如何设计

很有用的性质：每个数add与del的时候，最多使得这个数出现次数改变 $1$ ，考虑这个1如何维护。因为它维护的是区间出现次数，不妨考虑先离散化，再开桶来维护每个数出现的次数，记为 $c n t 1$ ，再开一个桶维护每个出现次数一共有几个，记为 $c n t 2$ ，这样我们可以保证 $O (1)$ 统计出来次数，考虑如何求解mex，设当前统计出的mex为 $s u m$ ，首先答案不可能为0，当我们需要更改 $s u m$ 的时候，也仅仅会改变两个值，记为 $x, y$ ，先来讨论add
假设我们加入了数 $s$ ，那么就需要

cnt2[cnt1[s]]--;//此时为0可能会更新mex
cnt1[s]++;
cnt2[cnt1[s]]++;

考虑其对mex的影响，当第一次减去 $c n t 2$ 时，若其为0则可能会更新 $m e x$ ，取 $min$ 即可，问题在于若原本 $m e x$ 为后面增加的那个 $c n t 2$ ，考虑如何维护这个更改，此时肯定是往后找到第一个为0的 $c n t 2$ ，但好似这个过程没有什么可以优化的，还不如区间移动到好了直接暴力mex，但直接暴力求解mex复杂度如何呢，让我们想想，从1开始扫，最坏情况下，即为有一个数出现1次，一个数出现2次，一个数出现3次……一直到 $x$ ，那么，可以发现，总得数的数量为： $\sum_{i = 1}^{x} i \leq n$ ，所以说这个暴力求解的复杂度是远小于单次 $O (\sqrt{n})$ 的，故总的复杂度也就 $O (n \sqrt{n})$ ，那么莫队的复杂度大于它，故不会影响复杂度

于是我们就得到了一个看似无比暴力的莫队算法，add,del完全只需要维护cnt1,cnt2即可，无需考虑影响，最后当 $l, r, t$ 三维归一，则暴力扫描mex即可。

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
#define N 500050
int a[N],b[N],c[N],ans[N],cnt1[N],cnt2[N],num,n,m,lst,tot,block; 
struct node{
	int l,r,t,id;
}ask[N];
struct Node{
	int x,y;
}upd[N];
inline int get(int x){
	return (x-1)/block+1;
}
bool cmp(node a,node b){
	return get(a.l)==get(b.l)?(get(a.r)==get(b.r)?a.t<b.t:a.r<b.r):a.l<b.l;
}
void add(int x){
	cnt2[cnt1[x]]--;
	cnt1[x]++;
	cnt2[cnt1[x]]++;
}
void del(int x){
	cnt2[cnt1[x]]--;
	cnt1[x]--;
	cnt2[cnt1[x]]++;
}
void change(int l,int r,int t){
	int id=upd[t].x;
	if(l<=id&&id<=r){
		del(a[id]);
		add(upd[t].y);
	}
	swap(upd[t].y,a[id]);
}
int find(){
	for(int i=1;i;i++){
		if(!cnt2[i])return i;
	}
}
int main(){
	ios::sync_with_stdio(false);
	cin>>n>>m;
	num=n;
	block=pow(n,0.67);
	for(int i=1;i<=n;i++){
		cin>>a[i];
		c[i]=a[i];
	} 
	for(int i=1;i<=m;i++){
		int opt,l,r;
		cin>>opt>>l>>r;
		if(opt==1)ask[++tot]={l,r,lst,tot};
		else upd[++lst]={l,r},c[++num]=r;
	}
	sort(c+1,c+num+1);
	num=unique(c+1,c+num+1)-c-1;
	for(int i=1;i<=n;i++)a[i]=lower_bound(c+1,c+num+1,a[i])-c;
	for(int i=1;i<=lst;i++)upd[i].y=lower_bound(c+1,c+num+1,upd[i].y)-c;
	sort(ask+1,ask+tot+1,cmp);
	for(int i=1,l=1,r=0,t=0;i<=tot;i++){
		while(l<ask[i].l)del(a[l++]);
		while(l>ask[i].l)add(a[--l]);
		while(r<ask[i].r)add(a[++r]);
		while(r>ask[i].r)del(a[r--]);
		while(t<ask[i].t)change(l,r,++t);
		while(t>ask[i].t)change(l,r,t--);
		ans[ask[i].id]=find();
	}
	for(int i=1;i<=tot;i++)printf("%d\n",ans[i]);
}

回滚莫队

由于莫队的核心操作是 $a d d, d e l$ 两个，整个莫队的复杂度基于这两个函数的算法复杂度乘上 $O (N \sqrt{N})$ ，但很多时候，莫队算法的这两个函数其中一个仍然可以保证 $O (1)$ ，但另一个函数的复杂度较高，比如 $\log n, \sqrt{n}$ 之类的，此时普通的莫队算法就不能解决问题。我们就有了回滚莫队的算法，对于 $a d d ， d e l$ 哪一个复杂度较高，又可以划分为两类：只删不增的回滚莫队，只增不删的回滚莫队，其核心思想是通过不断记录标记，将指针拉回，化增加/删除为撤销（即不改变答案，只 $O (1)$ 更改维护的信息）。

只删不增的回滚莫队

这里主要是先暴力统计大区间答案，再通过不断删这个大区间达到只删不增的效果

首先将询问的区间以左端点所在块为第一关键字升序，以右端点为第二关键字降序排序
对于左右端点都在同一个块的询问，直接暴力统计答案，复杂度为 $O (\sqrt{N})$
对于左端点在同一个块的询问，将 $l$ 初始化为这个块的左端点，将 $r$ 初始化为 $n$ ，这部分先暴力统计这段答案，复杂度一般 $O (N)$
由于右端点降序，在处理这同一个块的询问的时候，右端点单调递减，只用删除
由于左端点可能无序，考虑建立 $t m p$ 先记录下左端点为块的左端点的答案，然后将左端点向右移动，同样是只用删除，当到达指定位置之后，统计一次答案，然后撤销删除，但不统计答案，当撤销回块左端点时，再将答案重新变为 $t m p$

在实现上，为了代码的方便，可以给左右端点在同一个块的区间单独开一组统计数组来暴力求解

//只删不增回滚莫队伪代码
void del(int x) {

}
void move(int x) {
	//删除的逆操作，但不更新答案
}
void solve() {//pos表示所属块
	int lst = 0,l=1,r=0;//上个询问所属哪一个块
	for (int i = 1; i <= tot; i++) {
		if (pos[a[i].l] == pos[a[i].r]) {
			//暴力处理块内的询问
			ans[a[i].id]=//
			//撤销暴力统计的操作
			continue;
		}
		if (lst != pos[a[i].l]) {
			lst = pos[a[i].l];//需要再次初始化一次
			while (l < L[lst])del(l++);
			while (r < n)move(++r);
        //暴力计算此时答案
		}
		while (r > a[i].r)del(r--);
		int tmp =/*此时答案*/;
		while (l < a[i].l)del(l++);
		ans[a[i].id]=  ;
		while (l > L[pos[a[i].l]])move(--l);
		/*此时答案*/ = tmp;
	}
}

不难得知，复杂度为 $O (N \sqrt{N})$

例题：Rmq Problem / mex

描述

有一个长度为 $n$ 的数组 ${a_{1}, a_{2}, \dots, a_{n}}$ 。

$m$ 次询问，每次询问一个区间内最小没有出现过的自然数。

输入

第一行，两个正整数 $n, m$ 。
第二行， $n$ 个非负整数 $a_{1}, a_{2}, \dots, a_{n}$ 。
接下来 $m$ 行，每行两个正整数 $l, r$ ，表示一次询问。

分析

首先按照套路维护计数数组，然后考虑删除怎么做，很明显，令这个数出现次数减一，减到0就更新答案，那么剩下的都只是套一下即可。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
using namespace std;
#define N 500050
#define re register
int n, m, cnt[N], cnt1[N], sum, pos[N], L[N], R[N], s[N], ans[N], block, siz;
struct node {
	int l, r, id;
	bool operator<(const node& b)const {
		return pos[l] == pos[b.l] ? r > b.r : l < b.l;
	}
}a[N];
inline void init() {
	cin >> n >> m;
	block = sqrt(n), siz = n / block + (n % block != 0);
	for (re int i = 1; i <= siz; i++)L[i] = R[i - 1] + 1, R[i] = R[i - 1] + block;
	R[siz] = n;
	for (re int i = 1; i <= siz; i++) {
		for (re int j = L[i]; j <= R[i]; j++) {
			pos[j] = i;
		}
	}
	for (re int i = 1; i <= n; i++)cin >> s[i];
	for (re int i = 1; i <= m; i++) {
		cin >> a[i].l >> a[i].r;
		a[i].id = i;
	}
	sort(a + 1, a + m + 1);
	return;
}
inline void del(int x) {
	cnt[s[x]]--;
	if (cnt[s[x]] == 0)sum = min(sum, s[x]);
	return;
}
inline void move(int x) {
	cnt[s[x]]++;
	return;
}
inline void solve() {
	int lst = 0, l = 1, r = 0;
	for (re int i = 1; i <= m; i++) {
		if (pos[a[i].l] == pos[a[i].r]) {
			for (re int j = a[i].l; j <= a[i].r; j++) {
				cnt1[s[j]]++;
			}
			for (re int k = 0; k <= a[i].r - a[i].l + 1; k++) {
				if (cnt1[k] == 0) {
					ans[a[i].id] = k;
					break;
				}
			}
			for (re int j = a[i].l; j <= a[i].r; j++) {
				cnt1[s[j]]--;
			}
			continue;
		}
		if (lst != pos[a[i].l]) {
			lst = pos[a[i].l];
			while (l < L[lst])del(l++);
			while (r < n)move(++r);
			for (re int i = 0; i <= n; i++) {
				if (!cnt[i]) {
					sum = i; break;
				}
			}
		}
		while (r > a[i].r)del(r--);
		int tmp = sum;
		while (l < a[i].l)del(l++);
		ans[a[i].id] = sum;
		while (l > L[lst])move(--l);
		sum = tmp;
	}
	return;
}
int main() {
//	freopen("P4137_4.in","r",stdin); 
//	freopen("P4137_4.ans","w",stdout);
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	init();
	solve();
	for (re int i = 1; i <= m; i++)cout << ans[i] << "\n";
	return 0;
}

只增不删的回滚莫队

类比只删不增的回滚莫队，容易想到可以这样做：

将询问区间按左端点所在块为第一关键字递增排序，右端点为第二关键字递增排序
对于每个块，初始化 $l = R [i] + 1, r = l - 1$ ，这是一个空区间
对于左右端点在同一个块内的询问，暴力处理即可
否则，对于右端点的处理，由于递增，所以只增不删
对于左端点，先记录下此时的答案，然后只增不删往左滚，更新答案之后原路撤销操作
将答案还原即可
这里没有处理新开的块，原因是本身是一个空区间
板子大概类似

void add(int x) {

}
void move(int x) {

}
void solve() {
	int lst = 0, l = 1, r = 0;
	for (int i = 1; i <= tot; i++) {
		if (pos[a[i].l] == pos[a[i].r]) {
			//用那个另开的统计数组暴力统计答案
			and[a[i].id]=
			//撤销掉所有操作
			continue;
		}
		if (lst != pos[a[i].l]) {
			while (l <= R[pos[a[i].l]])move(l++);
			while (r > R[pos[a[i].l]])move(r--);
			//重置答案
			lst = pos[a[i].l];
		}
		while (r < a[i].r)add(++r);
		int tmp =/*此时答案*/;
		while (l > a[i].l)add(--l);
		ans[a[i].id] =/*此时答案*/;
		/*此时答案*/ = tmp;
		while (l <= R[pos[a[i].l]])move(l++);
	}
}

例题：洛谷模版

给定一个序列，多次询问一段区间 $[l, r]$ ，求区间中相同的数的最远间隔距离。

序列中两个元素的间隔距离指的是两个元素下标差的绝对值。

分析

解法1

考虑回滚莫队的常规操作，由于要求相同元素距离最大值，显然必须对于每一个值都求出相邻元素最大值，而欲求这个最大值，就必须知道当前区间每个值最后出现的位置和最先出现的位置，分别记为 $e d, s t$ ，考虑如何维护这两个值。由于我们每处理完一个块的询问之后会重置，无需考虑不同块的相互影响，那么仅需考虑一个块如何维护即可。由于回滚莫队的性质，显然 $r$ 单调递增， $e d$ 和 $s t$ 就可以肆无忌惮的在 $r$ 中更新，很简单不多说。而至于要回滚的 $l$ 指针，则不能维护 $s t$ ，因为无法撤销，但幸好，当前 $l$ 指针所在位置，就是这个位置对应值的 $s t$ ，故我们只需要对只出现于 $l$ 移动范围的值更新 $e d$ 即可。那么最后回滚的时候，如果发现回滚的 $l$ 指针这个位置的 $e d$ 指向自己，就重置为0。在每个块询问处理完之后，不要忘记清空两数组

同块暴力很简单，不多说

#include<iostream>
#include<algorithm>
#include<cmath>
#include<vector>
using namespace std;
#define N 5000005
int s[N],n,m,L[N],R[N],pos[N],ans[N],block,siz,sum,st[N],ed[N],st1[N],ed1[N],b[N],c[N],cnt,vis[N];
struct node{
	int l,r,id;
	bool operator<(const node b ){
		return pos[l]==pos[b.l]?r<b.r:l<b.l;
	}
}a[N];
void init(){
	cin>>n;
	for(int i=1;i<=n;i++)cin>>s[i];
	for(int i=1;i<=n;i++)c[i]=s[i];
	sort(c+1,c+n+1);
	cnt=unique(c+1,c+n+1)-c-1;
	for(int i=1;i<=n;i++){
		s[i]=lower_bound(c+1,c+cnt+1,s[i])-c;
	//	cout<<s[i]<<" ";
	} 
	//cout<<endl;
	cin>>m;
	for(int i=1;i<=m;i++){
		int l,r;
		cin>>l>>r;
		a[i]={l,r,i};
	}
	block=sqrt(n);
	siz=n/block+(n%block!=0);
	for(int i=1;i<=siz;i++)L[i]=R[i-1]+1,R[i]=R[i-1]+block;
	R[siz]=n;
	for(int i=1;i<=siz;i++){
		for(int j=L[i];j<=R[i];j++){
			pos[j]=i;
		}
	} 
	sort(a+1,a+m+1);
}
void addr(int x){
	ed[s[x]]=x;
	if(!st[s[x]])st[s[x]]=x;
	sum=max(sum,ed[s[x]]-st[s[x]]);
}
void addl(int x){
	if(!ed[s[x]])ed[s[x]]=x;
	sum=max(ed[s[x]]-x,sum);
}
void movel(int x){
	if(ed[s[x]]==x)ed[s[x]]=0;
}
void solve(){
	int l=1,r=0,lst=0;
	for(int i=1;i<=m;i++){
		if(pos[a[i].l]==pos[a[i].r]){
			int sum=0;
			for(int j=a[i].l;j<=a[i].r;j++){
				if(!st1[s[j]])st1[s[j]]=j;
				sum=max(sum,j-st1[s[j]]);
			}
			ans[a[i].id]=sum;
			for(int j=a[i].l;j<=a[i].r;j++){
				st1[s[j]]=0;
			}
			continue;
		}
		if(lst!=pos[a[i].l]){
			lst=pos[a[i].l];
			for(int i=l;i<=r;i++)ed[s[i]]=st[s[i]]=0;
			l=R[lst]+1,r=R[lst];
			sum=0;
		}
		while(r<a[i].r)addr(++r);
		int tmp=sum;
		while(l>a[i].l)addl(--l);
		ans[a[i].id]=sum;
		while(l<=R[lst])movel(l++);
		sum=tmp;
	}
}
int main(){
	ios::sync_with_stdio(false);
	init();
	solve();
	for(int i=1;i<=m;i++)cout<<ans[i]<<"\n";
	return 0;
}

解法2

有一说一，此题不用回滚莫队，可以 $O (n)$ 的预处理出每个数出现的位置的前一个和后一个出现位置，那么将 $a d d, d e l$ 都分 $l, r$ 讨论，借助前驱后继即可进行更新

树上莫队

二次离线莫队

posted @ 2022-11-30 22:41 spdarkle 阅读(52) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 分块全家桶

· 简单的分块

· 莫队学习笔记

· 莫队算法学习笔记

阅读排行：
· DeepSeek 开源周回顾「GitHub 热点速览」
· 记一次.NET内存居高不下排查解决与启示
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET 10首个预览版发布：重大改进与新特性概览！
· .NET10 - 预览版1新功能体验（一）

公告

昵称： spdarkle
园龄： 2年7个月
粉丝： 21
关注： 16

+加关注

2025年3月

日

一

二

三

四

五

六

spdarkle

莫队全家桶

莫队

XOR and Favorite Number

题面翻译

样例 #1

样例输入 #1

样例输出 #1

样例 #2

样例输入 #2

样例输出 #2

分析

莫队算法的变形

带修莫队

P2464

题目描述

输入格式

输出格式

样例 #1

样例输入 #1

样例输出 #1

提示

分析

例2

分析

例三

Machine Learning

题面翻译

题目描述

输入格式

输出格式

样例 #1

样例输入 #1

样例输出 #1

提示

分析

回滚莫队

只删不增的回滚莫队

例题：Rmq Problem / mex

描述

输入

分析

只增不删的回滚莫队

例题：洛谷模版

分析

解法1

解法2

树上莫队

二次离线莫队

公告

搜索

常用链接

合集

随笔档案

相册

阅读排行榜

评论排行榜

推荐排行榜

最新评论