根号算法学习笔记

最近整理并学习了一些根号算法，总共分为三个。

$1.$ 莫队

$2.$ 分块

$3.$ 根号分治

$1.$ 莫队

$1_{.}$ 序列莫队

这是一个离线算法（当然有在线的， 但是 CCF 不会卡吧）。

它可以在 $q\sqrt{n}+n\sqrt{n}$ 的时间内解决数列上多组询问的问题，问题大多给一个区间 $l$ $r$，让你输出 $[l,r]$ 的某个信息，比如区间和。

莫队的思想就是维护一个当前拥有信息的指针 $L$ $R$，通过不断地移动 $L$ $R$ 的位置添加或删除数字来得到 $l$ $r$ 的答案。

假如要求 $[2,5]$ 的区间和，现在手头上有 $[3,4]$ 的区间和，加上 $a[2]$ 和 $a[5]$ 的值就可以了。

现在归纳一下，假如有的信息是 $[L,R]$，要求 $[l,r]$，就可以通过 $|L-l|+|R-r|$ 次移动得到答案了。

所以我们要把所有的询问排一下序，使得 $\sum _{i=2}^n|a[i].l-a[i-1].l|+|a[i].r-a[i-1].r|$ 最小，这个有人证明过最小是 值域乘以 $\log$ 值域的，但怎么排列是一个 NP Hard，莫队算法的优势就是简洁好写，如果和 NP hard 弄在一起...

所以现在要做的就是找到一种容易求得的排列方式，代价又小。

如果仅仅按照右端点来排序，左端点一次在很前面，一次在很后面的交替，就卡死了。

如果按照左端点排序，右端点也可以移来移去还是不行。

我们需要找到一种兼顾左端点和右端点的排序方法，如果按照左端点所在的块排序，块相同的按照右端点排序就会很快。

设块长为 $b$，右端点在每个块内都会移动 $n$ 次，一共 $\frac{n}{b}$ 个块，所以 $\frac{n^2}{b}$。

左端点在每个块内每次都会移动 $b$，跨越块的移动 $b$ 次，每次 $\frac{n}{b}$，所以需要 $nb+n$

现在找到 $b$ 使得这两个加起来最小，显然 $b=\sqrt{n}$，这就是莫队算法。

$0xFF$ 浅谈在线莫队

在线莫队的思想其实很简单，先预处理出一些区间的答案，询问时找到离询问参数 $l$ $r$ 最近的预处理过的 $L$ $R$ 然后转移过去。

怎样预处理呢？我们每隔 $\sqrt{n}$ 个数就留下一个特征点，这样就有 $\sqrt{n}$ 个特征点，每两个特征点搭配组成特征区间，所以大约有 $\frac{n}{2}$ 个特征区间。

每次询问给定参数 $l$ $r$，对于部分莫队题目，加操作（即 l 向左，r 向右）能做，减操作无法处理，就要找到被 $l$ $r$ 包含的最大的特征区间，这样在线莫队代替回滚莫队？！！

对于加操作减操作都能处理的，那就找最近的特征区间啦！

莫队核心代码:：

while (r < a[i].r) add (++ r);
while (l > a[i].l) add (-- l);
while (r > a[i].r) rem (r --);
while (l < a[i].l) rem (l ++);

$0xFE$ 莫队总结

讲完这个，我们就来看几道例题。

能用莫队解决的题目，大概具有什么特点呢？

询问可支持离线（在线莫队不管），数据范围不卡 $n\sqrt{n}$（废话），没有修改操作（只是对于简单的莫队而言）

可以以较低的复杂度移动左右指针（为什么是较低，因为后面有一道题 $\log n$ 移动然后卡过了）。

例题

P2709 小 B 的询问

当然不像我们说的那么简单，维护区间和，这题要维护一个桶。

加入一个数 $x$ 之前其出现次数为 $b[x]$，那么加完后区间的答案 $ans$ 就变成 $ans-b[x{]}^2+(b[x]+1{)}^2$。

