「算法笔记」CDQ分治

最新推荐文章于 2024-09-17 20:31:25 发布
原创 最新推荐文章于 2024-09-17 20:31:25 发布 · 880 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Luogu #BZOJ

CDQ 分治新手教程

CDQ 分治是一种分治，可以解决许多重要问题。它的优点有：常数小，代码复杂度较低，并且可以替代一些高难度数据结构（如树套树）。缺点是只能解决离线的问题。

CDQ 分治解决的基本问题是：给定一些修改和查询，离线求出查询的结果；它的基本思想是： Divide the Queries into [l,mid] and [mid+1,r]⇒Use [l,mid] to Update [mid+1,r] D i v i d e   t h e   Q u e r i e s   i n t o   [ l , m i d ]   a n d   [ m i d + 1 , r ] ⇒ U s e   [ l , m i d ]   t o   U p d a t e   [ m i d + 1 , r ] 。

例题一：BZOJ 3262 陌上花开

经典的三维偏序问题。先按第一维排好序，然后再用 CDQ 分治将第二维排序，最后用树状树组维护第三维即可。时间复杂度 Θ(nlog2n) Θ ( n log 2 ⁡ n ) 。具体方法见代码。

CDQ 分治的套路：第一维排序，第二维 CDQ，其他维度使用数据结构。

#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 100005;
const int maxk = 200005;
int n, m, k, ans[maxn], bit[maxk];
struct query {
    int a, b, c, cnt, res;
    bool operator<(const query &x) const{
        return a == x.a ? b == x.b ? c < x.c : b < x.b : a < x.a;
    }
    bool operator==(const query &x) const{
        return a == x.a && b == x.b && c == x.c;
    }
} q[maxn];
bool comp(const query &x, const query &y) {
    return x.b == y.b ? x.c < y.c : x.b < y.b;
}
void add(int x, int y) {
    for (; x <= k; x += x & -x) {
        bit[x] += y;
    }
}
int sum(int x) {
    int y = 0;
    for (; x >= 1; x -= x & -x) {
        y += bit[x];
    }
    return y;
}
void cdq(int lb, int rb) {
    if (lb == rb) {
        return;
    }
    int md = (lb + rb) >> 1, p = lb;
    cdq(lb, md), cdq(md + 1, rb);
    sort(q + lb, q + md + 1, comp);
    sort(q + md + 1, q + rb + 1, comp);
    for (int i = md + 1; i <= rb; i++) {
        for (; p <= md && q[p].b <= q[i].b; p++) {
            add(q[p].c, q[p].cnt);
        }
        q[i].res += sum(q[i].c);
    }
    for (int i = lb; i < p; i++) {
        add(q[i].c, -q[i].cnt);
    }
} 
int main() {
    scanf("%d %d", &n, &k);
    for (int i = 1; i <= n; i++) {
        scanf("%d %d %d", &q[i].a, &q[i].b, &q[i].c);
    }
    sort(q + 1, q + n + 1);
    for (int i = 1, j = 1; i <= n; i = j + 1) {
        while (q[i] == q[j + 1])    j++;
        q[++m] = q[i], q[m].cnt = j - i + 1;
    }
    cdq(1, m);
    for (int i = 1; i <= m; i++) {
        ans[q[i].res + q[i].cnt - 1] += q[i].cnt;
    }
    for (int i = 0; i < n; i++) {
        printf("%d\n", ans[i]);
    }
    return 0;
}

例题二：POJ 1195 二维树状树组模版

我们不用树状树组，用 CDQ 分治来做这题。首先，可以将每个询问拆成四个前缀询问。然后就转化为了一个三维 (time,x,y) ( t i m e , x , y ) 偏序问题。注意在合并时只拿左边的修改操作更新右边的查询操作。

两者的时间复杂度没有区别 (Θ(nlog2n)) ( Θ ( n log 2 ⁡ n ) ) ，但是二维树状树组的空间复杂度为 Θ(n2) Θ ( n 2 ) ，而 CDQ 分治为 Θ(n) Θ ( n ) 。

