这是一种基于根号的算法，核心为大块标记，散块暴力，做到复杂度的平衡。
可能第一个想到于此相关的就是莫队吧，这是利用分块优化暴力的方法。
这本不是莫队的题……
很显然，求 \(\mathrm{mex}\) 我们需要知道那些数是出现过的，这利用莫队很容易维护。
问题在于如何找到 \(\mathrm{mex}\)，很 naive 的想法是在每一次加入一个值的时候动态的找到当前的 \(\mathrm{mex}\)，但是这样的话如果构造数据使得它在 \(1\) 和 \(n\) 之间来回跳，复杂度就炸了，这很不可取。
同样的，如果我们暴力找到 \(\mathrm{mex}\) 的话，那么同样也可以被卡成每次 \(O(n)\)，复杂度也不可取。
于是考虑平衡查询的复杂度，做到 \(O(\sqrt n)\).
将值域每 \(B = \lfloor \sqrt n \rfloor\) 化作一块，显然的是，如果这一块内有 \(B\) 个不同的元素，那么 \(\mathrm{mex}\) 一定不在这个块内，所以每次加入/删除一个元素，我们只需要维护其所在的块不同的元素个数即可。
inline void add(int ap) {
if (but[ap]++ == 0) ++bbut[ap / B];
}
inline void del(int ap) {
if (--but[ap] == 0) --bbut[ap / B];
}
这就是加入/删除一个元素的函数，\(ap\) 表示这个元素，而其所在块的编号就是 \(\lfloor ap / B \rfloor\)。
而查询的时候，我们枚举块，找到第一个不足 \(B\) 个元素的块，然后在暴力在块内找没有出现过的元素即可：
int k = 0;
while (bbut[k] == B) ++k; // all number exists in block k.
// searching in block k.
k = k * B + B;
for (int i = k - B; i < k; ++i) {
if (but[i] == 0) mex = i, i = k; // i = k to break
}
由于只有 \(\lfloor n / B \rfloor\) 个块，每个块最多 \(B\) 个元素，所以查询一次的时间复杂度为 \(O(n / B + B)\)，根据均值不等式，当 \(B = \sqrt n\) 时有最优复杂度 \(O(\sqrt n)\)。
于是最终复杂度变为 \(O(n\sqrt n + m \sqrt n)\)，可以过。
接下来我们看非常典的一个分块题吧（这里我们知道思路即可，实现在后面谈及）。
虽然有树套树的做法，然而如果我只是删除或者加入一个元素，那么树套树维护就不是很容易了。
所以分块，考虑加入一个数对于整个序列逆序对的影响：
前面比他大的：在前面的块中二分求即可 \(O(\frac nB \log B)\)。
后面比他小的：在后面的块中二分求即可 \(O(\frac nB \log B)\)。
块内的，暴力求即可，删除和插入类似冒泡即可 \(O(B)\)。
于是将 \(B = \sqrt {n \log n}\)，单次修改复杂度便为 \(O(\sqrt {n \log n})\)。
然而预处理是 \(O(n \log n)\) 的，于是总的复杂度为 \(O(n \log n + m \sqrt {n \log n})\)，可以过。
接下来，我们就可以完成这道题了：CF1830E，也可以转化为动态维护逆序对的问题。
可能一上来的难度太高了，现在给一个简单题：
本题相当于区间异或 \(1\)，区间求和，所以对于散块，暴力异或，对于整块，打上懒标记即可。
很显然，这可以利用线段树做到 \(O(n + m \log n)\)，然而为了分块而分块，来分个块吧！
首先块长设为 \(B = \sqrt n\)，于是可以 \(O(1)\) 求出每一个点对应的块：
这里默认为
1-index。
#define Bk(i) (((i) - 1) / B + 1)
于是也可以很轻易的得出块所对应的左右端点 \([L_b, R_b]\)：
#define BL(b) ((b) * B - B + 1)
#define BR(b) ((b) * B)
此时我们需要修改 \([l, r]\)：
Bk(l) == Bk(r) 那么就可以暴力做：
// cnt[b][0/1] 表示第 b 块内 0/1 的个数
// rev[b] 是整块的懒标记
// val[x] 是其原本的
int b = Bk(l);
for (int i = l; i <= r; ++i) {
--cnt[b][val[i] ^ rev[i]];
val[i] ^= 1;
--cnt[b][val[i] ^ rev[i]];
}
否则，\(l\) 和 \(r\) 所在块内暴力，中间打标记即可：
int bl = Bk(l), br = Bk(r);
for (int i = l; i <= BR(bl); ++i) ...
for (int i = BL(br); i <= r; ++i) ...
for (int k = bl + 1; k < br; ++k)
rev[k] ^= 1, swap(cnt[k][0], cnt[k][1]);
修改部分如上，而查询也十分类似，分两种情况即可。
那么分块的思想有了，接下来就是板子的练习了。
在 LibreOJ 上有很多板子，从 数列分块入门 1 到 数列分块入门 9 都是很好的练习题。
接下来我们稍稍上升，讲一讲 [Violet] 蒲公英 - 洛谷，一道很好的分块题：
假定我们已经分好了块，求区间 \([l, r]\) 的众数。
依据大块标记，散块暴力的思想，我们将他看作三个部分：
整块是多个 \(\sqrt n\) 的块！
显然的是，众数要么是整块的众数，要么出现在两侧的散块中，这提示我们可以先预处理出块两两之间的众数，这一共是 \(O(\sqrt n) \times O(\sqrt n) = O(n)\) 个，然后再两侧枚举判断是否更加优秀。
然而判断需要其出现的数量，于是我们需要处理出每一个数在块中出现的次数，做前缀和，然后差分即可求出在整块中的个数。而对于散块中的数，可以额外再开一个桶记录其出现的次数即可。
不过为了开这个桶，我们可能需要对于这些数离散化一下，变成 \(O(n)\) 个连续的值，不然根本开不下……
for (int i = 1; i <= n; ++i)
++f[bk(i)][a[i]];
for (int b = 2; b <= be; ++b) {
for (int i = 1; i <= n; ++i)
f[b][i] += f[b - 1][i];
}
现在唯一的问题就剩下了如何预处理出每个整块的众数。
令 \(most_{i, j}\) 表示第 \(i\) 块到第 \(j\) 块的众数（\(i \le j\)），于是类似在查询时的思想，\(most_{i, j}\) 要么是 \(most_{i, j - 1}\)，要么出现在第 \(j\) 块中。
#define cnt(v, i, j) (f[j][v] - f[(i) - 1][v])
for (int i = 1; i <= be; ++i) {
for (int j = i; j <= be; ++j) {
int most = g[i][j - 1];
for (int k = BL(j), ke = BR(j); k <= ke; ++k)
if (cnt(a[k], i, j) > cnt(most, i, j) || (cnt(a[k], i, j) == cnt(most, i, j) && a[k] < most))
most = a[k];
g[i][j] = most;
}
}
于是枚举本块的所有元素与之对比即可，所以求一个 \(most_{i, j}\) 是 \(O(\sqrt n)\) 的，故预处理部分是 \(O(n \sqrt n)\) 的。
之所以可以通过离散化后的值比较原本值的大小……排序后离散化的
sort(app + 1, app + 1 + apc); int *ae = unique(app + 1, app + 1 + apc); for (int i = 1; i <= n; ++i) a[i] = lower_bound(app + 1, ae, a[i]) - app;
所以分块在什么时候用呢？
可能满足的条件如下：
\(n, m \le 10^5\)。
没有办法，或者很难用线段树维护（信息不满足区间加）。
修改和查询的数量明显不同阶，需要 \(O(1) - O(\sqrt n)\) 的数据结构平衡复杂度。
……