【Coel.学习笔记】分块入门

引入

分块是一种暴力数据结构（类似珂朵莉树，但时间复杂度有所保证），尽管不像线段树和树状数组能够在对数时间复杂度完成操作，但能够做到许多线段树、树状数组做不到的操作。

分块

我们从一道简单的区间加、区间求和看一看分块的基本原理。

【模板】线段树

洛谷传送门
已知一个数列，你需要进行下面两种操作：

• 将某区间每一个数加上 $c$
• 求出某区间每一个数的和。

数列长度和操作数 $n,m\leq10^5$。

---

解析：既然叫做“分块”，自然就要把数列分成若干个“块”。记每个块的长度为 $s$。最后一个块可能长度不够 $s$，但是不会影响接下来的操作。显然，这时块的个数是 $O(\dfrac{n}{s})$。

每个块需要维护一些信息。对于这道题，我们需要维护两个信息：一是懒惰标记，记录本段的加法操作；二是区间和，记录本段的加和（包括懒标记记录的操作）。

对于区间修改操作，显然会遇到两种不同的块:中间完整包含的块，和左右两边不完整包含的块。对于完整块而言，直接暴力修改懒惰标记和区间和即可；对于不完整的块而言，枚举被包含的所有数，并对数列本身做修改，区间加上和。时间复杂度为 $O(\dfrac{n}{s}+s)$。

对于查询操作，同样要对两种块分别处理。完整块累加每个块的区间和，不完整的块暴力求和，时间复杂度同样为 $O(\dfrac{n}{s}+s)$。

由高中数学必修一中学到的均值不等式可以知道，当 $\dfrac{n}{s}=s=\sqrt n$ 时，$\dfrac{n}{s}+s$ 有最小值 $2\sqrt n$。因此我们让块的长度为 $\sqrt n$，就可以得到分块的最优时间复杂度 $O(\sqrt n)$。

可以发现，分块的操作十分暴力，但也使得它理解更容易（相对树状数组）、代码长度更短（相对线段树），并且能够解决更多问题（Ynoi 系列一大堆分块题）。缺点也很显然，时间复杂度劣于线段树、树状数组的 $O(\log n)$。

具体实现时，我们要记录下每个数字对应的块，方便进行操作。一种常见的方法是用 $(i-1)\div s$ 表示第 $i$ 个数对应的块。

代码如下（不开 O2 优化也能过，但对于分块来说 O2 优化的效果非常显著）：

#include <cmath>
#include <iostream>

#define int long long
#define get(x) (x - 1) / len

using namespace std;

const int maxn = 1e5 + 10;

int n, m, len;
int add[maxn], sum[maxn], a[maxn];

void modify(int l, int r, int c) {
    if (get(l) == get(r)) //全部在块内，直接算
        for (int i = l; i <= r; i++) a[i] += c, sum[get(i)] += c;
    else {
        int i = l, j = r;
        while (get(i) == get(l)) a[i] += c, sum[get(i)] += c, i++;
        while (get(j) == get(r)) a[j] += c, sum[get(j)] += c, j--;
        for (int k = get(i); k <= get(j); k++) sum[k] += c * len, add[k] += c;
        //分别处理左边、右边和中间的块
    }
}

int query(int l, int r) { //查询和修改是一样的
    int res = 0;
    if (get(l) == get(r))
        for (int i = l; i <= r; i++) res += a[i] + add[get(i)];
    else {
        int i = l, j = r;
        while (get(i) == get(l)) res += a[i] + add[get(i)], i++;
        while (get(j) == get(r)) res += a[j] + add[get(j)], j--;
        for (int k = get(i); k <= get(j); k++) res += sum[k];
    }
    return res;
}

signed main(void) {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cin >> n >> m;
    len = sqrt(n);
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        sum[get(i)] += a[i];
    }
    while (m--) {
        int op, l, r, c;
        cin >> op >> l >> r;
        if (op == 1) {
            cin >> c;
            modify(l, r, c);
        } else
            cout << query(l, r) << '\n';
    }
    return 0;
}

