cdq分治简述与小试-CSDN博客

本文链接：https://blog.csdn.net/Morning_Glory_JR/article/details/131415680

简述

cdq分治是一种思想：将问题从中间分成两个部分，并且满足只有一部分（设为左）对另一部分（设为右）有贡献，右部分对左部分是没有贡献的，然后计算左部分对右部分的贡献，再继续分治。
最简单的运用应该就是归并排序求逆序对吧，将序列分成两半，然后考虑左边序列的数对右边序列的数构成了多少逆序对。

正确性

拿求逆序对举例，在分治的过程中，左边序列中的逆序对已经在左边求完了，右边序列中的逆序对也求完了，只剩下还有左边序列中的数与右边序列中的数构成的逆序对还没求，因此只需处理左边与右边的数构成的逆序对数量。

运用

二维偏序

二维平面上有若干个不同的点，求有多少个点对 $(a, b)$ 满足 $x_a\le x_b, y_a \le y_b$
要求会求逆序对
首先考虑将点按第一维排好序，然后将问题分为左右两个区间，考虑左区间对右区间的贡献
因为以按照第一维排序过了，因此左区间的点的第一维都小于或者等于右区间的点，也就是说在考虑左区间对右区间的贡献时，我们不需要考虑第一维了
此时我们直接对左区间和右区间分别按照第二维排序，不难发现，在不需要考虑第一维的前提下，问题已经变成了单纯的求左区间对右区间第二维的顺序对数量
而这个排序当然可以直接在内部重新排序两次，也可借助归并排序的思想来求

void cdq (int l, int r)//在调用函数前按第一维排序
{
	if (l >= r)	return;
	int md = (l + r) / 2;
	cdq(l, md), cdq(md + 1, r);//这俩一般没有顺序要求，如果借助归并排序的思想那么就必须优先执行
	sort(a + l, a + md + 1, 第二维排序);
	sort(a + md + 1, a + r + 1, 第二维排序);//这两个sort可以省略，借助归并排序求逆序对的方法在求顺序对过程中排序
	求左区间对右区间的第二维顺序对数。
}

三维偏序

不是在二维平面上而是在三维空间中的偏序问题
要求会用树状数组求逆序对

首先按照二维偏序的思路来，在最开始按照第一维排序，然后在分治过程中排序第二维，这一部分和二维偏序没有区别
但是在求顺序对数时不是直接用两个指针求顺序对数，在使用两个指针的前提下，还需借助树状数组

设 $i$ 为左区间指针， $j$ 为右区间指针
我们可以知道，左区间和右区间是按照第二维升序排列的，并且右区间的第一维都大于等于左区间
还是双指针往后走，对于当前 $j$ ，找到第二维最大的并且仍然小于 $j$ 的 $i$ ，此时我们知道，已经考虑过左区间中所有的第一维和第二维都小于等于 $j$ 的点了，也就是左区间中的前 $i$ 个点，只需在这些点中求第三维也小于 $j$ 的点的数量，利用树状数组，对每个 $i$ 的第三维按照树状数组求顺序对的方法做好标记，那么 $j$ 就只需要直接查询即可
洛谷模板题

#include <cstdio>
#include <algorithm>
#define lowbit(x) ((x) & (-x))
using namespace std;
const int maxn = 200005;
int n, m;
int id[maxn], a[maxn], b[maxn], c[maxn], cp[maxn], tmp[maxn], ans[maxn], cup[maxn];
bool cmp (int x, int y) { return a[x] ^ a[y]? a[x] < a[y] : b[x] ^ b[y]? b[x] < b[y] : c[x] < c[y]; }
void add(int x, int val)
{
    while (x <= m)  cp[x] += val, x += lowbit(x);
}
int query (int r)
{
    int res = 0;
    while (r)   res += cp[r], r -= lowbit(r);
    return res;
}
void cdq (int l, int r)//计算左边对右边的贡献，并将[l, r]按照第二维排序
{
    if (l >= r) return;
    int md = (l + r) / 2;
    cdq(l, md), cdq(md + 1, r);
    int i = l, j = md + 1, k = l - 1;
    while (i <= md && j <= r) {
        while (i <= md && b[id[i]] <= b[id[j]])  tmp[++k] = id[i++], add(c[tmp[k]], 1);
        //处于右边的第一维本就大于等于左边，又找到所有的第二维小于等于j的id，此时已经找到所有第一维和第二维都小于等于j的id
        //而这些id的第三维全都存在树状数组里
        tmp[++k] = id[j++];
        ans[tmp[k]] += query(c[tmp[k]]);
        /*
            为何要用ans而不是直接cup[query(c[id[j]])]++？
            因为如果有三维全部相等的两个点对刚好在中间附近，那么右边的点计算了左边的点的贡献，而左边的点没有计算到右边的点的贡献
            因此能够保证全部计算到位的只有最右边的那个点
            而三维相等的点的答案也是相同的，只需最后再从右往左扫一遍同步一下答案
        */
    }
    while (j <= r)  tmp[++k] = id[j++], ans[tmp[k]] += query(c[tmp[k]]);
    for (j = l; j <= i - 1; ++j)    add(c[id[j]], -1);//清空树状数组
    while (i <= md) tmp[++k] = id[i++];
    for (i = l; i <= r; ++i)    id[i] = tmp[i];
}
int main ()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; ++i)    scanf("%d%d%d", &a[i], &b[i], &c[i]), id[i] = i;
    sort(id + 1, id + n + 1, cmp);
    cdq(1, n);
    for (int i = n; i >= 1; --i) {
        if (a[id[i]] == a[id[i + 1]] && b[id[i]] == b[id[i + 1]] && c[id[i]] == c[id[i + 1]])   ans[id[i]] = ans[id[i + 1]];
        //cdq部分有解释
        ++cup[ans[id[i]]];
    }
    for (int i = 0; i < n; ++i) printf("%d\n", cup[i]);
    return 0;
}

