cdq 分治学习笔记

CDQ 分治是一种很玄学的东西。

---

Part 0 引子

相信大家都会归并排序，又都知道归并排序求逆序对怎么求的

如果连归并求逆序对都不会那你为什么要学 cdq 分治阿喂

void merge_sort(int l, int r) {
	if(l >= r) return ;
	int mid = (l + r) >> 1;
	merge_sort(l, mid);
	merge_sort(mid + 1, r);
	int L = l, R = mid + 1, k = 0;
	while(L <= mid && R <= r)
		if(a[L] <= a[R]) tmp[k++] = a[L++];
		else tmp[k++] = a[R++], ans += mid - L + 1;
	while(L <= mid) tmp[k++] = a[L++];
	while(R <= r) tmp[k++] = a[R++];
	for(int p = l, i = 0; p <= r; p++, i++)
		a[p] = tmp[i];
}

tnnd，为什么不用树状数组！为什么不用！

事实上这也是 CDQ 分治，让我们来思考思考它是如何工作的：

• 排序的区间先处理 \([l, mid]\)。
• 处理 \([mid + 1, r]\)。
• 统计。

我们来重点思考一下，这个统计是怎么做的——

• 这个统计的大前提，是我们的 \(a_l\sim a_{mid}\) 和 \(a_{mid} + 1, a_r\) 都已经有序，没有这个大前提，就没有后面的合并。
• 尝试合并这两个有序的序列。
• 在合并过程中，我们都知道逆序对定义如 \(a_i < a_j (j > i)\)。我们如果发现在合并的时候有个 \(a_L > a_R\)，这说明 \(a_L\sim a_{mid}\) 必然都大于 \(a_R\)，故逆序对数量加上 \(mid - L + 1\)。
• 总结一下，本质上就是看统计两个区间对答案能造成多少贡献。

总结到这里，我们就可以得到一个大致的 CDQ 分治的流程了——

• 先处理 \([l, mid]\)。
• 再处理 \([mid + 1, r]\)。
• 统计两个区间对答案造成的贡献。
  
  还不理解？下面我们通过几道例题来更深入的理解 CDQ 分治。

---

Part 1 CDQ 分治维护静态问题与偏序问题

CDQ 分治可以维护静态问题，尤其是偏序问题。

我们上面提到的逆序对实际上就是一维偏序。

二维偏序与一维偏序类似，就是变成了二维，如果 \(a_i \le a_j, b_i \le b_j\) 则称之为一个偏序。

我们可以以 \(a_i\) 为第一关键字，\(b_i\) 为第二关键字降序排序，这样的话就消除了 \(a_i\) 的影响，现在只要考虑 \(b_i\) 的影响了。我们按照排序过的 \(a_i\) 的顺序挨个把 \(b_i\) 加入树状数组，那么目前就能统计出 \(\operatorname{query}(b_i)\) 个偏序。

有了二维偏序的基础，我们再来看看三维偏序 link。

联系上面二维偏序的方法，我们容易想到，我们先以 \(a_i\) 为第一关键字排个序，排序完了再进行 CDQ 分治。下面就变成了一个只剩下两维的偏序问题，做法其实和上文的差不多。

先处理 \([l, mid]\)，再处理 \([mid + 1, r]\)。然后是 CDQ 分治的重头戏：统计影响。

• 我们还是为了消维度影响，我们考虑对 \([l, mid]\) 和 \([mid + 1, r]\) 这两个区间分别再以 \(b_i\) 为第一关键字降序排序，这样也消除了 \(b\) 的影响。
• 下面建立两个指针，\(p\) 指向 \([mid + 1, r]\)，\(pos\) 指向 \([l, mid]\)。
• 不断枚举 \(p\) 的位置，同时控制 \(pos\) 的位置。不断尝试右移 \(pos\)。当 \(b_p \le b_{pos}\) 且 \(pos\) 不越过区间（即小于等于 \(mid\) ）时可以消除 \(a\) 与 \(b\) 的影响。因为 \(pos\) 始终小于等于 \(p\)，故 \(a_{pos}\) 始终小于等于 \(a_p\)。既然 \(a_{pos} \ge a_p, b_{pos} \ge a_p\)，我们只要康康 \(c_{pos}\) 的影响即可。
• 建立一个树状数组维护前缀和，我们在 \(c_{pos}\) 位置添加这个三元组出现的次数。
• 结束了这个流程，最后对答案造成的贡献是树状数组内 \(c_p\) 的前缀和（因为大于 \(c_p\) 的 \(c\) 是不能用滴。）

