【总结】CDQ分治
总的来说，CDQ分治与普通分治不一样的地方在于，CDQ分治的对象是时间。即对于一个时间段[L, R]，我们取mid = (L + R) / 2，（用数据结构题举例）分治的每层只考虑mid之前的修改对mid之后的查询的贡献，然后递归到[L,mid]，(mid,R]。
显然，CDQ分治是一种离线算法，我们需要将所有的修改/查询存下来，一起进行操作。
同时，CDQ分治还需要满足：操作之间相互独立，即一个操作的存在不会影响到另一个操作的存在。
那么这是一个经典入门题：【BZOJ1176: [Balkan2007]Mokia】
二维单点修改，矩形查询。
首先修改/查询之间的顺序就是时间，我们按时间来分治。
但是由于是二维的，为了省空间不开二维的数据结构，我们一开始把所有操作按x轴排序，每次处理我们只需要扫描一下x轴，把y轴的修改/查询放到一个一维树状数组里就好了。
（另外，矩形查询拆为4个前缀和查询）
具体步骤如下：
（1）把操作离线下来（离线的时候要记录每个操作的时间，即操作的编号），然后按x轴排序。（必要时离散化）
（2）分治区间[L, R]（L, R为时间，即操作的编号），取mid，从L到R遍历操作，将mid之前的修改加入一维树状数组，将mid之后的查询在一维树状数组里查询。
（3）注意要还原修改操作，从L到R遍历操作，遇到修改操作，将修改操作改回去。（如果是+c，那么-c）
（4）开一个临时数组，两个指针（一个指针指向左区间的左端点，另一个指针指向右区间的左端点），从L到R遍历操作，将mid之前的操作放到左区间，将mid之后的操作放到右区间。最后把临时数组赋值给操作数组。
（5）递归[L, mid]，[mid + 1, R]，回到（2）。
递归的终点是L==R。
注意，在分治的每一层的区间内，x轴都是有序的。虽然时间无序，但是我们遍历操作时按照mid来划分了。（这个大概是CDQ分治比较难懂的地方）
看代码吧。
/* Pigonometry */
#include
#include
using namespace std;
const int maxn = 2000005, maxm = 640005, maxq = 10005;
int n, tr[maxn], ans[maxq];
struct _data {
int opt, id, qid, x, y, c;
} c[maxm], tmp[maxm];
inline int iread() {
int f = 1, x = 0; char ch = getchar();
for(; ch < '0' || ch > '9'; ch = getchar()) f = ch == '-' ? -1 : 1;
for(; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return f * x;
}
inline void add(int x, int c) {
for(; x <= n; x += x & -x) tr[x] += c;
}
inline int sum(int x) {
int res = 0;
for(; x; x -= x & -x) res += tr[x];
return res;
}
inline int cmp(_data a, _data b) {
return a.x != b.x ? a.x < b.x : a.y != b.y ? a.y < b.y : a.opt < b.opt;
}
inline void cdq(int l, int r) {
if(l == r) return;
int mid = l + r >> 1;
for(int i = l; i <= r; i++)
if(c[i].opt == 1 && c[i].id <= mid) add(c[i].y, c[i].c);
else if(c[i].opt == 2 && c[i].id > mid) ans[c[i].qid] += c[i].c * sum(c[i].y);
for(int i = l; i <= r; i++)
if(c[i].opt == 1 && c[i].id <= mid) add(c[i].y, -c[i].c);
int h1 = l, h2 = mid;
for(int i = l; i <= r; i++)
if(c[i].id <= mid) tmp[h1++] = c[i];
else tmp[++h2] = c[i];
for(int i = l; i <= r; i++) c[i] = tmp[i];
cdq(l, mid); cdq(mid + 1, r);
}
int main() {
int s = iread(); n = iread(); int tot = 0, id = 0;
while(1) {
int opt = iread();
if(opt == 3) break;
if(opt == 1) {
int x = iread(), y = iread(), w = iread();
c[++tot] = (_data){1, tot, 0, x, y, w};
} else {
int x1 = iread(), y1 = iread(), x2 = iread(), y2 = iread(); id++;
c[++tot] = (_data){2, tot, id, x2, y2, 1};
c[++tot] = (_data){2, tot, id, x1 - 1, y2, -1};
c[++tot] = (_data){2, tot, id, x2, y1 - 1, -1};
c[++tot] = (_data){2, tot, id, x1 - 1, y1 - 1, 1};
}
}
sort(c + 1, c + 1 + tot, cmp);
cdq(1, tot);
for(int i = 1; i <= id; i++) printf("%d\n", ans[i]);
return 0;
} 另外CDQ分治还可以处理偏序问题。
比如【BZOJ3262: 陌上花开】
有n个物品，每个物品有三个属性a, b, c。对于物品X，需要查询有多少物品Y满足Xa >= Ya, Xb >= Yb, Xc >= Yc。物品Y的个数即为X的等级。
我们发现，这个问题里并没有时间，但是我们可以转化一下，比如将属性a当做时间（时间本来也是一种序）。
所以思路是，先按a排序，将a编号，把a当做时间。然后按b排序（如果不理解，多多理解上个题），那么我们遍历操作的时候，只需要在一维树状数组里面查询有多少比c小的物品就行了。
下面是代码（很久之前的）
#include
#include
#define rec(i, x, n) for(int i = x; i <= n; i++)
const int maxn = 100005, maxk = 200005;
int n, k, tot, tr[maxk], ans[maxn];
struct _flower
{
int a, b, c, cnt, ans;
bool operator != (const _flower &x) const
{
return a != x.a || b != x.b || c != x.c;
}
} f[maxn], c[maxn];
inline int iread()
{
int f = 1, x = 0; char ch = getchar();
for(; ch < '0' || ch > '9'; ch = getchar()) f = ch == '-' ? -1 : 1;
for(; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return f * x;
}
bool cmp1(_flower x, _flower y)
{
return x.a != y.a ? x.a < y.a : x.b != y.b ? x.b < y.b : x.c < y.c;
}
bool cmp2(_flower x, _flower y)
{
return x.b != y.b ? x.b < y.b : x.a < y.a;
}
void add(int x, int w)
{
for(; x <= k; x += x & -x) tr[x] += w;
}
int sum(int x)
{
int res = 0;
for(; x; x -= x & -x) res += tr[x];
return res;
}
void cdq(int l, int r)
{
if(l == r)
{
f[l].ans += f[l].cnt - 1;
return;
}
int mid = l + r >> 1, q1 = l, q2 = mid;
rec(i, l, r) f[i].a <= mid ? c[q1++] = f[i] : c[++q2] = f[i];
rec(i, l, r) f[i] = c[i];
for(int i = mid + 1, j = l; i <= r; i++)
{
for(; j <= mid && f[j].b <= f[i].b; j++)
add(f[j].c, f[j].cnt);
f[i].ans += sum(f[i].c);
}
for(int i = l; i <= mid && f[i].b <= f[r].b; i++) add(f[i].c, -f[i].cnt);
cdq(l, mid); cdq(mid + 1, r);
}
int main()
{
n = iread(); k = iread();
rec(i, 1, n) f[i].a = iread(), f[i].b = iread(), f[i].c = iread();
std::sort(f + 1, f + 1 + n, cmp1);
rec(i, 1, n)
{
if(f[i] != f[i - 1]) f[++tot] = f[i];
++f[tot].cnt;
}
rec(i, 1, tot) f[i].a = i;
std::sort(f + 1, f + 1 + tot, cmp2);
cdq(1, tot);
rec(i, 1, tot) ans[f[i].ans] += f[i].cnt;
rec(i, 0, n - 1) printf("%d\n", ans[i]);
return 0;
} 另外还有四维偏序
【BZOJ1790: [Ahoi2008]Rectangle 矩形藏宝地】
现在有了四个属性a, b, c, d，对于物品X，问是否有物品Y满足Xa >= Ya, Xb >= Yb, Xc <= Yc, Xd <= Yd。
我们沿用上题的思路，还是将一维当做时间。但注意，我们这里选择将c作为时间轴，原因在下面。
将c排序，编号，当做时间。然后将d排序。
对于a，b的处理，我们发现我们只需要知道“存在性”即可，那么对于物品X，我们就需要在[1, Xa]里查找是否有物品Y满足Xb >= Yb，这是个RMQ问题，我们用线段树维护。
即把a当做线段树的下标，把b当做线段树的权值，线段树维护区间最小值。
代码（还是很久之前的）
#include
#include
#include
#define rec(i, x, n) for(int i = x; i <= n; i++)
const int maxn = 200005, inf = 0x3f3f3f3f;
int n, tot, rank[maxn], tr[maxn << 2];
struct _mat {
int a, b, c, d, ans; // a up, b up, c down, d down
} c[maxn], tmp[maxn];
inline int iread() {
int f = 1, x = 0; char ch = getchar();
for(; ch < '0' || ch > '9'; ch = getchar()) f = ch == '-' ? -1 : 1;
for(; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return f * x;
}
void pushup(int p) {
tr[p] = std::min(tr[p << 1], tr[p << 1 | 1]);
}
bool cmp1(_mat x, _mat y) {return x.c > y.c;}
bool cmp2(_mat x, _mat y) {return x.d > y.d;}
void change(int p, int l, int r, int x, int w) {
if(l == r && r == x) {
tr[p] = w;
return;
}
int mid = l + r >> 1;
if(x <= mid) change(p << 1, l, mid, x, w);
else change(p << 1 | 1, mid + 1, r, x, w);
pushup(p);
}
int query(int p, int l, int r, int x, int y) {
if(x > y) return inf;
if(x <= l && r <= y) return tr[p];
int mid = l + r >> 1;
int res = inf;
if(x <= mid)
res = std::min(res, query(p << 1, l, mid, x, y));
if(y > mid)
res = std::min(res, query(p << 1 | 1, mid + 1, r, x, y));
return res;
}
void cdq(int l, int r) {
if(l == r) return;
int mid = l + r >> 1, q1 = l, q2 = mid;
rec(i, l, r) tmp[c[i].c <= mid ? q1++ : ++q2] = c[i];
rec(i, l, r) c[i] = tmp[i];
for(int i = mid + 1, j = l; i <= r; i++) {
for(; j <= mid && c[j].d > c[i].d; j++) change(1, 1, tot, c[j].a, c[j].b);
if(c[i].b > query(1, 1, tot, 1, c[i].a - 1)) c[i].ans = 1;
}
for(int i = l; i <= mid && c[i].d > c[r].d; i++) change(1, 1, tot, c[i].a, inf);
cdq(l, mid); cdq(mid + 1, r);
}
int main() {
n = iread();
rec(i, 1, n) {
int x1 = iread(), y1 = iread(), x2 = iread(), y2 = iread();
c[i] = (_mat){rank[i] = x1, y1, x2, y2};
}
std::sort(rank + 1, rank + 1 + n);
tot = std::unique(rank + 1, rank + 1 + n) - rank - 1;
std::sort(c + 1, c + 1 + n, cmp1);
rec(i, 1, n) c[i].c = i, c[i].a = std::lower_bound(rank + 1, rank + 1 + tot, c[i].a) - rank;
std::sort(c + 1, c + 1 + n, cmp2);
memset(tr, 0x3f, sizeof(tr));
cdq(1, n);
int ans = 0;
rec(i, 1, n) ans += c[i].ans;
printf("%d\n", ans);
return 0;
} 如果我们把a当做时间，把b排序，那么我们就得在[Xc, inf)里寻找是否有物品Y满足Xd <= Yd。这个太复杂了，inf有可能非常大，即使离散化了，常数也会比较大。
还有一个题，和Mokia一样，而且数据范围更小，当做CDQ分治的练习吧。
【BZOJ2683: 简单题】