简介
莫队算法是由莫涛提出的算法。
在莫涛提出莫队算法之前，莫队算法已经在 Codeforces 的高手圈里小范围流传，但是莫涛是第一个对莫队算法进行详细归纳总结的人。
莫涛提出莫队算法时，只分析了普通莫队算法，但是经过 OIer 和 ACMer 的集体智慧改造，莫队有了多种扩展版本。
莫队算法可以解决一类离线区间询问问题，适用性极为广泛。同时将其加以扩展，便能轻松处理树上路径询问以及支持修改操作。
—— OI-Wiki
普通莫队
例题：给定一个长为n的序列 \(a_1, a_2, ..., a_n\)，有m次查询，每次查询求区间 \([l, r]\)中满足: \(l \leq i < j < k \leq r\)，\(a_i = a_k > a_j\)的三元组\((i, j, k)\)的个数。
莫队用于处理这样的问题：离线多次查询序列区间，每次查询都需要\(O(n)\)的时间计算答案，但是由区间\([l, r]\)的答案计算\([l + 1, r], [l - 1, r], [l, r + 1], [l, r - 1]\)的答案时只需要\(O(1)\)的时间。
当已知\([l, r]\)的答案，要计算\([l^{'}, r^{'}]\)的答案时，只需将\(l\)转移到\(l^{'}\), \(r\)转移到\(r^{'}\)，将区间两个端点看成平面坐标系上的一个点的横纵坐标，转移过程所需要的步数即为两点之间的曼哈顿距离。
由此，我们可以将所有点在平面坐标系中画出来，最佳的转移方案即为一个最小生成树，其中两点之间的距离为曼哈顿距离，转移所需的步数为最小生成树的大小。
考虑对查询区间进行如下的排序方式，可以获得较优的转移顺序：
将序列按照\(\sqrt n\)大小分块，从左到右标上序号，按照查询区间左端点所属分块序号为第一关键字，右端点大小为第二关键字排序，最终在\(n=m\)的情况下计算所有答案的时间复杂度为\(O(n \sqrt n)\)
给出一个不太严谨的证明：
首先分块之后，每个块大的大小为\(\sqrt n\)，块的数量为\(\lceil \sqrt n \rceil\)，暴力计算每个块的第一个查询区间，每次计算\(O(n)\)，共有\(\lceil \sqrt n \rceil\)次，时间复杂度为\(O(n \sqrt n)\)。在同一个块中，右端点单调递增，转移右端点的复杂度为\(O(n)\)，左端点每次转移都在同一块中，复杂度为\(O(\sqrt n)\)，转移的总数为\(n\)次，总复杂度为\(O(n \sqrt n)\)。
对于上面的例题，首先用树状数组求出每个位置\(i\)前面满足\(a_j < a_i\)的\(j\)的数量，记为\(c_i\)。为了\(O(1)\)转移，还需记录两个数组\(tot_i\)和\(sum_i\)，分别表示当前区间中值为\(i\)的位置的数量和总和。
分四种情况：
\(r\)到\(r + 1\)，答案增加\(tot_{a_{r + 1}} \cdot c_{r + 1} - sum_{a_{r + 1}}\)
\(l\)到\(l - 1\)，答案增加\(sum_{a_{l - 1}} - tot_{a_{l - 1}} \cdot c_{l - 1}\)
\(r\)到\(r - 1\)，答案减少\((tot_{a_r} - 1) \cdot c_r - (sum_{a_r} - c_r)\)
\(l\)到\(l + 1\)，答案减少\((sum_{a_l} - c_l) - (tot_{a_l} - 1) \cdot c_l\)
代码
#include <bits/stdc++.h>
using namespace std;
typedef long long lld;
const int N = 500005;
struct Que {
int l, r, num;
lld ans;
};
int n, m, a[N];
lld c[N], tot[N], sum[N];
vector <int> poss[N];
lld s[N];
int siz, id[N], numb;
Que que[N];
inline int lowbit(int x) {
return x & -x;
}
void add(int x, int k) {
for(; x < N; x += lowbit(x)) s[x] += k;
}
int Sum(int x) {
int summ = 0;
for(; x; x -= lowbit(x)) summ += s[x];
return summ;
}
bool cmp1(Que a, Que b) {
if(id[a.l] == id[b.l]) return a.r < b.r;
return id[a.l] < id[b.l];
}
bool cmp2(Que a, Que b) {
return a.num < b.num;
}
int main() {
// freopen("data.in", "r", stdin);
ios::sync_with_stdio(false);
cin >> n >> m;
siz = (int)sqrt(n); numb = ceil((double)n / (double)siz);
for(int i = 1; i <= numb; i++) {
for(int j = (i - 1) * siz + 1; j <= i * siz; j++) {
id[j] = i;
}
}
for(int i = 1; i <= n; i++) {
cin >> a[i];
poss[a[i]].push_back(i);
}
for(int i = 1; i <= m; i++) {
cin >> que[i].l >> que[i].r;
que[i].num = i;
}
for(int i = 1; i <= n; i++) {
if(poss[i].size()) {
for(auto j : poss[i]) {
c[j] = Sum(j);
}
for(auto j : poss[i]) {
add(j, 1);
}
}
}
sort(que + 1, que + 1 + m, cmp1);
int l = 1, r = 0; lld ans = 0;
for(int i = 1; i <= m; i++) {
int nowl = que[i].l, nowr = que[i].r;
while(l < nowl) {
ans = ans - ((sum[a[l]] - c[l]) - (tot[a[l]] - 1) * c[l]);
tot[a[l]]--; sum[a[l]] -= c[l]; l++;
}
while(l > nowl) {
ans = ans + (sum[a[l - 1]] - tot[a[l - 1]] * c[l - 1]);
tot[a[l - 1]]++; sum[a[l - 1]] += c[l - 1]; l--;
}
while(r < nowr) {
ans = ans + (tot[a[r + 1]] * c[r + 1] - sum[a[r + 1]]);
tot[a[r + 1]]++; sum[a[r + 1]] += c[r + 1]; r++;
}
while(r > nowr) {
ans = ans - ((tot[a[r]] - 1) * c[r] - (sum[a[r]] - c[r]));
tot[a[r]]--; sum[a[r]] -= c[r]; r--;
}
que[i].ans = ans;
}
sort(que + 1, que + 1 + m, cmp2);
for(int i = 1; i <= m; i++) {
cout << que[i].ans << endl;
}
return 0;
}