分治技巧在高级数据结构中的应用——cdq分治（一）&&bzoj3262例题详解

分治技巧在高级数据结构中的应用——cdq分治（一）

 

从一道简单题说起：

 

3262: 陌上花开

Time Limit: 20 Sec   Memory Limit: 256 MB
Submit: 2596   Solved: 1160
[ Submit][ Status][ Discuss]

Description

有n朵花，每朵花有三个属性：花形(s)、颜色(c)、气味(m)，又三个整数表示。现要对每朵花评级，一朵花的级别是它拥有的美丽能超过的花的数量。定义一朵花A比另一朵花B要美丽，当且仅当Sa>=Sb,Ca>=Cb,Ma>=Mb。显然，两朵花可能有同样的属性。需要统计出评出每个等级的花的数量。

Input

第一行为N,K (1 <= N <= 100,000, 1 <= K <= 200,000 ), 分别表示花的数量和最大属性值。

以下N行，每行三个整数si, ci, mi (1 <= si, ci, mi <= K)，表示第i朵花的属性

Output

包含N行，分别表示评级为0...N-1的每级花的数量。

Sample Input

10 3
3 3 3
2 3 3
2 3 1
3 1 1
3 1 2
1 3 1
1 1 2
1 2 2
1 3 2
1 2 1

Sample Output

3
1
3
0
1
0
1
0
0
1

HINT

1 <= N <= 100,000, 1 <= K <= 200,000

Source

树套树 CDQ分治

三维偏序——一道经典的高级数据结构模板题

先从暴力的角度分析

原始暴力n^3

三维KD-Tree？

反正总之试了一下之后TLE了

排序+二维KD-Tree？

好像很有道理，加个重构树优化勉强卡过了

再从正经的高级数据结构分析：

三维~就算了吧

排序+二维线段树或树状数组。

应该都是比较优秀的算法。

我们发现，以上几种算法，无疑都是通过不同维度的序的处理来进行复杂度的优化，把三维问题不断通过数据结构降维度。而如果用分治算法的角度，也有一种针对于序处理的分治算法，可以很好地代替高级数据结构降低复杂度，而且比起树套树，在代码上有很大的优势，它就是cdq分治

Cdq分治——序的处理

什么是cdq分治？我们考察一道高级数据结构题目，无非是让我们做两件事情：修改和查询。而我们需要的是查询的结果。每个查询只会被“之前”的修改影响。“之前”其实就是潜在的时间顺序。那么cdq就利用二分的思想，对时间顺序进行二分。

神奇的贡献

对于一个区间L~R，我们首先进行分治，分治为L，R两个子区间。我们发现，那么L，R区间内的修改对L，R区间查询的贡献显然是两个独立的子问题。我们递归，那么剩下的就是L区间内的修改对R内的查询产生的贡献。

梳理一下步骤

第一步：分将问题区间[L,R]分为[L, mid]，[mid + 1, R]

第二步：递归解决[L,mid][mid+1,R]的子问题

第三步：通过某种数据结构处理[L,mid]的修改

第四步：计算[L,mid]的修改对[mid + 1, R]的贡献。

这个时候，我们发现，第四步中的修改和查询之间的顺序已经没有了——我们需要处理的，一定是先修改，后查询。先修改后查询意味着什么？这不再是一个动态的问题了！这已经是一个静态的问题。我们将时间“同化”！了这就是cdq分治的核心所在。我们将一道动态的题目转化为静态，那么显然可以找到不少更多的优秀算法。

伪代码可以看看

cdq(int L, int R) {
	if(L == R) {get_ans(L); return;} // 如果当前只有一个，直接处理即可 
	int mid = L + R >> 1; //分治 
	cdq(L, mid); cdq(mid + 1, R); //递归子区间 
	update(L, mid); //添加 L~mid的修改
	get_ans(mid + 1, R); //计算贡献
	restore(); //还原修改 
}

是不是不可思议地简单！

About题目

我们看看这道题。

第一维看成时间即可。

Cdq分治，问题转化为计算一个子区间满足对另一个子区间内的二维偏序。

我们先看成一维偏序。那么要解决的就是一个子区间对另一个子区间的顺序对的数的个数。因此会想到归并。可以归并吗？cdq分治后，两个子区间本身a的顺序被同化，对我们计算的答案贡献无影响，因此可以归并。那么对于二维，就多写一个树状数组即可。

看到同化时间的力量了吧！

下面是代码

 

#include<iostream>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
using namespace std;
const int N = 880000;
using namespace std;
int read() {
	char ch = getchar(); int x = 0, f = 1;
	while(ch < '0' || ch > '9') {if(ch == '-') f = -1; ch = getchar();}
	while(ch >= '0' && ch <= '9') {x = (x << 1) + (x << 3)  - '0' + ch; ch = getchar();}
	return x * f;
}

void write(int x) {
	if(x / 10) write(x / 10);
	putchar(x % 10 + '0'); 
} 

struct data {
	int a, b, c, ans, cnt;
	bool operator < (const data &d) const {
		return a == d.a ? (b == d.b ? c < d.c : b < d.b) : a < d.a;
	} 
	bool operator == (const data &d) const {return a == d.a && b == d.b && c == d.c;} 
	void init() {a = read(); b = read(); c = read(); ans = 0; cnt = 0;}
}a[N], tmp[N];
int f[N], t[N], n, m;
void update(int x, int add) {for(int i = x;i <= m; t[i] += add, i += -i&i) ;}
int query(int x) {int ret = 0; for(int i = x; i; ret += t[i], i -= -i&i) ; return ret;}

void cdq(int L, int R) {
	if(L == R) {a[L].ans += a[L].cnt - 1; return;}
	int mid = L + R >> 1;
	cdq(L, mid); cdq(mid + 1, R);
	int l = L, r = mid + 1, top = 0; 
	while(l <= mid && r <= R) {
		if(a[l].b <= a[r].b) {update(a[l].c, a[l].cnt); tmp[top++] = a[l++];}
		else {
			a[r].ans += query(a[r].c);
			tmp[top++] = a[r++];
		}
	}
	while(r <= R) a[r].ans += query(a[r].c), tmp[top++] = a[r++];
	for(int i = L; i < l; ++i) update(a[i].c, -a[i].cnt);
	while(l <= mid) tmp[top++] = a[l++];
	for(int i = 0;i < top; ++i) a[i + L] = tmp[i];
}

int main() {
	n = read(); m = read(); int tot = 0;
	for(int i = 1;i <= n; ++i) a[i].init();
	sort(a + 1, a + n + 1);
	for(int i = 1;i <= n; ++i) 
	if(i != 1 && a[i] == a[i - 1]) ++a[tot].cnt; 
	else a[++tot] = a[i], a[tot].cnt = 1;
	cdq(1, tot);
	for(int i = 1;i <= tot; ++i) f[a[i].ans] += a[i].cnt;
	for(int i = 0;i < n; ++i) write(f[i]), putchar('\n');
	return 0;
}

是不是和归并超级像！

关于时间复杂度
考虑每次处理。如果处理是O(f(区间长度))的，那么递归的每一层都是O(f(n))的，至多递归logn次，因此复杂度是O(f(n)logn)

对于静态问题，不难设计出O(n)或O(nlogn)的算法

最后的总结

比较厉害的文章：戳我戳我戳我

Cdq分治是一个比较皮的家伙，一般在树套树中很常用，用来优化常数、空间和。。代码复杂度，使用条件是要有序和动态查询。好用好用新技能get。