#include <iostream>
#include <algorithm>
#define MAXN 100000
#define QWQ cout << "qwq" << endl;
using namespace std;
struct node {
	int a, b, c, cnt, ans;
} I[MAXN + 10], A[MAXN + 10];
int S = 0, n, k;
int ANS[MAXN + 10];
//-----
int tr[MAXN * 4 + 10];
int lowbit(int x) {return (x & (-x));}
void updata(int x, int y) {
	while(x <= k) {
		tr[x] += y;
		x += lowbit(x);
	}
}
int ask(int x) {
	int sum = 0;
	while(x) {
		sum += tr[x];
		x -= lowbit(x);
	}
	return sum;
}
//-----
bool cmp1(node &x, node &y) {
	if(x.a == y.a) if(x.b != y.b) return x.b < y.b; else return x.c < y.c;
	else return x.a < y.a;
}
bool cmp2(node &x, node &y) {
	if(x.b == y.b) return x.c < y.c;
	else return x.b < y.b;
}
void stO_cdq_Orz(int l, int r) {//即上文所讲的 cdq 分治
	if(l == r) return ;
	int mid = (l + r) >> 1;
	stO_cdq_Orz(l, mid);
	stO_cdq_Orz(mid + 1, r);
	sort(A + l, A + mid + 1, cmp2);
	sort(A + mid + 1, A + r + 1, cmp2);
	int pos = l;
	for(int p = mid + 1; p <= r; p++) {//统计影响的代码
		while(A[p].b >= A[pos].b && pos <= mid) {
			updata(A[pos].c, A[pos].cnt);
			pos++;
		}
		A[p].ans += ask(A[p].c);
	}
	for(int p = l; p < pos; p++)//记得清空树状数组 \ovo/
		updata(A[p].c, -A[p].cnt);
}
int main() {
	cin >> n >> k;
	for(int p = 1; p <= n; p++)
		cin >> I[p].a >> I[p].b >> I[p].c;
	sort(I + 1, I + n + 1, cmp1);
	int qwq = 0;
	for(int p = 1; p <= n; p++) {//事实上这个过程实在去重
		qwq++;
		if(I[p].a != I[p + 1].a || I[p].b != I[p + 1].b || I[p].c != I[p + 1].c)
			A[++S].a = I[p].a, A[S].b = I[p].b, A[S].c = I[p].c, A[S].cnt = qwq, qwq = 0;
	}
	stO_cdq_Orz(1, S);//cdq 太强啦！
	for(int p = 1; p <= S; p++)
		ANS[A[p].ans + A[p].cnt - 1] += A[p].cnt;
  //解释一下为什么要这样统计答案，是个很小得细节。
  //A[p].ans 代表的是带这个三元组的偏序数量，加上 A[p].cnt 是因为 (a,b,c) 与 (a,b,c) 也是偏序，减一是因为这里面包含了 p 号三元组与 p 号三元组本身的偏序，重复了
  //为什么在加上 A[p].cnt 时不减一？因为本来就是缺了 A[p].cnt 个偏序，这里就大家都没有差别了
  //如果大家还不懂的话可以自己琢磨琢磨，很简单的
	for(int p = 0; p < n; p++) cout << ANS[p] << endl;
}

Part 2 CDQ 分治维护动态问题

这里会谈 CDQ 分治是如何维护动态问题的。

Part 2.1 维护树状数组

tnnd，为什么不用树状数组！为什么不用！

CDQ 分治也可以用来维护树状数组基本题 link。

我们都会树状数组，我们都知道树状数组其实是在维护前缀和，也就是说我们可以把这个问题分解成三个操作：

1. 单点修改。
2. 将答案加上 \([1, r]\) 的和。
3. 将答案减去 \([1, l - 1]\) 的和。

我们就很轻松的可以整出来这几个元素：

• \(opt_i\)， 代表操作的编号。
• \(val_i\)，仅对于 \(opt_i = 1\) 的情况，是要修改的值。
• \(pos_i\)，仅对于 \(opt_i = 2\) 或 \(3\)，即修改位置。

还是老规矩，cdq 分治。有如下几个步骤：

• 处理 \([l, mid]\)。
• 处理 \([mid + 1, t]\)。
• 统计。我们要统计答案，也就是说我们要统计左边对右边产生的影响，既然是影响，那么左半边我们要统计一波修改（即 \(opt_i = 1\)），右半边统计的是查询（\(opt_i = 2\) 或 \(3\)）。
• 对于左半边的修改，我们可以直接用一个变量统计这些修改所改动的值 \(res\)，对于右半边的查询，我们可以直接对其进行增减。