块状链表

块状链表是分块思想的一个具体体现，可以实现插入操作。
这里先介绍原理再讲例题，因为例题实在太复杂了

用一张 OI-Wiki 的图片直观感受一下块状链表：

显然块状链表也是一个链表，每个节点对应一个数组。这样就可以实现高效插入。具体地，我们要把待插入位置两边分裂开，再建立一个序列。

如果要删除呢？分三步走：删除开头节点后半部分，删除中间的完整部分，删除结尾节点的前半部分。

要想维护一个块状链表，对于每一块都要维护几个信息：对应的字符串，存放的字串长度，左右相连的值。

现在看看这道题吧……

[NOI2003] 文本编辑器

建立一个文本编辑器，实现以下操作：

操作名称	输入文件中的格式	功能
$\text{Move}(k)$	Move k	将光标移动到第 $k$ 个字符之后，如果 $k=0$，将光标移到文本开头
$\text{Insert}(n,s)$	Insert n s	在光标处插入长度为 $n$ 的字符串 $s$，光标位置不变$n\geq1$
$\text{Delete}(n)$	Delete n	删除光标后的 $n$ 个字符，光标位置不变，$n \geq 1$
$\text{Get}(n)$	Get n	输出光标后的 $n$ 个字符，光标位置不变，$n \geq 1$
$\text{Prev}()$	Prev	光标前移一个字符
$\text{Next}()$	Next	光标后移一个字符

解析：这题可以用 Splay 或者 FHQ-Treap 解决，但也可以用块状链表实现。

对于移动光标操作，从第一个块开始找 $k$ 个字符就是对应的位置。顺带一提，这时光标要保存两个信息：所在的块和块内的位置。
插入和删除上面已经提到过了，这里不再赘述。
输出操作和插入删除一样要断开，不过不需要实际插入删除东西就是了。
移动光标需要特判光标在块边上的情况，除了这点也没什么可以注意的。
移动、插入、删除和输出的操作复杂度均为 $O(\sqrt n)$，移动光标的操作复杂度为 $O(1)$。为了保证复杂度的正确性，我们还得在每次操作后把散块合并起来直到长度保持到 $O(\sqrt n)$。

和维护数列那题一样，这里也可以用内存回收。
说起来很简单，但细节相当多，调试起来极其麻烦。具体看代码吧——
（其实理解起来还是相当容易的，就是比较费 debug 和手）

#include <cctype>
#include <cstdio>
#include <cstring>
#include <iostream>

using namespace std;

const int maxn = 2e3 + 10, mlen = 2e6 + 10;
/*这里的 maxn 其实是取了根号下最大长度*/

int n;

int x, y;  //光标所在分块和所在分块的具体下标

struct node {
    char s[maxn + 1];
    int cnt, l, r;  //字串长度，链表前驱，链表后继
} p[maxn];

char str[mlen];

int q[maxn], idx;  //内存回收

inline int read() {
    int x = 0, f = 1;
    char ch = getchar();
    while (!isdigit(ch)) {
        if (ch == '-') f = -1;
        ch = getchar();
    }
    while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
    return x * f;
}

inline bool check(char x) { return x >= 32 && x <= 126; }

/*以下为维护链表的操作*/

void add(int x, int u) {  //在 x 结点的后方加上 u 结点
    /*这里其实就是一个前驱后继关系变动的问题，可以自己手模一下*/
    p[u].r = p[x].r, p[p[u].r].l = u;
    p[x].r = u, p[u].l = x;
}

void del(int u) {  //删除 u 结点
    p[p[u].l].r = p[u].r;
    p[p[u].r].l = p[u].l;
    p[u].l = p[u].r = p[u].cnt = 0;
    q[++idx] = u;  //内存回收
}

