CDQ分治学习笔记

CDQ分治学习笔记

什么是CDQ分治呢？
CDQ分治，从一维的角度来考虑问题，那么就是归并排序
那么为什么叫CDQ分治不叫归并排序呢？

<1>

1.我们考虑一个题目，给出一个数组，有n个元素，涉及m次操作，其中有单点更新操作与区间查询
有点经验的同学已经想到了使用树状数组/线段树来解决问题，如果不使用这两种数据结构能否解决
问题呢？
我们先来考虑insert 操作 与 query 操作
我们考虑一个问题，没错insert会影响后续的query操作
那么query出来的结果应该是 前面insert对后面造成的影响
我们可以先获取所有的操作
然后通过归并排序，从低往上更新，然后可得对应查询的结果
附上例题

例题1
【思路】:我们可以先考虑怎么处理插入，查询的操作，通过前面的分析我们可以知道插入肯定会影响后序的查询
那么我们要怎么实现区间呢？现将区间分成两个点【l,r】，可以变成对应的前缀和sum[r] - sum[l - 1]
可以处理一个结构题

struct NODE{
    int type, idx;
    ll val;
    ///type代表数据的类型：是查询节点，还是插入节点 查询节点分为两种 一个是r， 一个是l
    ///对应1 3 2
    ///idx代表编号
    ///val是代表插入的更新的值，或者当前是第几个查询
}

然后可以进行CDQ分治，怎么分治呢？
考虑type的种类，更新肯定要在前面，然后考虑idx如果种类相同idx肯定要在前面
然后使用一个sum来保存当前的值
详细看代码理解

void CDQ(int l, int r){
    if(l + 1 < r){
        return ;
    }///当前只有一个元素
    int mid = (l + r) >> 1;
    CDQ(l, mid);
    CDQ(mid, r);
    int p, q;
    p = l, q = r;
    long long sum = 0;
    vector<NODE>vec;
    while(p < mid && q < r)///注意是[)区间
    {
        if(arr[p] < arr[q]){
            sum += arr[p].val;
            vec.push_back(arr[p]);
            p ++;
        }
        else{
            if(arr[q].type == 2) ans[arr[q].val] -= sum;
            else if(arr[q].type == 3) ans[arr[q].val] += sum;
            vec.push_back(arr[q]);
            q ++;
        }
    }
    while(p < mid){
        vec.push_back(arr[p ++]);
    }
    while(q < r){
        if(arr[q].type == 2) ans[arr[q].val] -= sum;
        else if(arr[q].type == 3) ans[arr[q].val] += sum;
        vec.push_back(arr[q]);
        q ++;
    }
    for(int i = 0; i < vec.size(); i ++){
        arr[l + i] = vec[i];
    }
    /**
     * 一层一层向上递归
     * 然后把每次的贡献加上去
     * 这样就能保证答案是对的
     * 因为每次都是左区间作用于右区间
     * 然后因为是1 1向上去递归的
     * 所以所有的影响都会被考虑
     * 时间复杂度是O(nlogn)
     * **/
}

附上代码：

#include <bits/stdc++.h>
using namespace std;
/*
CDQ分治
*/
const int MAXN = 50000 + 5;
int n, m;
typedef long long LL;
struct query {
    int type, idx;
    LL val;
    friend bool operator<(const query& a, const query& b) {
        return a.idx == b.idx ? a.type < b.type : a.idx < b.idx;
    }
} arr[MAXN << 2];
query temp[MAXN << 2];
LL ans[MAXN << 2];
void CDQ(int l, int r){
    if(r - l <= 1){
        return ;
    }
    int mid = (l + r) >> 1;
    CDQ(l, mid);
    CDQ(mid, r);
    int p = l, q = mid, tot = 0;
    LL sum = 0;
    while(p < mid && q < r){
        if(arr[p] < arr[q]){
            if(arr[p].type == 1) sum += arr[p].val;
            temp[tot ++] = arr[p ++];
        }
        else{
            if(arr[q].type == 2) ans[arr[q].val] -= sum;
            else if(arr[q].type == 3) ans[arr[q].val] += sum;
            temp[tot ++] = arr[q ++]; 
        }
    }
    while(p < mid){
        temp[tot ++] = arr[p ++];
    }
    while(q < r){
        if(arr[q].type == 2) ans[arr[q].val] -= sum;
        else if(arr[q].type == 3) ans[arr[q].val] += sum;
        temp[tot ++] = arr[q ++]; 
    }
    for(int i = 0; i < tot; i ++){
        arr[l + i] = temp[i];
    }
}
vector<int>vec;
int main() {
    ios::sync_with_stdio(false);
    int T, cnt = 0;
    cin >> T;
    int cases = 0;
    while(T --){
        memset(ans, 0, sizeof(ans));
        vec.clear();
        int n;
        cin >> n;
        cnt = 0;
        for(int i = 1; i <= n; i ++){
            int num;
            cin >> num;
            arr[cnt].idx = i, arr[cnt].type = 1, arr[cnt ++].val = num;
        }
        int ans_num = 0;
        while(1){
            string str;
            cin >> str;
            if(str == "Query"){
                int l, r;
                cin >> l >> r;
                vec.push_back(ans_num);
                arr[cnt].idx = r, arr[cnt].type = 3, arr[cnt ++].val = ans_num;
                arr[cnt].idx = l - 1, arr[cnt].type = 2, arr[cnt ++].val = ans_num ++;
            }
            else if(str == "Add"){
                int c, value;
                cin >> c >> value;
                arr[cnt].idx = c, arr[cnt].type = 1, arr[cnt ++].val = value;
            }
            else if(str == "Sub"){
                int c, value;
                cin >> c >> value;
                arr[cnt].idx = c, arr[cnt].type = 1, arr[cnt ++].val = -value;
            }
            else{
                break;
            }
        }
        CDQ(0, cnt);
        cout << "Case " << ++cases << ":
";
        for(int i = 0; i < vec.size(); i ++){
            cout << ans[vec[i]] << endl;
        }
    }
    return 0;
}