当然可以化简成 $ans+2\times b[x]+1$，减去一个数同理啦，略。

#include <cmath>
#include <iostream>
#include <algorithm>
using namespace std;
int n, m, k;
int l, r, sum = 1, block;
int c[50010], ans[50010], cnt[50010];
struct Sec{int l, r, id;}a[50010];
void add (int x)
{
    sum += 2 * cnt[c[x]] + 1;
    cnt[c[x]] ++;
}
void rem (int x)
{
    sum -= 2 * cnt[c[x]] - 1;
    cnt[c[x]] --;
}
bool cmp (Sec s1, Sec s2){return s1.l / block < s2.l / block || s1.l / block == s2.l / block && s1.r < s2.r;}
int main()
{
    scanf("%d%d%d", &n, &m, &k);
    block = sqrt(n);
    for (int i = 1; i <= n; i ++) scanf("%d", &c[i]);
    for (int i = 1; i <= m; i ++)
    {
        scanf("%d%d", &a[i].l, &a[i].r);
        a[i].id = i;
    }
    sort (a + 1, a + m + 1, cmp);
    l = r = a[1].l;
    cnt[c[l]] ++;
    for (int i = 1; i <= m; i ++)
    {
        while (r < a[i].r) add (++ r);
        while (l > a[i].l) add (-- l);
        while (r > a[i].r) rem (r --);
        while (l < a[i].l) rem (l ++);
        ans[a[i].id] = sum;
    }
    for (int i = 1; i <= m; i ++) cout << ans[i] << "\n";
    return 0;
}

 

P4462 异或序列

属于是半思维半莫队啦！

首先你需要知道异或具有自反性，即 $a\oplus a=0$。

令 $o_i=a_1\oplus a_2\cdots \oplus a_i$，那么 $a_x\oplus a_{x+1}\cdots \oplus a_y$ 就等于 $o_y\oplus o_{x-1}$。

询问有多少子区间异或和为 $k$ 其实就相当于询问有多少个点 $x$ $y$，其中 $l-1\le x\le r-1$，$l\le y\le r$，使得 $o_x\oplus o_y=k$。

$k$ 是已知的，假如我们要假如第 $R$ 个位置，那就需要统计在合法的范围内，$o_L\oplus o_R=k$，$L$ 的数量喽，可以先算出 $o_L$ 的值 $=k\oplus o_R$。

那么我们用一个桶维护，$b[x]$ 维护的就是 $o_L=x$ 的数量，减也同理就不说了。（注意这里我没有加减函数都写，而是用一个参数使一个函数替代这两个的作用了，码风更加清新）

#include <iostream>
#include <algorithm>
using namespace std;
int n, m, k;
int l = 1, r, res;
int a[100005], b[100005], ans[100005];
struct Node {int l, r, id;}q[100005];
bool cmp (Node n1, Node n2) {return n1.l / 300 < n2.l / 300 || n1.l / 300 == n2.l / 300 && n1.r < n2.r;}
void fun (int x, int s) {
    res += s * b[x ^ k];
    b[x] += s;
}
int main () {
    cin >> n >> m >> k;
    for (int i = 1; i <= n; i ++) {
        cin >> a[i];
        a[i] ^= a[i - 1];
    }
    for (int i = 1; i <= m; i ++) {
        cin >> q[i].l >> q[i].r;
        -- q[i].l;
        q[i].id = i;
    }
    sort (q + 1, q + m + 1, cmp);
    for (int i = 1; i <= m; i ++) {
        while (r < q[i].r) fun (a[++ r], 1);
        while (l > q[i].l) fun (a[-- l], 1);
        while (l < q[i].l) fun (a[l ++], -1);
        while (r > q[i].r) fun (a[r --], -1);
        ans[q[i].id] = res;
    }
    for (int i = 1; i <= m; i ++) cout << ans[i] << "\n";
    return 0;
}