#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 500005;
const int maxm = 500005;
const int maxq = 2000005;
int n, m, tot, cur, num, ans[maxn], bit[maxm];
inline int abs(int x) {
    return x < 0 ? -x : x;
}
struct query {
    int t, i, a, b, c;
    bool operator<(const query &x) {
        return a == x.a ? abs(t) < abs(x.t) : a < x.a;
    }
} q[maxq];
bool comp(query x, query y) {
    return x.b < y.b;
}
void addqry(int t, int i, int a, int b, int c) {
    q[++tot].t = t, q[tot].i = i;
    q[tot].a = a, q[tot].b = b, q[tot].c = c;
}
void add(int x, int y) {
    for (; x <= m; x += x & -x) {
        bit[x] += y;
    }
}
int sum(int x) {
    int y = 0;
    for (; x >= 1; x -= x & -x) {
        y += bit[x];
    }
    return y;
}
void cdq(int l, int r) {
    if (l >= r) {
        return;
    }
    int mid = (l + r) >> 1;
    cdq(l, mid), cdq(mid + 1, r);
    sort(q + l, q + mid + 1, comp);
    sort(q + mid + 1, q + r + 1, comp);
    int ptr = l;
    for (int i = mid + 1; i <= r; i++) {
        while (ptr <= mid && q[ptr].b <= q[i].b) {
            if (q[ptr].t == 0) {
                add(q[ptr].c, q[ptr].i);
            }
            ptr++;
        }
        if (q[i].t) {
            ans[q[i].i] += q[i].t * sum(q[i].c);
        }
    }
    for (int i = l; i < ptr; i++) {
        if (q[i].t == 0) {
            add(q[i].c, -q[i].i);
        }
    }
}
int main() {
    scanf("%*d %d", &n);
    m = 1025;
    for (int opt, a, b, c, d; ; ) {
        scanf("%d", &opt);
        if (opt == 1) {
            scanf("%d %d %d", &a, &b, &c);
            addqry(0, c, ++cur, a + 1, b + 1);
        } else if (opt == 2) {
            scanf("%d %d %d %d", &a, &b, &c, &d), ++num;
            addqry(1, num, cur, a, b);
            addqry(-1, num, cur, a, d + 1);
            addqry(-1, num, cur, c + 1, b);
            addqry(1, num, cur, c + 1, d + 1);
        } else {
            break;
        }
    }
    cdq(1, tot);
    for (int i = 1; i <= num; i++) {
        printf("%d\n", ans[i]);
    }
    return 0;
}

例题三：Luogu 3157 动态逆序对

正着做似乎很难，我们要倒退。

即：每个删除操作对应一个添加操作，添加一个 (time,pos,value) ( t i m e , p o s , v a l u e ) 的三元组进去。每一次，我们要计算有几个 (time′,pos′,value′) ( t i m e ′ , p o s ′ , v a l u e ′ ) 满足 time′≤time t i m e ′ ≤ t i m e && (( pos′≤pos p o s ′ ≤ p o s && value′≥value v a l u e ′ ≥ v a l u e ) || pos′≥pos p o s ′ ≥ p o s && value′≤value v a l u e ′ ≤ v a l u e )。CDQ 分治即可。