void merge() {  //合并散块，保证时间复杂度正确
    for (int i = p[0].r; i; i = p[i].r)
        while (p[i].r && p[i].cnt + p[p[i].r].cnt < maxn) {
            int r = p[i].r;
            for (int j = p[i].cnt, k = 0; k < p[r].cnt; j++, k++)
                p[i].s[j] = p[r].s[k];
            if (x == r) x = i, y += p[i].cnt;
            p[i].cnt += p[r].cnt;
            del(r);
        }
}

/*以下为具体操作*/

void move(int k) {
    x = p[0].r;
    while (k > p[x].cnt) k -= p[x].cnt, x = p[x].r;  //一步步移动所在块
    y = k - 1;                                       //块内具体位置
}

void insert(int k) {
    if (y < p[x].cnt - 1) {  //不在块的边界，分裂新结点
        int u = q[idx--];
        for (int i = y + 1; i < p[x].cnt; i++) p[u].s[p[u].cnt++] = p[x].s[i];
        p[x].cnt = y + 1;
        add(x, u);
    }
    int cur = x, pos = 0;
    while (pos < k) {
        int u = q[idx--];
        while (p[u].cnt < maxn && pos < k) p[u].s[p[u].cnt++] = str[pos++];
        /*不断加直到满块或加完*/
        add(cur, u);
        cur = u;
    }
}

void remove(int k) {
    if (p[x].cnt - 1 - y >= k) {  //若删完不到达块的边界，直接把后一部分移动到前面
        for (int i = y + k + 1, j = y + 1; i < p[x].cnt; i++, j++)
            p[x].s[j] = p[x].s[i];
        p[x].cnt -= k;  //下标后退
    } else {
        k -= p[x].cnt - y - 1;
        p[x].cnt = y + 1;
        while (p[x].r && k >= p[p[x].r].cnt) {  //删散块
            int u = p[x].r;
            k -= p[u].cnt;
            del(u);
        }
        int u = p[x].r;
        for (int i = 0, j = k; j < p[u].cnt; i++, j++)  //删整块的小部分
            p[u].s[i] = p[u].s[j];
        p[u].cnt -= k;
    }
}

void get(int k) {
    if (p[x].cnt - 1 - y >= k)  //输出内容全部在块内
        for (int i = 0, j = y + 1; i < k; i++, j++) putchar(p[x].s[j]);
    else {
        k -= p[x].cnt - y - 1;
        for (int i = y + 1; i < p[x].cnt; i++) putchar(p[x].s[i]);
        int cur = x;
        while (p[cur].r && k >= p[p[cur].r].cnt) {  //输出散块
            int u = p[cur].r;
            for (int i = 0; i < p[u].cnt; i++) putchar(p[u].s[i]);
            k -= p[u].cnt;
            cur = u;
        }
        int u = p[cur].r;
        for (int i = 0; i < k; i++) putchar(p[u].s[i]);  //输出整块小部分
    }
}

void prev() {
    if (!y)  //块内下标无了，退到上一个块
        x = p[x].l, y = p[x].cnt - 1;
    else
        y--;
}

void next() {
    if (y >= p[x].cnt - 1)  //块内下标无了，进到下一个块
        x = p[x].r, y = 0;
    else
        y++;
}

int main(void) {
    n = read();
    for (int i = 1; i < maxn; i++) q[++idx] = i;
    str[0] = '>';//添加一个哨兵点
    insert(1);
    move(1);
    while (n--) {
        int a;
        char op[10];
        scanf("%s", op);
        if (!strcmp(op, "Move"))
            move((a = read()) + 1);
        else if (!strcmp(op, "Insert")) {
            a = read();
            int i = 0, k = a;
            while (a) {
                str[i] = getchar();
                if (check(str[i])) i++, a--;
            }
            insert(k);
            merge();
        } else if (!strcmp(op, "Delete")) {
            a = read();
            remove(a);
            merge();
        } else if (!strcmp(op, "Get")) {
            a = read();
            get(a);
            putchar('\n');
        } else if (!strcmp(op, "Prev"))
            prev();
        else
            next();
    }
    return 0;
}