P3834 【模板】可持久化线段树

也是一道莫队的题目，我们可以采用莫队套线段树，每次加一个数就在权值线段树上加，查询就线段树上二分，时间复杂度为 $O(n\sqrt{n}\times \log n)$，加上奇偶排序（待会儿讲）就过了。

当然，如果你不会线段树，也不要紧，这仅仅是一个跳板，我们发现每加一个数时间复杂度 $O(\log n)$ 较高，这是我们不喜欢的，而查询时间复杂度为 $O(\log n)$，

这导致每次移动完左右区间，查询的复杂度加起来仅为 $O(n\log n)$，所以要找到一个加操作 $O(1)$，查询较低的来中和一下，那不就是值域分块吗？查询总时间复杂度 $O(n\sqrt{n})$，也不高于莫队，正正好好。

代码大家可以参考扶咕咕的题解。

其他题目

关于莫队的题目数不胜数，给个题单，https://www.luogu.com.cn/training/38213#problems。

带修莫队

带修莫队，顾名思义就是带修改的莫队，其实也很简单。

我们每个询问有三个参数了：$l$ $r$ $t$，$t$ 是前面经过了多少次的修改操作。

即我们把时间轴也当成一个参数来移动了，如果看不懂就看代码。

询问的排序大家可以先不看，自己口胡一下。

这里我要说一下区间的转移，首先还是 $l$ $r$ 移动到当前询问的 $L$ $R$，最后再移动 $t$ 到 $T$。

这样就可以做修改操作时不影响答案，举个例子：

$L=2$ $R=5$ $T=1$。

$l=3$ $r=4$ $t=0$。

其中 $1$ 号修改操作是 把第 $2$ 个改为某个新的颜色，这时如果你先做修改，发现这个修改不在 $l$ $r$ 内就忽略掉了，你的桶 $cnt$ 维护的是 $l$ $r$ 中数字出现了多少次。

大家大概明白了吧，但是这个我不好用准确的语言描述。

 

 

 

 

排序方法就是按照左端点所在的块排序，相同的按照右端点所在的块排序，再相同按照 $t$ 排序。

时间复杂度如何呢？我们设块长为 $b$，那么左端点每次会移动 $b$ 次，一共 $n$ 次，跨越区间移动 $n/b$ 次，每次 $b$，总共 $nb$。

右端点，它每次会移动 $b$ 次。跨越块的移动忽略不计。每次左端点换到下一个块了右端点移动 $n$ 次，一共切换 $n/b$ 次，时间复杂度为 $n^2/b+nb$。

$t$ 最好算了，左端点和右端点每在一个块内时，也就是 $(n/b{)}^2$ 种，每次右从前到后移动 $n$ 次，所以 $n^3/b^2$。

总时间复杂度为 $n^2/b+n^4/b^2+nb$，当 $b$ 取 $n^{\frac{2}{3}}$ 时有最优复杂度 $n^{\frac{3}{5}}$，足以过 $1e5$。

P1903 数颜色

写带修莫队时注意，看我发的警示贴

这题是一个最基本的带修莫队，主要是还要开一个结构体存修改操作，警示贴大家看过了我就不多说了，代码虽然很长，只要看带修莫队移动指针的部分就行了：