<2>

2.刚刚考虑的一维的，那我们来考虑使用CDQ分治来解决二维偏序问题
先附上例题

例题2
[思路]：这个题目其实可以使用离线 + 线段树 + 离散化来ac这个问题，但是我们考虑使用CDQ分治来处理问题
我们可以考虑把其变成一个三维的，加上一个维度type代表是插入还是查询，因为插入一个就查询一个，所以
点的个数就*2了，然后先按照

 friend bool operator<(const NODE &a, const NODE &b){
        if(a.x != b.x){
            return a.x < b.x;
        }
        if(a.type != b.type){
            return a.type < b.type;
        }
        return a.y < b.y;
    }

进行排序，这样我们可以保证归并之前，左边的区间[l,mid)的x的值肯定小于[mid,r)的值，
左边的更新可能会对右边的更新有贡献
其实一次查询肯定是有左边对右边的贡献，你可能会问那么[mid, r)这个区间就失去了对本区间的贡献了吗？
其实不是，因为我们肯定是分治递归到底才进行计算的，所以[mid, r)区间的贡献在底已经先计算过了
那么考虑CDQ分治的过程，考虑使用y来排序，若相同着考虑type，肯定是先更新后查询
注意每次使用树状数组来维护y区间的数的个数，当type == 1的时候查询的时候，就可以直接查询query(l, r)
type == 0的时候，可以考虑add(y, 1)
当更新完答案的时候，肯定要把树状数组清空，因为每一次左右区间都会发生变化，所以上一次的树状数组就是无效的
只有[l, mid)才会出现add的操作，所以只要把[l, mid) 使用add(y, -1)
附上代码：

