莫队学习笔记
都0202年了怎么还会考根号数据结构呢？
莫队是一种用于处理静态区间查询的一类方法，其的时间复杂度为 \(O(n\sqrt m+m)\)。
当然，由于其适用面之广，也出现了诸如带修莫队，在线莫队，二次离线莫队，树上莫队，二维莫队 以及套在一起 的变形。
1.普通莫队
首先我们要明白，莫队究竟是怎么优化暴力的。
考虑这样一道题：给定 \(n\) 个数字，\(m\) 次询问区间 \([l_i,r_i]\) 出现次数最多的数的出现次数。\(n,m,a_i\leq 10^5\)
这是最经典的区间众数，一般情况只有根号做法。莫队就是其中一种。
考虑如何用莫队处理这件事：
首先如果只有一次询问，是不是很好处理：直接用一个桶记录某个数字出现次数即可，然后更新的同时处理最大值。
那么再考虑如果保证询问 \(\forall i<j\leq m\ ,\ l_i\leq l_j\ ,\ r_i\leq r_j\) 怎么处理？
显然我们可以用类似于双指针的思想，不断加入右指针 \(pr\) 的值并向右移动直到 \(pr=r_i\)，再不断删除左指针 \(pl\) 的值并向右移动直到 \(pl=l_i\)。复杂度 \(O(n+m)\)。
再考虑如果保证询问 \(\forall i,j\leq m\ ,\ \text{若}\ l_i< l_j\ \text{那么}\ r_i\leq r_j\) 怎么处理？
按左端点排个序就好了。复杂度 \(O(n\log n)\)。
但是，几乎不会有题会有这种限制。如果单纯的按左端点排序，右指针移来移去，显然会被卡成 \(O(n^2)\)。
所以现在我们就要一个新的排序方式，这就是莫队的精髓（没错，重点就在于排序）。
我们发现，假如我们按左端点为第一关键字，右端点为第二关键字，那么右指针的运动距离是 \(O(n^2)\) 的，而左指针却只有 \(O(n)\)。
显然这应该是可以优化的。具体来说，我们并不一定要求左指针严格递增，只要它不超过 \(O(\sqrt{n})\) 就好了。
这样我们得出了一种排序：首先先将所有点按某一数字 \(B\) 分块，即 \(b_i=\frac i B\)。
然后对于一个区间，先按左指针的所在块排序，再按右指针排序，即 \(b_{l_i}\) 为第一关键字，\(r_i\) 为第二关键字。
可以发现，由于最多只有 \(\frac n B\) 个块，所以左指针移动路程为 \(O(\frac{n^2} B)\)，而右指针在每个块中最多移动 \(O(n)\) 步，所以移动路程为 \(O(nB)\)。
所以总复杂度 \(O(\frac{n^2} B+nB)\)，显然当 \(B=\sqrt m\) 时最小，即 \(O(n\sqrt m+m)\)。
例题太多了，洛谷题单里面较简单的应该都是普通莫队。
虽然它是一个根号算法，但是它常数真的很小。它还有一些优化，其中比较有用的是奇偶优化，即对于奇数的右端点从左到右排，偶数的从右到左排。
这样由于处理完奇数后右端点在最右端，不用移回左端点重新做，所以可以减小将近一半的常数。
2.带修莫队
虽然普通莫队很优秀，常数也比分块高明了不少，但是它终究还是静态的，如果加一个修改就没办法了。
所以我们就需要一个变形：带修莫队。
首先我们把修改操作也离线下来，看成一个时间。然后对于某个询问，也加上时间，即 \((l,r,t)\) 表示询问 \([l,r]\) 区间，并且在 \(t\) 时间操作后进行询问。
然后我们把时间也看成一个指针。特别，如果加入的修改在当前区间里面，应当立刻对区间答案进行修改处理影响。
那么这样，我们的排序就变成：先按 \(b_{l_i}\) 排序，再按 \(b_{r_i}\) 排序，再按 \(t_i\) 排序。
分析复杂度：\(O(\frac{n^3} {B^2}+\frac{n^2} B+nB)\)。取 \(B=n^{\frac 2 3}\)。得到 \(O(n^{\frac 5 3})\)。
同样，常数还是很小。不要相信莫队的时间复杂度。
3.回滚莫队
按照莫队的做法，我们需要支持一个数据结构，使之能够快速插入/删除一个数字。
但事实上有很多数据结构删除会存在问题，比如并查集/线性基/求最大值。这时候普通莫队就会出现问题。
那么，有没有一种莫队能够只插入呢？有的，这就是回滚莫队。
具体来说，对于两个区间 \([l_1,r_1],[l_2,r_2]\)，如果 \(l_1,l_2\) 在同一个块中，那么该块的右端点到 \(\min(r_1,r_2)\) 这段区间是公共的。
可以发现，按照莫队的排序，如果左指针在同一个块中，那么右指针单调递增。所以右指针是不会有删除操作的。
所以我们不妨每次先记录左指针移动前的答案和移动时的所有变化，在移动结束之后，将这部分变化和左指针归位，即“回滚”。
特别的，对于左右端点在同一块内的情况，暴力处理即可。如果两次操作不同块，直接暴力清空所有数据，然后左右指针直接移动到新块的右端点。
可以发现，由于在同一块内，每次左指针移动距离 \(O(\sqrt n)\)，复原一次 \(O(\sqrt n)\)，右端点一个块中均摊 \(O(m)\)，所以总复杂度还是 \(O(n\sqrt m+m\sqrt n)\)。
4.树上莫队
详见 [WC2013] 糖果公园。其实树上莫队应该叫树+莫队，因为莫队处理的还是序列。
5.在线莫队
这个其实和普通莫队有一些出入了。毕竟莫队的本质应该就是那个排序（？）。
首先，我们要处理的询问是允许差分的，即对于 \([l,r]_x\)（\(x\) 对于区间 \([l,r]\) 的贡献）的信息，我们可以通过 \([1,r]_x\) 和 \([1,l-1]_x\) 推出。
考虑强制在线时，我们不能得到上一次的结果。所以我们对 \(B\) 个区间分别设置一个关键点，然后处理所有 \([1,b_i]_x\)。对于块与块之间的信息，我们只需要记录答案就行。
这样预处理时空复杂度 \(O(Bn+\frac{n^2} B)\)。
询问的时候我们从最近的一段块转移过来，时间复杂度 \(O(Bm)\)。
显然当 \(B=\sqrt n\) 时总时间复杂度 \(O(m\sqrt n)\) 最优。
6.二次离线莫队
一个很神仙的算法，不过不是很难理解。
当然使用的前提还是询问可差分.
但是我们发现直接莫队，由于插入/删除的时间 \(T(n)\) 比较大（比如区间逆序对中采用树状数组是 \(T(n)=O(\log n)\)），总时间可能会退化成 \(O(T(n)n\sqrt n)\) 而难以接受。
考虑如何优化。我们可以把操作看成若干次 \(\pm\ [l,r]_x\) 操作。差分后就是若干次 \(\pm\ [1,r]_x\)。
而这个可以直接离线从左往右 \(O(nT(n)+M)\) 完成。这里 \(M\) 是莫队移动指针的次数，即 \(M=O(m\sqrt n)\)。
这样时间已经足够优秀了，不过空间是 \(O(n+M)\) 即 \(O(m\sqrt n)\) 的，可能会爆炸。
考虑如何优化。因为 \([1,r]_x\) 中 \(x=l\operatorname{或}r\operatorname{或}l-1\operatorname{或}r+1\)，对于2,4种我们完全可以先预处理出来，直接计入答案。
考虑1,3种，我们移动左指针时右指针并不会移动，所以此时连续的 \(x_i\) 一定构成一个区间。我们直接存下这个区间就好了。
这样空间复杂度 \(O(n+m)\)，时间 \(O((n+m)T(n)+m\sqrt n)\)，十分优秀。
例：【模板】莫队二次离线
首先 \(a\operatorname{xor} b=c\Rightarrow a\operatorname{xor} c=b\)，而 \(\operatorname{popcount}(c)=k\)，所以我们可以枚举所有 \(c\)，得到 \(b\)。
因为一次插入/删除操作只能用比较暴力的枚举，即一次 \(\binom {14} k\)，最坏大约有3000多次。
显然我们无法接受 \(O(m\sqrt n\binom {14} k)\)。考虑二次离线。
显然一个数字对区间的贡献 \([l,r]_x=[1,r]_x-[1,l-1]_x\) 可以差分。按照上述方式就可以做到 \(O(n\binom {14} k+m\sqrt n)\) 的优秀复杂度。
细节比较多。
#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
#define ll long long
#define N 100010
#define B 14
#define M 16400
using namespace std;
int g[3500],f[M],tot;
int bl[N],a[N];
inline void ins(int x,int v){for(int i=1;i<=tot;i++) f[g[i]^x]+=v;}
struct node{
int l,r,id;
bool operator <(const node a)const{return bl[l]==bl[a.l]?r<a.r:bl[l]<bl[a.l];}
}q[N];
ll ans[N];
struct ques{
int l,r,id;//[1,x]_l~[1,x]_r
};
vector<ques>v[N];
ll res1[N],res2[N];//[1,x]_{x+1},[1,x+1]_{x}
int fl=1,fr,uid;
void addqr()
{
++fr;
if(v[fl-1].size() && v[fl-1][v[fl-1].size()-1].id==-uid) v[fl-1][v[fl-1].size()-1].r=fr;
else v[fl-1].push_back((ques){fr,fr,-uid});
}
void delqr()
{
if(v[fl-1].size() && v[fl-1][v[fl-1].size()-1].id==uid) v[fl-1][v[fl-1].size()-1].l=fr;
else v[fl-1].push_back((ques){fr,fr,uid});
--fr;
}
void addql()
{
if(v[fr].size() && v[fr][v[fr].size()-1].id==-uid) v[fr][v[fr].size()-1].r=fl;
else v[fr].push_back((ques){fl,fl,-uid});
++fl;
}
void delql()
{
--fl;
if(v[fr].size() && v[fr][v[fr].size()-1].id==uid) v[fr][v[fr].size()-1].l=fl;
else v[fr].push_back((ques){fl,fl,uid});
}
int main()
{
int n,m,k;
scanf("%d%d%d",&n,&m,&k);
for(int i=0;i<1<<B;i++)
if(__builtin_popcount(i)==k) g[++tot]=i;
for(int i=1;i<=n;i++) scanf("%d",&a[i]),bl[i]=i/344;
for(int i=1;i<=m;i++) scanf("%d%d",&q[i].l,&q[i].r),q[i].id=i;
sort(q+1,q+m+1);
for(uid=1;uid<=m;uid++)
{
while(fl<q[uid].l) addql();
while(fl>q[uid].l) delql();
while(fr<q[uid].r) addqr();
while(fr>q[uid].r) delqr();
}
for(int i=1;i<=n;i++)
{
res1[i]=f[a[i]];
ins(a[i],1);
res2[i]=f[a[i]];
for(int j=0;j<(int)v[i].size();j++)
{
for(int k=v[i][j].l;k<=v[i][j].r;k++)
{
if(v[i][j].id<0) ans[-v[i][j].id]-=f[a[k]];
else ans[v[i][j].id]+=f[a[k]];
}
}
}
fl=1,fr=0;
for(uid=1;uid<=m;uid++)
{
ans[uid]+=ans[uid-1];
while(fl<q[uid].l) ans[uid]+=res2[fl],fl++;
while(fl>q[uid].l) --fl,ans[uid]-=res2[fl];
while(fr<q[uid].r) ++fr,ans[uid]+=res1[fr];
while(fr>q[uid].r) ans[uid]-=res1[fr],fr--;
}
for(int i=1;i<=m;i++) res1[q[i].id]=ans[i];
for(int i=1;i<=m;i++) printf("%lld\n",res1[i]);
return 0;
}
7. 套一起
总结：莫队是一个十分优秀的算法。虽然赛场上不一定会作为标程（眼泪的时代），就算出了我也不会写。但其也不乏为一个优秀的骗分技巧。