#include <cmath>
#include <iostream>
#include <algorithm>
using namespace std;
char op;
int n, m, x, y;
int su, sq, block;//su:sum of update sq:sum of query
int l, r, tim, sum = 1;//time:time 但是不让用这个变量
int t[140000], ans[140000], cnt[1000010], color[140000];
struct Question{int l, r, t, id;}q[140000];
void add(int x)
{
    if (! cnt[x]) ++ sum;
    ++ cnt[x];
}
void rem(int x)
{
    -- cnt[x];
    if (! cnt[x]) -- sum;
}
struct Upd{int id, pre, val;}u[140000];
bool cmp (Question q1, Question q2)
{
    if (q1.l / block < q2.l / block) return true;
    if (q1.l / block == q2.l / block && q1.r / block < q2.r / block) return true;
    if (q1.l / block == q2.l / block && q1.r / block == q2.r / block && q1.t < q2.t) return true;
    return false;
}
int main ()
{
    scanf("%d%d", &n, &m);
    block = pow (n, 2.0 / 3);
    for (int i = 1; i <= n; ++ i)
    {
        scanf("%d", &color[i]);
        t[i] = color[i];
    }
    for (int i = 1; i <= m; ++ i)
    {
        cin >> op >> x >> y;
        if (op == 'Q') q[++ sq] = Question{x, y, su, sq};
        else
        {
            u[++ su] = {x, t[x], y};
            t[x] = y;
        }
    }
    sort (q + 1, q + sq + 1, cmp);
    l = r = q[1].l;
    cnt [color[l] ] ++;
    for (int i = 1; i <= sq; i ++)
    {
        while (r < q[i].r) add(color[++ r]);
        while (l > q[i].l) add(color[-- l]);
        while (r > q[i].r) rem(color[r --]);
        while (l < q[i].l) rem(color[l ++]);
        while (tim < q[i].t)
        {
            tim ++;
            if (l <= u[tim].id && r >= u[tim].id)
            {
                rem(u[tim].pre);
                add(u[tim].val);
            }
            color[u[tim].id] = u[tim].val;
        }
        while (tim > q[i].t)
        {
            if (l <= u[tim].id && r >= u[tim].id)
            {
                rem (u[tim].val);
                add (u[tim].pre);
            }
            color[u[tim].id] = u[tim].pre;
            tim --;
        }
        ans[q[i].id] = sum;
    }
    for (int i = 1; i <= sq; i ++) cout << ans[i] << "\n";
    return 0;
}

P2464 郁闷的小 J

和上一题一样，只不过要离散化，我这里用了一个垃圾回收站来处理，实在不行用 map 亦可。

代码略（好像是 ctj AC 的？？？）

莫队的优化

最简单的一个就是奇偶排序了，就从最基础的序列莫队看，当一个块处理完后，右端点最坏在最后一个，而在下一个块开始时，右端点又在第一个了。

每过一个块，右端点就会多移动 $n$ 次，所以左端点块相同，如果左端点所在块是奇数那么升序，否则降序，这样就能少一半常数，甚至能过 $1e6$！

大家有没有想过带修莫队，左端点总共只移动 $nb$ 次，而右端点要移动 $n^2/b$ 次，最多的 $t$，要移动 $n^3/b^2$ 次，有没有办法平衡一下呢？

其他莫队

其他的感觉大家看看题解啊能自己口胡出来的，那我就不说了，在线莫队都讲过了

$2.$ 分块

$1.$ 序列分块

遇到一道毒瘤题时，大家的选择是什么？就打数据结构认怂吗？不！我们还有对付毒瘤的专用武器，那就是分块。

分块常数小，甚至在数据 CPU 配置相同的情况下比单 log 的平衡树还要快（

我们来介绍一下分块算法吧，如果你学过线段树，那就会很轻松。

分块算法的思路也是打懒标记，一个长度为 $n$ 的区间，把它分成 $\sqrt{n}$ 个块，每块 $\sqrt{n}$ 个元素。

每个大块都会维护它的信息诸如和，懒标记等一些东西。

询问的时候，设左右端点为 $l$ $r$，找到它们中间的大块把答案统计掉，剩下的直接暴力。

可以发现，最多找到 $\sqrt{n}$ 个大块，合并这些信息的时间复杂度一般为 $\sqrt{n}$。

大块旁边的元素个数是小于 $\sqrt{n}$ 的，不然它又会成为一个大块了呀。

所以一次询问的时间复杂度为 $\sqrt{n}$。

例题

P3372 【模板】线段树 1

多么好的一道数据结构模板题啊，可是我就要用分块。