练习

Cow Hopscotch
分治的过程中 $d p$
~~这题自己想歪了，一开始将所有格子拆下来，然后将标号当第三维当作二维偏序写，虽然不知道哪里错了，但是只能过一个点~~
首先这题是不是简单的先算左区间再算右区间再算中间的顺序，考虑到这样的顺序会使得右区间计算中的方案数缺少左区间到右区间的左区间再到右区间的右区间的方案，因此考虑先算左区间，再算左区间对右区间的贡献，再算右区间的顺序
这样的话就不能用归并排序的思想边排序边做了，但是！我们不需要把所有点拆下来啊，我们直接对这个二维平面分治，中间砍一刀分成左右两边，然后考虑左边对右边的贡献的计算方法，这样就简单了，本来就是排序好的，从第一行开始，经过的左区间的点都能到之后的右区间的点，因此先计算贡献，再更新方案数，不知道为啥题解里很多人都是横着砍分成上下，我感觉不是很习惯这样思考，而且代码上也没有了空间邻近性，更多的看代码吧。

#include <cstdio>
#include <algorithm>
#define lowbit(x) (x & -x)
using namespace std;
const int maxn = 755;
const int maxl = 750 * 750 + 5;
const int mod = 1000000007;
int n, m, mx, time;
int t[maxl], s[maxl];
int id[maxn][maxn], f[maxn][maxn];
void cdq (int l, int r)//l, r指的是列， 更加贴近正常思维
{
	if (l >= r)	return;
    int md = (l + r) >> 1;//顺便作为更新桶的标志
    cdq(l, md);
    int all = 0;
    for (int i = 1; i <= n; ++i) {
        for (int j = md + 1; j <= r; ++j) {
            if (t[id[i][j]] != md) {
                t[id[i][j]] = md;
                s[id[i][j]] = 0;
            }
            f[i][j] = (f[i][j] + (all - s[id[i][j]] + mod) % mod) % mod;
        }
        for (int j = l; j <= md; ++j) {
            if (t[id[i][j]] != md) {
                t[id[i][j]] = md;
                s[id[i][j]] = 0;
            }
            s[id[i][j]] = (s[id[i][j]] + f[i][j]) % mod;
            all = (all + f[i][j]) % mod;
        }
    }
    cdq(md + 1, r);
}
int main ()
{
    scanf("%d%d%d", &n, &m, &mx);
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= m; ++j) scanf("%d", &id[i][j]);
    f[1][1] = 1;
    cdq(1, m);
    printf("%d\n", f[n][m]);
    return 0;
}

P4093 [HEOI2016/TJOI2016] 序列
考虑 $d p$ ， $f [i]$ 表示以 $i$ 作为末尾最长不降子序列长度是多少，转移方程 $f[i]=max\{f[j]\}+1$ ，其中 $j < i, m x [j] <= a [i], a [j] <= mn [i]$ ，转移过程要满足三维偏序，用 $c d q$ 分治来优化这个过程即可

#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 1e5 + 10;
const int lim = 1e5;
int n, m, root, tot;
int mx[maxn], mn[maxn], a[maxn], id[maxn], f[maxn];
int ls[maxn << 2], rs[maxn << 2], val[maxn << 2];
void modify (int &k, int l, int r, int p, int v)
{
    if (!k) k = ++tot, ls[k] = rs[k] = val[k] = 0;
    if (l == r) return val[k] = max(val[k], v), void();
    int md = (l + r) >> 1;
    if (p <= md)    modify(ls[k], l, md, p, v);
    else    modify(rs[k], md + 1, r, p, v);
    val[k] = max(val[ls[k]], val[rs[k]]);
}
int query (int &k, int l, int r, int p)//max{1~p}
{
    if (!k) return 0;
    if (p >= r) return val[k];
    int md = (l + r) >> 1;
    int res = query(ls[k], l, md, p);
    if (p > md) res = max(res, query(rs[k], md + 1, r, p));
    return res;
}
bool cmp1 (int x, int y) { return mx[x] < mx[y]; }
bool cmp2 (int x, int y) { return a[x] < a[y]; }
void cdq (int l, int r)
{
    if (l == r) return ;
    int md = (l + r) >> 1;
    cdq(l, md);
    sort(id + l, id + md + 1, cmp1);
    sort(id + md + 1, id + r + 1, cmp2);
    root = tot = 0;
    int lt = l, rt = md + 1;
    while (rt <= r) {
        if (lt <= md && mx[id[lt]] <= a[id[rt]]) {
            modify(root, 1, lim, a[id[lt]], f[id[lt]]);
            ++lt;
        }
        else {
            f[id[rt]] = max(f[id[rt]], query(root, 1, lim, mn[id[rt]]) + 1);
            ++rt;
        }
    }
    for (int i = md + 1; i <= r; ++i)	id[i] = i;
    cdq(md + 1, r);
}
int main ()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; ++i)    scanf("%d", &a[i]), mn[i] = mx[i] = a[i], f[i] = 1, id[i] = i;
    for (int i = 1, x, y; i <= m; ++i) {
        scanf("%d%d", &x, &y);
        mx[x] = max(mx[x], y);
        mn[x] = min(mn[x], y);
    }
    cdq(1, n);
    int ans = 0;
    for (int i = 1; i <= n; ++i)    ans = max(ans, f[i]);
    printf("%d\n", ans);
    return 0;
}