不过，cdq 分治有个大前提，那就是 \([l,mid]\) 和 \([mid + 1, r]\) 是有序的。如果无序，那么又何谈影响？

下面我们就要来讨论讨论关于顺序的问题了。根据我们上面的叙述，事实上对于 \(opt_i = 1\) 来说，它的操作必然会对 \([mid + 1, r]\) 里面的查询造成影响，也就是说这个位置肯定要在右半边查询的位置之内（不然的话不就查不到了吗）。

所以，操作的位置是我们排序的第一关键字，同时对于操作位置相同的操作，以操作的编号为第二关键字（显然修改要放在查询前面做），降序排序，保证 \([l, mid]\) 的修改位置一定不超过 \([mid + 1, r]\) 的查询位置。

不过我们可以直接在 cdq 分治内部用归并做这个排序。

#include <iostream>
#define MAXN 500000
#define QWQ cout << "QWQ" << endl;
using namespace std;
struct node {
	int opt, pos, val, id;
	bool operator < (const node &other) const {
		if(pos != other.pos) return pos < other.pos;
		else return opt < other.opt;
	}
} a[MAXN * 2 + 10], tmp[MAXN * 2 + 10];
int ans[MAXN + 10];
void sto_cdq_orz(int l, int r) {
	if(l >= r) return ;
	int mid = (l + r) >> 1;
	sto_cdq_orz(l, mid);
	sto_cdq_orz(mid + 1, r);
	int p = mid + 1, pos = l, rest = 0, c = l - 1;
	while(pos <= mid && p <= r) {
		if(a[pos] < a[p]) {
			if(a[pos].opt == 1) rest += a[pos].val;
			tmp[++c] = a[pos++];
		}
		else {
			if(a[p].opt == 2) ans[a[p].id] += rest;
			else if(a[p].opt == 3) ans[a[p].id] -= rest;
			tmp[++c] = a[p++];//一个归并的过程
		}
	}
	while(pos <= mid) tmp[++c] = a[pos++];//因为这时候右半边都处理完了，没有查询了，所以不需要判断操作
	while(p <= r) {//右半边还没有完全处理完毕
		if(a[p].opt == 2) ans[a[p].id] += rest;
		else if(a[p].opt == 3) ans[a[p].id] -= rest;
		tmp[++c] = a[p++];
	}
	for(p = l; p <= r; p++) a[p] = tmp[p];
}
int main() {
	int n, m, qwq = 0, qaq = 0;
	cin >> n >> m;
	for(int p = 1, x; p <= n; p++) {
		cin >> x;
		a[++qwq].opt = 1, a[qwq].pos = p;
		a[qwq].val = x, a[qwq].id = 0;
	}
	for(int p = 1; p <= m; p++) {
		int opt, x, y;
		cin >> opt >> x >> y;
		if(opt == 1) {
			a[++qwq].opt = 1, a[qwq].pos = x;
			a[qwq].val = y, a[qwq].id = 0;
		}
		else {
			a[++qwq].opt = 2, a[qwq].pos = y, a[qwq].val = -114514, a[qwq].id = ++qaq;//id 是第几个查询，为了输出方便的
			a[++qwq].opt = 3, a[qwq].pos = x - 1, a[qwq].val = -11, a[qwq].id = qaq;
		}
	}
	sto_cdq_orz(1, qwq);
	for(int p = 1; p <= qaq; p++)
		cout << ans[p] << endl;
}

再来看一道题天使玩偶，很经典的 cdq 分治。

概括题意为：

\(n + m\) 个操作，操作有添加一个点和查询目前点集里与其曼哈顿距离最小的点。

姑且不看添加操作，先看查询操作。

曼哈顿距离是有绝对值的式子，\(|x - x'| + |y - y'|\)，但是这个式子很难搞，我们要化简一下，以 \(x' \le x, y' \le y\) 为例，我们要求的距离就转化成了 \(\min\{x - x' + y - y'\}\)。

提取已知条件转化式子是基操。\(x, y\) 已知，弄出来得到 \(x + y - \max\{x' + y'\}\)。

问题转化成，如何维护 \(\max\{x', y'\}\) 同时保证 \(x' \le x, y' \le y\)。

等等，\(x' \le x, y'\le y\)？这不是二维偏序的式子吗！