刚刚的内容已经讲的很清晰了，大家试着自己写下代码，我贴个 AC 代码：

#include <cmath>
#include <iostream>
using namespace std;
long long n, m, sz;
long long op, x, y, k;
long long a[100010], sum[316], add[316];
int sec (int x) {
    if (x > sz * sz) return sz;
    return x / sz + (x % sz != 0);
}
int len (int x) {
    int l = sz * (x - 1) + 1, r = sz * x;
    if (x == sz) r = n;
    return r - l + 1;
}
int main () {
    scanf("%lld%lld", &n, &m);
    sz = pow(n, 0.5);
    for (int i = 1; i <= n; i ++) {
        scanf("%lld", &a[i]);
        sum[sec(i)] += a[i];
    }
    while (m --) {
        scanf("%lld%lld%lld", &op, &x, &y);
        int secl = sec(x), secr = sec(y);
        if (op == 1) {
            scanf("%lld", &k);
            if (secl == secr) {
                for (int i = x; i <= y; i ++) a[i] += k;
                sum[secl] += (y - x + 1) * k;
            } else {
                for (int i = x; i <= sz * secl; i ++) a[i] += k;
                sum[secl] += k * (sz * secl - x + 1);
                secl ++;
                for (int i = sz * (secr - 1) + 1; i <= y; i ++) a[i] += k;
                sum[secr] += k * (y - sz * (secr - 1) );
                secr --;
                for (int i = secl; i <= secr; i ++) add[i] += k;
            }
        }
        else {
            long long ans = 0;
            if (secl == secr) {
                for (int i = x; i <= y; i ++) ans += a[i];
                printf("%lld\n", ans + add[secl] * (y - x + 1) );
            }
            else {
                for (int i = x; i <= sz * secl; i ++) ans += a[i] + add[secl];
                secl ++;
                for (int i = sz * (secr - 1) + 1; i <= y; i ++) ans += a[i] + add[secr];
                secr --;
                for (int i = secl; i <= secr; i ++) ans += sum[i] + add[i] * len(i);
                printf("%lld\n", ans);
            }
        }
    }
    return 0;
}

虽然在这个时候线段树的代码比分块短些，但是在有多个修改操作查询操作，（比如区间乘上 $k$）时，分块只需要在这上面加 $5$ 行左右就行了。

P5356 [Ynoi2017] 由乃打扑克

毒瘤题，不过掌握分块了还是很好写的，把块内排序然后二分就行了。

但排序了会打乱顺序，所以要一个备用数组。

先来考虑如何朴素的求出第 $k$ 小，我们可以二分，然后遍历块，块内二分比这个阀值大的有多少个，然后判断是否合法。

设块长为 $b$，单次的二分 check 时间复杂度为 $O(m\times ((\frac{n}{b})\log b+b))$，$b$ 是外面零散的，$(\frac{n}{b})\log b$ 是二分大块的。

当 $b$ 取 $\sqrt{n}$ 时时间复杂度为$\sqrt{n}\times \log \sqrt{n}$，因为 $\log \sqrt{n}=\frac{1}{2}\log n$，所以没啥区别，时间复杂度 $\sqrt{n}\times \log n$。

 

当 $b$ 取 $\sqrt{n\log n}$ 时比较优秀，$n=100000$ 时单次 $1500$ 左右。（实际上，这玩意儿我不知道怎么算出来的）

$b$ 取 $\sqrt{n}$ 时，运行次数为 $2626$，所以取 $\sqrt{n\log n}$ 优秀。

二分还要乘上 $\log n$ 次。

 

再来看修改，显然：大块打标记，小块暴力搞。

时间复杂度为 $O(\frac{n}{b}+b\log b)$。（这时修改现用的改完直接 sort，备用的改完别 sort 就行了）

总复杂度 $O(n\times {\log }^{2}n\times \sqrt{n})$，省略了一大堆过程。

其他算法几乎过不掉，不过分块的常数小，过了（

$2.$ 值域分块