#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
int n, m;
const int MAXN = 3e5 + 5;
struct tree_arr{
    int tree[MAXN];
    inline int lowbit(int x){
        return x & -x;
    }
    inline void add(int k, int val){
        while(k <= n + m){
            tree[k] += val;
            k += lowbit(k);
        }
    }
    inline int sum(int k){
        int sum = 0;
        while(k){
            sum += tree[k];
            k -= lowbit(k);
        }
        return sum;
    }
    inline int query(int l, int r){
        return sum(r) - sum(l - 1);
    }
}t_a;
struct NODE{
    int x, y, type, idx;
    friend bool operator<(const NODE &a, const NODE &b){
        if(a.x != b.x){
            return a.x < b.x;
        }
        if(a.type != b.type){
            return a.type < b.type;
        }
        return a.y < b.y;
    }
}arr[MAXN];
vector<int>vec;
int ans[MAXN];
bool cmp(const NODE &a, const NODE &b){
    if(a.y != b.y)  return a.y < b.y;
    if(a.type != b.type)    return a.type < b.type;
    return a.x < b.x;
}
NODE temp[MAXN];
void CDQ(int l, int r){
    if(l + 1 >= r)   return;
    int mid = (l + r) >> 1;
    CDQ(l, mid);
    CDQ(mid, r);
    int cnt = 0;
    int p, q;
    p = l, q = mid;
    while(p < mid && q < r){
        if(arr[p].y <= arr[q].y){
            if(arr[p].type == 0)  
            t_a.add(lower_bound(vec.begin(), vec.end(), arr[p].y) - vec.begin() + 1, 1);
            temp[cnt ++] = arr[p];
            p ++;
        }
        else{
            if(arr[q].type == 1) 
            ans[arr[q].idx] += t_a.query(1, lower_bound(vec.begin(), vec.end(), arr[q].y) - vec.begin() + 1);
            temp[cnt ++] = arr[q];
            q ++;
        }
    }
    while(p < mid){
        if(arr[p].type == 0) 
        t_a.add(lower_bound(vec.begin(), vec.end(), arr[p].y) - vec.begin() + 1, 1);
        temp[cnt ++] = arr[p];
        p ++;
    }
    while(q < r){
        if(arr[q].type == 1) 
        ans[arr[q].idx] += t_a.query(1, lower_bound(vec.begin(), vec.end(), arr[q].y) - vec.begin() + 1);
        temp[cnt ++] = arr[q];
        q ++;
    }
    for(int i = l; i < mid; i ++){
        if(arr[i].type == 0) 
        t_a.add(lower_bound(vec.begin(), vec.end(), arr[i].y) - vec.begin() + 1, -1);
    }
    for(int i = 0; i < cnt; i ++){
       arr[l + i] = temp[i];
    }
    return ;
}
int main(){
    scanf("%d%d", &n, &m);
    for(int i = 0; i < n; i ++){
        scanf("%d%d", &arr[i].x, &arr[i].y);
        vec.push_back(arr[i].y);
        arr[i].type = 0;
    }
    for(int i = 0; i < m; i ++){
        scanf("%d%d", &arr[n + i].x, &arr[n + i].y);
        arr[n + i].type = 1;
        arr[n + i].idx = i;
        vec.push_back(arr[i].y);
    }
    sort(vec.begin(), vec.end());
    vec.erase(unique(vec.begin(), vec.end()), vec.end());
    sort(arr, arr + (n + m));
    CDQ(0, n + m);
    for(int i = 0; i < m; i ++){
        printf("%d
", ans[i]);
    }
    return 0;
}

<3> CDQ分治处理三维偏序问题

例题3
什么是三维偏序？三维偏序就是一个三维空间询问区间内的点的个数或者是点的
总和价值，时间复杂度是一个O(nlog(n)log(n))
首先我们先考虑一个点<x, y, z>
首先我们先考虑如果分为两个区间，保证左边的x小于右边的x
那么我们只要考虑左边的点对右边的点的贡献，判断y的大小
如果把对应的z所构造成的线段树或者树状数组
进行更新，其他跟上面相似

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 50005;
const int MAXM = 100005;
struct Point{
    int x, y, z, id;
    friend bool operator<(const Point &a, const Point &b){
        if(a.x != b.x)
        return a.x < b.x;
        if(a.y != b.y)
        return a.y < b.y;
        return a.z < b.z;
    }
}arr[MAXN];
int ans[MAXN];
bool cmp(const Point &a, const Point &b){
    if(a.y != b.y)
    return a.y < b.y;
    return a.z < b.z;
}
struct Segtree{
    struct seg_node{
        int l, r, sum;
    }tree[MAXM << 2];
    void build(int root, int l, int r){
        tree[root].l = l, tree[root].r = r;
        if(l == r){
            tree[root].sum = 0;
            return ;
        }
        int mid = (l + r) >> 1;
        build(root << 1, l, mid);
        build(root << 1 | 1, mid + 1, r);
        tree[root].sum = tree[root << 1].sum + tree[root << 1 | 1].sum;
        return ;
    }
    void update(int root, int cnt, int val){
        if(tree[root].l == tree[root].r){
            tree[root].sum += val;
            return ;
        }
        int mid = (tree[root].l + tree[root].r) >> 1;
        if(cnt <= mid){
            update(root << 1, cnt, val);
        }
        else{
            update(root << 1 | 1, cnt, val);
        }
        tree[root].sum = tree[root << 1].sum + tree[root << 1 | 1].sum;
        return ;
    }
    int query(int root, int l, int r){
        if(tree[root].l >= l && tree[root].r <= r){
            return tree[root].sum;
        }
        int mid = (tree[root].l + tree[root].r) >> 1;
        if(r <= mid){
            return query(root << 1, l, r);
        }
        else if(l > mid){
            return query(root << 1 | 1, l, r);
        }
        else{
            return query(root << 1, l, mid) + query(root << 1 | 1, mid + 1, r);
        }
    }
}seg;
void CDQ(int l, int r){///[)
    if(l + 1 >= r){
        return ;
    }
    int mid = (l + r) >> 1;
    int p, q;
    p = l, q = mid;
    CDQ(l, mid);
    CDQ(mid, r);
    sort(arr + l, arr + mid, cmp);
    sort(arr + mid, arr + r, cmp);
    while(p < mid && q < r){
        if(arr[p].y <= arr[q].y){
            seg.update(1, arr[p].z, 1);
            p ++;
        }
        else{
            ans[arr[q].id] += seg.query(1, 1, arr[q].z);
            q ++;
        }
    }
    while(p < mid){
        seg.update(1, arr[p].z, 1);
        p ++;
    }
    while(q < r){
        ans[arr[q].id] += seg.query(1, 1, arr[q].z);
        q ++;
    }
    for(int i = l; i < mid; i ++){
        seg.update(1, arr[i].z, -1);
    }
    return ;
}
int main(){
    ios::sync_with_stdio(false);
    int n;
    cin >> n;
    for(int i = 1; i <= n; i ++){
        cin >> arr[i].x >> arr[i].y >> arr[i].z;
        arr[i].id = i;
    }
    seg.build(1, 1, 100001);
    sort(arr + 1, arr + n + 1);
    CDQ(1, n + 1);
    for(int i = 1; i <= n; i ++){
        cout << ans[i] << endl;
    }
    return 0;
}