那么方案就呼之欲出啦！把初始坐标和查询坐标按照横坐标降序排序，用一个树状数组维护。树状数组维护 \(y'\) 位置的 \(x' + y'\) 最大值。查询时，答案就是 \(\min\{x - y - \operatorname{query}(y)\}\)。因为排序满足 \(x'\le x\)，树状数组满足 \(y'\le y\)。

下面，我们要考虑带修改的操作了！

其实这里的统计和上面树状数组的统计一个套路。左半边有修改，左半边进行修改。右半边有查询，右半边进行查询。

最后我们要处理答案了。首先我们上面处理的是左下角的坐标，而不是全局的坐标。你可以多推几个式子，但是事实上反转一下整个坐标系就可以了。

代码：

#include <iostream>
#include <cstring>
#include <algorithm>
#define MAXN 1000000
#define QWQ cout << "QWQ" << endl;
using namespace std;
int f = 0;
int INF;
struct node {
    int opt, x, y, id;
} a[MAXN + 10];
//qaq
int tr[MAXN + 10];
int lowbit(int x) {
    return x & (-x);
}
int n;
void change(int x, int y) {
    for(int p = y; p <= 1000000; p += lowbit(p))
        tr[p] = max(tr[p], x + y);
}
int query(int x) {
    int res = 0;
    while(x) {
        res = max(res, tr[x]);
        x -= lowbit(x);
    }
    return res;
}
void clear(int pos) {
    for(; pos <= 1000000; pos += lowbit(pos))
        tr[pos] = 0;
}
//qwq
node tmp[MAXN + 10];
int ans[MAXN + 10];
void sto_cdq_orz(int l, int r) {
    if(l >= r) return ;
    int mid = (l + r) >> 1;
    sto_cdq_orz(l, mid);
    sto_cdq_orz(mid + 1, r);
    int pos = l, p = mid + 1, c = l - 1;
    while(pos <= mid && p <= r) {
        if(a[pos].x <= a[p].x) {//修改
            if(a[pos].opt == 1) change(a[pos].x, a[pos].y);
            tmp[++c] = a[pos], pos++;
        }
        else {
            if(a[p].opt == 2) {//统计
                int qaq = query(a[p].y);
                if(qaq) ans[a[p].id] = min(ans[a[p].id], a[p].x + a[p].y - qaq);
            }
            tmp[++c] = a[p], p++;
        }
    }
    while(pos <= mid) tmp[++c] = a[pos], pos++;
    while(p <= r) {
        if(a[p].opt == 2) {//统计
            int qaq = query(a[p].y);
            if(qaq) ans[a[p].id] = min(ans[a[p].id], a[p].x + a[p].y - qaq);
        }
        tmp[++c] = a[p], p++;
    }
    for(int p = l; p <= r; p++) a[p] = tmp[p];
    for(int p = l; p <= r; p++)
        if(a[p].opt == 1) clear(a[p].y);
    return ;
}
//
node qwq[MAXN + 10];
void init() {
    int m;
    cin >> n >> m;
    for(int p = 1, x, y; p <= n; p++) {
        cin >> x >> y;
        x++, y++;//为什么要加一？因为如果出现 0 的坐标，在树状数组里就会死循环
        a[p].opt = 1, a[p].x = x, a[p].y = y;
    }
    for(int p = 1, opt, x, y; p <= m; p++) {
        cin >> a[++n].opt >> a[n].x >> a[n].y;
        a[n].x++, a[n].y++;
        if(a[n].opt == 2) f++, a[n].id = f;
    }
    for(int p = 1; p <= n; p++)
        qwq[p] = a[p];
}
void work() {
    memset(ans, 0x7f, sizeof(ans));
    memset(ans, 0x3f, sizeof(ans));
    sto_cdq_orz(1, n);
    for(int p = 1; p <= n; p++) a[p] = qwq[p], a[p].x = 1000001 - a[p].x;//反转
    sto_cdq_orz(1, n);
    for(int p = 1; p <= n; p++) a[p] = qwq[p], a[p].y = 1000001 - a[p].y;
    sto_cdq_orz(1, n);
    for(int p = 1; p <= n; p++) a[p] = qwq[p], a[p].x = 1000001 - a[p].x, a[p].y = 1000001 - a[p].y;
    sto_cdq_orz(1, n);
}
int main() {
    init();
    work();
    for(int p = 1; p <= f; p++)
        cout << ans[p] << endl;
}

为什么这道题我们采用 cdq 分治？因为这样的话就避免了各种高级数据结构，好写，好调。不然的话可能要用树套树之类的东西维护前驱后继，这样就麻烦许多，调试起来很繁琐。

Part 3 总结

cdq 分治真是好呢！