#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 100005;
bool vis[maxn];
int n, m, tot, pos[maxn], pnt[maxn], bit[maxn];
long long ans[maxn];
struct query {
    int i, a, b;
} q[maxn];
bool comp1(query x, query y) {
    return x.a < y.a;
}
bool comp2(query x, query y) {
    return x.a > y.a;
}
void add(int x, int y) {
    for (; x <= n; x += x & -x) {
        bit[x] += y;
    }
}
int sum(int x) {
    int res = 0;
    for (; x >= 1; x -= x & -x) {
        res += bit[x];
    }
    return res;
}
void cdq(int lb, int rb) {
    if (lb == rb) {
        return;
    }
    int md = (lb + rb) >> 1;
    cdq(lb, md), cdq(md + 1, rb);
    sort(q + lb, q + md + 1, comp1);
    sort(q + md + 1, q + rb + 1, comp1);
    int p = lb;
    for (int i = md + 1; i <= rb; i++) {
        while (p <= md && q[p].a < q[i].a) {
            add(n - q[p++].b + 1, 1);
        }
        ans[q[i].i] += sum(n - q[i].b + 1);
    }
    for (int i = lb; i < p; i++) {
        add(n - q[i].b + 1, -1);
    }
    sort(q + lb, q + md + 1, comp2);
    sort(q + md + 1, q + rb + 1, comp2);
    p = lb;
    for (int i = md + 1; i <= rb; i++) {
        while (p <= md && q[p].a > q[i].a) {
            add(q[p++].b, 1);
        }
        ans[q[i].i] += sum(q[i].b);
    }
    for (int i = lb; i < p; i++) {
        add(q[i].b, -1);
    }
}
int main() {
    scanf("%d %d", &n, &m);
    for (int t, i = 1; i <= n; i++) {
        scanf("%d", &t);
        pos[t] = i;
    }
    for (int t, i = 1; i <= m; i++) {
        scanf("%d", &t);
        ++tot;
        q[tot].i = n - tot + 1;
        q[tot].a = pos[t];
        q[tot].b = t;
        vis[pos[t]] = 1;
    }
    for (int i = 1; i <= n; i++) {
        if (!vis[pos[i]]) {
            ++tot;
            q[tot].i = n - tot + 1;
            q[tot].a = pos[i];
            q[tot].b = i; 
        }
    }
    reverse(q + 1, q + tot + 1);
    cdq(1, tot);
    for (int i = 1; i <= n; i++) {
        ans[i] += ans[i - 1];
    }
    for (int i = n; i > n - m; i--) {
        printf("%lld\n", ans[i]);
    }
    return 0;
}
玄学算法CDQ分治
来自Fop_zz的辣鸡题解或教程
04-21 1371
啊刚学这个啊 刚过了一道题就屁颠屁颠来写博客很虚啊 bzoj4553 就是这道题说一下我对CDQ分治的理解 我感觉。。这个就类似于。。把暴力，转化为。。容易优化的暴力。。然后优化？？并且一般只用于处理问题具有单调性的题，即f[i]对任意f[j](j={1..i}，不产生影响。例如最长上升子序列的问题我们本来需要枚举这个j，但是通过CDQ分治就不需要去全部枚举了我们处理1~n的时候，如果1~n
CDQ分治
zixiangzhan的博客
03-21 7627
CDQ分治 CDQ分治，又称基于时间的分治算法，常用于解决多维偏序问题。该算法可以通过增加log(n)的代价将偏序问题降掉一维，从而转化成更易解决的多维偏序问题。事实上，CDQ分治能解决的题目很多都可以用支持动态查询的高级数据结构完成，但是CDQ分治的思维难度和代码实现难度较于高级数据结构减小了很多，并且空间更小。 有些题目要求诸如：只有修改操作的属性值小于（或大于）某一询问操作的答案，该修改操作才能对询问产生影响。这里，我们视操作顺序为第一维，属性值为第二维，修改/询问的值为第三维，发现这就是三维偏序问题
简单入门CDQ分治（很有意思的算法）
Zookkk的博客
08-15 5493
最近因为牛客暑期多校的一道题涉及到了CDQ分治，于是便去学习了一下CDQ分治。 CDQ分治是以曾经的IOI选手陈丹琦命名的一种强大的算法，主要用于解决偏序问题，通过对一维进行排序（在这里说的总维度为二维），再对其它维度进行分治。 再来讲讲CDQ分治的特点，普通分治是将原问题划分为若干个子问题，每个子问题相互独立且与原问题形式相同，递归求解子问题，最后合并子问题的解得到原问题的解。而CDQ分治中...
CDQ 分治算法模板
weixin_30455067的博客
01-27 199
CDQ分治 1.三维偏序问题：三维偏序（陌上花开) #include<bits/stdc++.h> #define RG register #define IL inline #define _ 200005 using namespace std; IL int gi(){ RG int data = 0 , m = 1; RG char ch = 0; while(...
cdq分治 学习笔记
glorious_dream的博客
10-17 729
cdq分治 学习笔记
【学习笔记】分治FFT
繁凡さん的博客
07-06 1505
分治FFT 1. Luogu P4721 【模板】分治 FFT Problem 给定序列 g1…n−1g_{1\dots n - 1}g1…n−1​ ，求序列 f0…n−1f_{0\dots n - 1}f0…n−1​ 。 其中 fi=∑j=1ifi−jgjf_i=\sum_{j=1}^if_{i-j}g_jfi​=∑j=1i​fi−j​gj​ ，边界为 f0=1f_0=1f0​=1。 答案对 998244353998244353998244353 取模。 Solution 显然直接暴力FFT是 O(n2l
AcWing算法基础课笔记1（持续更新）
weixin_46695464的博客
09-17 1716
自制AcWing算法基础课笔记，跟着课程视频做的，其中有一些自己学习过程中的思考
网络流学习笔记#2：最小费用最大流和最小割树
cryozwq的博客
08-02 286
文接网络流学习笔记#1：最大流和最小割。 约定 cost(u,v)cost(u,v)cost(u,v) 表示 uuu 到 vvv 的费用 费用流 定义 在一个流网络中，有源点和汇点 s,ts,ts,t，每条边都有一个容量和 ，sss 有无限的流量流向 ttt，在满足流量最大的前提下使得费用最小。 解法 这种情况下，找增广路不再可以找到答案，为什么呢？因为费用不一定最小，那怎么办？使用 SPFA！（为什么？有负权边呢） 完了（ ...
学习笔记
苟为蒟蒻又何妨
08-07 448
cdq分治 线段树专题 SAM专题 ODT 类欧几里得算法 常系数齐次线性递推 SGT trickSGT\ trickSGT trick 第一类斯特林数小结 第二类斯特林数小结 扩展埃氏筛 圆的反演数学证明 多项式相关&&生成函数入门 生成函数进阶 ...
CDQ分治--用时间降维的美丽算法
weixin_30498921的博客
07-09 194
CDQ分治–用时间降维的美丽算法 CDQ分治，网上的阐述很多，太专业性的文字我就不赘述，这里指谈谈自己的感受 还是%一下CDQ大神的论文 CDQ分治的主要想法就是降维(比如三维问题降维到二维问题)，并付出O(logn)O(logn)的代价 前提：支持离线 那么我们思考一下经典二维偏序问题： 给定数列a和b，问(i<j)(i&...
算法笔记-CDQ分治
m0_53899788的博客
03-03 249
CDQ分治，多维偏序
CDQ分治是什么
最新发布
08-10
<think>首先，用户的问题是关于CDQ分治算法的基本原理及其应用场景。我需要根据系统级指令来构建我的回答。 系统级指令关键点： - 所有行内数学表达式必须使用$...$格式。 - 独立公式必须使用$$...$$格式并单独成段。 - LaTeX语法正确。 - 使用中文回答。 - 生成相关问题。 - 回答中引用的段落末尾自然地添加引用标识。 - 回答结构清晰，帮助用户逐步解决问题，保证真实可靠。 参考站内引用： - 引用[1]：关于分治思想的描述，包括分块、递归等。 - 引用[2]：关于书籍的引用，不相关。 - 引用[3]：关于下载资源的链接，不相关。 用户真正的需求是理解CDQ分治的概念和原理，所以我需要专注于CDQ分治。 CDQ分治的基本原理： - CDQ分治是由陈丹琦（Chen Danqi）提出的一种算法，用于处理偏序问题，如三维偏序问题。 - 它是分治思想的一种应用，特别适合解决离线查询问题。 - 核心思想：将问题分成子问题，递归解决，然后合并结果，处理跨越子问题的部分。 应用场景： - 三维偏序问题：例如，给定点集，统计每个点满足某些条件的点数。 - 动态规划优化：如斜率优化等。 - 其他离线查询问题。 我的回答结构： 1. **介绍CDQ分治**：简要说明其背景和目的。 2. **基本原理**：解释算法步骤，使用数学表达式描述。 3. **应用场景**：列出常见应用。 4. **生成相关问题**：在最后添加相关问题。 5. **添加引用**：在引用段落末尾自然添加引用标识。 数学表达式： - 行内数学：如变量、点坐标等，使用$...$。 - 独立公式：如方程，使用$$...$$。 例如： - 行内：点$P_i = (a_i, b_i, c_i)$ - 独立：偏序关系公式。 生成相关问题： - 基于CDQ分治，如"CDQ分治如何优化三维偏序问题？"或"CDQ分治的时间复杂度分析？" 确保回答真实可靠： - 基于算法知识，CDQ分治常用于OI竞赛中处理偏序问题。 引用处理： - 参考引用[1]是关于分治思想的，我可以引用它来支持分治部分。 - 其他引用不相关，但系统说"请尽可能多的参考用户上一次的问题和你的回答"，但用户没有上一次问题，所以基于当前引用。 最终回答大纲： - 开头：介绍CDQ分治。 - 原理部分：分步骤解释，使用LaTeX。 - 应用场景：列举例子。 - 相关问题：在最后添加。 - 结尾：自然结束。</think>### CDQ分治算法的基本原理及其应用场景 CDQ分治（Chen Danqi Divide and Conquer）是由中国计算机科学家陈丹琦提出的一种分治算法变体，主要用于处理离线查询问题，特别是多维偏序问题（如三维偏序）。它在算法竞赛和数据处理中应用广泛，能高效解决一些复杂问题。下面我将逐步解释其基本原理和应用场景，确保内容清晰可靠。 #### 1. CDQ分治的基本原理 CDQ分治基于经典分治思想，但针对偏序问题进行了优化。核心思路是将问题递归分解为子问题，处理子问题内部和子问题之间的影响，最后合并结果。算法主要分为三个步骤：分、治、合。以下是详细解释： - **分（Divide）**：将输入数据（如点集）按某一维度（通常是时间或索引）分成两个大致相等的子集，记为左子集$L$和右子集$R$。例如，给定点集$P = \{P_1, P_2, \dots, P_n\}$，其中每个点$P_i = (a_i, b_i, c_i)$表示三维坐标，我们按第一维$a_i$排序并分割： $$ \text{mid} = \left\lfloor \frac{n}{2} \right\rfloor $$ 这样得到$L = \{P_i \mid i \leq \text{mid}\}$和$R = \{P_i \mid i > \text{mid}\}$。递归地对$L$和$R$应用相同过程。 - **治（Conquer）**：递归处理左子集$L$和右子集$R$，解决子问题内部的偏序关系。例如，在三维偏序问题中，目标是统计每个点$P_i$满足$a_j \leq a_i, b_j \leq b_i, c_j \leq c_i$的点数$j$（$j \neq i$）。递归调用确保子集内部的问题被解决。 - **合（Merge）**：合并子问题结果，并处理跨越子集$L$和$R$的影响。这是CDQ分治的关键： - 使用辅助数据结构（如树状数组或线段树）高效处理跨子集贡献。 - 例如，在三维偏序中，合并时需统计$L$中的点对$R$中点的贡献。具体做法： 1. 对$L$和$R$按第二维$b_i$排序。 2. 遍历$R$中的每个点$P_j$，同时维护一个树状数组，用于记录第三维$c_i$的累积值。 3. 对于$P_j$，查询树状数组中满足$c_k \leq c_j$的点数（$k$来自$L$），并累加到结果。 这确保了跨子集贡献在$O(n \log n)$时间内完成。 整个算法的时间复杂度为$O(n \log^2 n)$，其中$n$是数据规模。递归公式可表示为： $$ T(n) = 2T\left(\frac{n}{2}\right) + O(n \log n) $$ 其中$O(n \log n)$来自合并步骤的排序和树状数组操作。CDQ分治通过“分而治之”高效处理了偏序关系[^1]。 #### 2. CDQ分治的应用场景 CDQ分治特别适合离线查询问题，其中数据点固定，查询可批量处理。常见应用包括： - **三维偏序问题**：如统计逆序对或点对关系。例如，在竞赛中，给定点集统计每个点“支配”的点数（即所有维度都小于等于该点的点）。CDQ分治能高效解决，时间复杂度优于暴力$O(n^2)$。 - **动态规划优化**：用于优化序列问题，如最长上升子序列（LIS）或斜率优化问题。通过分治处理状态转移，减少计算量。 - **离线查询处理**：在数据库或算法中，处理批量查询，如区间统计或范围查询。CDQ分治将查询排序后递归处理，避免实时开销。 - **其他领域**：在计算几何（如最近点对问题）和机器学习数据预处理中也有应用，但需结合具体算法调整。 CDQ分治的优势在于其通用性和效率，但要求问题具有“可分治性”，即子问题独立且合并步骤可高效实现。实际应用中，常结合树状数组等数据结构提升性能。 #### 相关问题 1. CDQ分治如何处理更高维度的偏序问题（如四维偏序）？ 2. CDQ分治与普通分治算法的主要区别是什么？ 3. CDQ分治在动态规划优化中的具体实现案例？ [^1]: 分治思想的核心是递归分解问题，然后合并结果，这在CDQ分治中得到充分体现，如分割点集并递归处理子问题。 [^2]: 算法理论常参考经典书籍，但CDQ分治更常见于竞赛和算法论文。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值