232 lines
7.7 KiB
Markdown
232 lines
7.7 KiB
Markdown
---
|
||
tags:
|
||
- 算法设计与分析
|
||
- 复习
|
||
- 分治法
|
||
create time: 2026-06-10 11:11
|
||
---
|
||
|
||
# 分治法
|
||
|
||
## 概述
|
||
分治法（Divide and Conquer）是算法设计中最基础、最重要的策略之一。其核心思想是"大事化小"：将一个难以直接解决的大问题，分割成若干规模较小的子问题，递归地解决这些子问题，然后将子问题的解合并得到原问题的解。本文将从基本思想出发，讲解分治法的三步骤、适用条件以及多个经典应用。
|
||
|
||
## 正文
|
||
|
||
### 一、分治法基本思想
|
||
|
||
分治法将一个大规模问题分解为 **k 个规模较小的子问题**，这些子问题互相独立且与原问题形式相同。递归地求解这些子问题，然后将子问题的解合并，得到原问题的解。
|
||
|
||
```mermaid
|
||
flowchart TD
|
||
Problem["Original Problem P"]
|
||
Divide["Divide: Split into subproblems"]
|
||
Sub1["Subproblem P1"]
|
||
Sub2["Subpattern P2"]
|
||
Sub3["Subproblem Pk"]
|
||
Conquer["Conquer: Solve each subproblem recursively"]
|
||
Merge["Merge: Combine subproblem solutions"]
|
||
Solution["Solution to P"]
|
||
|
||
Problem --> Divide
|
||
Divide --> Sub1
|
||
Divide --> Sub2
|
||
Divide --> Sub3
|
||
Sub1 --> Conquer
|
||
Sub2 --> Conquer
|
||
Sub3 --> Conquer
|
||
Conquer --> Merge
|
||
Merge --> Solution
|
||
```
|
||
|
||
### 二、分治法三个步骤
|
||
|
||
1. **分解（Divide）**：将原问题分解为若干规模较小的子问题
|
||
2. **求解（Conquer）**：递归地求解各子问题。若子问题规模足够小，则直接求解
|
||
3. **合并（Merge）**：将子问题的解合并为原问题的解
|
||
|
||
### 三、适用条件
|
||
|
||
分治法适用需要同时满足以下条件：
|
||
|
||
- 问题可以**分解**为若干规模较小的子问题
|
||
- 子问题**相互独立**（没有重叠子问题）
|
||
- 子问题的解可以**合并**为原问题的解
|
||
|
||
> [!warning] 分治法与动态规划的关键区别
|
||
> 分治法要求子问题**相互独立、没有重叠**。如果子问题之间有重叠（即同一个子问题被多次计算），则应该使用动态规划。这是两者最本质的区别。
|
||
|
||
> [!question] 分治法和动态规划的本质区别是什么？
|
||
> 核心区别在于子问题是否重叠。分治法的子问题互相独立，每次求解不会重复；动态规划的子问题有重叠，所以需要把子问题的解存储起来避免重复计算。例如归并排序的子问题不重叠（左半和右半不交叉），适合分治；而Fibonacci的子问题严重重叠，适合动态规划。
|
||
|
||
### 四、经典应用
|
||
|
||
#### 4.1 归并排序（Merge Sort）
|
||
|
||
归并排序是分治法最经典的应用之一，时间复杂度 **O(n logn)**。
|
||
|
||
```cpp
|
||
#include <vector>
|
||
using namespace std;
|
||
|
||
// merge函数省略，此处仅展示归并排序的分治骨架
|
||
// void merge(vector<int>& A, int left, int mid, int right) { ... }
|
||
|
||
void mergeSort(vector<int>& A, int left, int right) {
|
||
if (left < right) {
|
||
int mid = (left + right) / 2;
|
||
mergeSort(A, left, mid); // 分解：排序左半部分
|
||
mergeSort(A, mid + 1, right); // 分解：排序右半部分
|
||
// merge(A, left, mid, right); // 合并：合并两个有序子数组
|
||
}
|
||
}
|
||
```
|
||
|
||
- **分解**：将数组从中间分为两半
|
||
- **求解**：递归排序左右两半
|
||
- **合并**：将两个有序子数组合并为一个有序数组
|
||
|
||
#### 4.2 快速排序（Quick Sort）
|
||
|
||
- 平均时间复杂度 **O(n logn)**，最坏情况 **O(n²)**
|
||
- 最坏情况发生在每次 pivot 选择都不理想（如已排序数组选第一个元素为 pivot）
|
||
|
||
> [!question] 快速排序最坏情况下时间复杂度为什么是O(n²)?
|
||
> 当每次选择的 pivot 都是最大或最小元素时，划分极度不平衡，一边有 n-1 个元素，另一边为 0 个。递归方程变为 T(n) = T(n-1) + O(n)，解为 O(n²)。
|
||
|
||
#### 4.3 同时求最大值和最小值
|
||
|
||
**朴素方法**：分别查找最大值和最小值，需要 2(n-1) 次比较。
|
||
|
||
**分治改进**：将数组两两分组，每组内先比较，再分别维护最大值和最小值。
|
||
|
||
- 每组2个元素：组内比较1次，再与当前最大、最小各比较1次
|
||
- 比较次数从 **2(n-1)** 降至约 **3n/2**
|
||
|
||
```cpp
|
||
#include <vector>
|
||
#include <utility>
|
||
using namespace std;
|
||
|
||
// 同时求最大值和最小值，比较次数约 3n/2
|
||
pair<int, int> findMaxMin(vector<int>& A, int n) {
|
||
int maxVal, minVal;
|
||
int start;
|
||
|
||
// 初始化：根据元素个数的奇偶性决定初始值
|
||
if (n % 2 == 1) {
|
||
maxVal = minVal = A[0];
|
||
start = 1;
|
||
} else {
|
||
if (A[0] < A[1]) {
|
||
minVal = A[0]; maxVal = A[1];
|
||
} else {
|
||
minVal = A[1]; maxVal = A[0];
|
||
}
|
||
start = 2;
|
||
}
|
||
|
||
// 两两比较：每组内比较1次，再分别与全局最大最小比较
|
||
for (int i = start; i < n; i += 2) {
|
||
int smaller, larger;
|
||
if (A[i] < A[i + 1]) {
|
||
smaller = A[i]; larger = A[i + 1];
|
||
} else {
|
||
smaller = A[i + 1]; larger = A[i];
|
||
}
|
||
if (smaller < minVal) minVal = smaller;
|
||
if (larger > maxVal) maxVal = larger;
|
||
}
|
||
return {maxVal, minVal};
|
||
}
|
||
```
|
||
|
||
**解释**：每次循环处理两个元素，组内比较1次确定大小，再分别与全局最大最小比较最多2次，所以每组最多3次比较。总比较次数约为 3(n-1)/2。
|
||
|
||
#### 4.4 找第二大/第二小的数
|
||
|
||
用分治法可以 **O(n)** 时间找到第二大的数：
|
||
|
||
1. 同时维护最大值和第二大的值
|
||
2. 只有当某个元素**大于当前最大值**时，才更新第二大值
|
||
3. 一次遍历即可完成
|
||
|
||
```cpp
|
||
#include <vector>
|
||
#include <climits>
|
||
using namespace std;
|
||
|
||
// 一次遍历找第二大的数，时间O(n)
|
||
int findSecondMax(vector<int>& A, int n) {
|
||
int maxVal = A[0];
|
||
int secondMax = INT_MIN;
|
||
for (int i = 1; i < n; i++) {
|
||
if (A[i] > maxVal) {
|
||
secondMax = maxVal; // 原来的最大变为第二
|
||
maxVal = A[i]; // 更新最大
|
||
} else if (A[i] > secondMax) {
|
||
secondMax = A[i]; // 更新第二
|
||
}
|
||
}
|
||
return secondMax;
|
||
}
|
||
```
|
||
|
||
#### 4.5 伪币问题
|
||
|
||
**问题**：有 n 枚硬币，其中一枚是假币（重量不同），用天平称量找出假币。
|
||
|
||
**分治策略**：
|
||
|
||
1. 将硬币分为**三组**（尽量均分）
|
||
2. 用天平称量其中两组
|
||
- 若平衡：假币在第三组
|
||
- 若不平衡：假币在较轻（或较重）的一组
|
||
3. 递归处理包含假币的那一组
|
||
|
||
**时间复杂度**：每次排除 2/3，总共只需 **O(log₃n)** 次称量。
|
||
|
||
> [!tip] 为什么是三路划分而不是二路？
|
||
> 天平有三种结果（左重、右重、平衡），对应三路划分。利用三种结果信息，每次排除 2/3 的可能性，效率远高于二分法的 1/2。
|
||
|
||
```mermaid
|
||
flowchart TD
|
||
Start["n coins, find fake"]
|
||
Split["Divide into 3 groups: A, B, C"]
|
||
Weigh["Weigh group A vs group B"]
|
||
Balance["A == B: fake in C"]
|
||
Left["A < B: fake in A (lighter)"]
|
||
Right["A > B: fake in B (lighter)"]
|
||
Recurse["Recurse on the group with fake coin"]
|
||
Found["Found the fake coin"]
|
||
|
||
Start --> Split
|
||
Split --> Weigh
|
||
Weigh --> Balance
|
||
Weigh --> Left
|
||
Weigh --> Right
|
||
Balance --> Recurse
|
||
Left --> Recurse
|
||
Right --> Recurse
|
||
Recurse --> |"n > 1"| Weigh
|
||
Recurse --> |"n = 1"| Found
|
||
```
|
||
|
||
### 五、分治法的递归方程求解
|
||
|
||
分治法的一般递归方程：
|
||
|
||
$$T(n) = aT(n/b) + f(n)$$
|
||
|
||
其中 a 是子问题个数，n/b 是子问题规模，f(n) 是分解与合并的代价。
|
||
|
||
| 算法 | a | b | f(n) | 复杂度 |
|
||
|------|---|---|------|--------|
|
||
| 二分查找 | 1 | 2 | O(1) | O(logn) |
|
||
| 归并排序 | 2 | 2 | O(n) | O(n logn) |
|
||
| 快速排序(平均) | 2 | 2 | O(n) | O(n logn) |
|
||
| 伪币问题 | 1 | 3 | O(1) | O(log₃n) |
|
||
|
||
## 关联笔记
|
||
- [[算法设计与分析/试题册/index|试题册索引]]
|