CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-04-29 21:12:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
This commit is contained in:
krahets
2023-07-24 03:03:29 +08:00
parent d0f117eccc
commit debd909387
16 changed files with 262 additions and 227 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
chapter_divide_and_conquer/binary_search_recur.md
View File

@@ -5,38 +5,47 @@ status: new
# 12.2.   分治搜索策略
我们已经学过，搜索算法分为两大类：暴力搜索、自适应搜索。暴力搜索的时间复杂度为 $O(n)$ 。自适应搜索利用特有的数据组织形式或先验信息，可达到 $O(\log n)$ 甚至 $O(1)$ 的时间复杂度。
我们已经学过，搜索算法分为两大类：
### 基于分治的搜索算法
- **暴力搜索**：它通过遍历数据结构实现，时间复杂度为 $O(n)$ 。
- **自适应搜索**：它利用特有的数据组织形式或先验信息，可达到 $O(\log n)$ 甚至 $O(1)$ 的时间复杂度。
实际上，**$O(\log n)$ 的搜索算法通常都是基于分治策略实现的**，例如：
实际上，**时间复杂度为 $O(\log n)$ 的搜索算法通常都是基于分治策略实现的**，例如：
- 二分查找的每一步都将问题（在数组中搜索目标元素）分解为一个小问题（在数组的一半中搜索目标元素），这个过程一直持续到数组为空或找到目标元素为止。
- 树是分治关系的代表，在二叉搜索树、AVL 树、堆等数据结构中，各种操作的时间复杂度皆为 $O(\log n)$ 。
分治之所以能够提升搜索效率，是因为暴力搜索每轮只能排除一个选项，**而基于分治的搜索每轮可以排除一半选项**。
### 基于分治实现二分
接下来，我们尝试从分治策略的角度分析二分查找的性质：
以二分查找为例：
- **问题可以被分解**：二分查找递归地将原问题（在数组中进行查找）分解为子问题（在数组的一半中进行查找），这是通过比较中间元素和目标元素来实现的。
- **子问题是独立的**：在二分查找中，每轮只处理一个子问题，它不受另外子问题的影响。
- **子问题的解无需合并**：二分查找旨在查找一个特定元素，因此不需要将子问题的解进行合并。当子问题得到解决时，原问题也会同时得到解决。
在之前章节中，我们基于递推（迭代）实现二分查找。现在，我们尝试基于递归分治来实现它。
分治能够提升搜索效率，本质上是因为暴力搜索每轮只能排除一个选项，**而分治搜索每轮可以排除一半选项**。
问题定义为：**在数组 `nums` 的区间 $[i, j]$ 内查找元素 `target`** ，记为 $f(i, j)$ 。
### 基于分治实现二分
设数组长度为 $n$ ，则二分查找的流程为：从原问题 $f(0, n-1)$ 开始，每轮排除一半索引区间，递归求解规模减小一半的子问题，直至找到 `target` 或区间为空时返回。
在之前的章节中，二分查找是基于递推（迭代）实现的。现在我们基于分治（递归）来实现它。
下图展示了在数组中二分查找目标元素 $6$ 的分治过程。
!!! question
给定一个长度为 $n$ 的有序数组 `nums` ，数组中所有元素都是唯一的，请查找元素 `target` 。
从分治角度，我们将搜索区间 $[i, j]$ 对应的子问题记为 $f(i, j)$ 。
从原问题 $f(0, n-1)$ 为起始点，二分查找的分治步骤为：
1. 计算搜索区间 $[i, j]$ 的中点 $m$ ，根据它排除一半搜索区间；
2. 递归求解规模减小一半的子问题，可能为 $f(i, m-1)$ 或 $f(m+1, j)$ ；
3. 循环第 `1.` , `2.` 步，直至找到 `target` 或区间为空时返回。
下图展示了在数组中二分查找元素 $6$ 的分治过程。
![二分查找的分治过程](binary_search_recur.assets/binary_search_recur.png)
<p align="center"> Fig. 二分查找的分治过程 </p>
如下代码所示，我们声明一个递归函数 `dfs()` 来求解问题 $f(i, j)$ 。
在实现代码中，我们声明一个递归函数 `dfs()` 来求解问题 $f(i, j)$ 。
=== "Java"

24
chapter_divide_and_conquer/build_binary_tree_problem.md
View File

@@ -18,8 +18,8 @@ status: new
原问题定义为从 `preorder` 和 `inorder` 构建二叉树。我们首先从分治的角度分析这道题：
- **问题可以被分解**：从分治的角度切入，我们可以将原问题划分为两个子问题：构建左子树、构建右子树，加上一步操作：初始化根节点。而对于每个子树（子问题），我们仍然可以复用以上划分方法，将其划分为更小的子树（子问题），直至达到最小子问题（空子树）时终止。
- **子问题是独立的**：左子树和右子树是相互独立的，它们之间没有交集。在构建左子树时，我们只需要关注中序遍历和前序遍历或后序遍历中与左子树对应的部分。右子树同理。
- **子问题的解可以合并**：一旦我们得到了左子树和右子树，我们可以将它们链接到根节点上，从而得到原问题的解。
- **子问题是独立的**：左子树和右子树是相互独立的，它们之间没有交集。在构建左子树时，我们只需要关注中序遍历和前序遍历中与左子树对应的部分。右子树同理。
- **子问题的解可以合并**：一旦得到了左子树和右子树（子问题的解），我们就可以将它们链接到根节点上，得到原问题的解。
### 如何划分子树
@@ -30,29 +30,29 @@ status: new
- 前序遍历：`[ 根节点 | 左子树 | 右子树 ]` ，例如上图 `[ 3 | 9 | 2 1 7 ]` ；
- 中序遍历：`[ 左子树 | 根节点 ｜ 右子树 ]` ，例如上图 `[ 9 | 3 | 1 2 7 ]` ；
以上图数据为例，我们可以通过以下三步得到上述的划分结果：
以上图数据为例，我们可以通过以下步骤得到上述的划分结果：
1. 前序遍历的首元素 3 为根节点的值；
2. 查找根节点在 `inorder` 中的索引，基于该索引可将 `inorder` 划分为 `[ 9 | 3 ｜ 1 2 7 ]` ；
3. 根据 `inorder` 划分结果，可得左子树和右子树分别有 1 个和 3 个节点，从而可将 `preorder` 划分为 `[ 3 | 9 | 2 1 7 ]` ；
1. 前序遍历的首元素 3 是根节点的值；
2. 查找根节点 3 在 `inorder` 中的索引，利用该索引可将 `inorder` 划分为 `[ 9 | 3 ｜ 1 2 7 ]` ；
3. 根据 `inorder` 划分结果，易得左子树和右子树的节点数量分别为 1 和 3 ，从而可将 `preorder` 划分为 `[ 3 | 9 | 2 1 7 ]` ；
![在前序和中序遍历中划分子树](build_binary_tree_problem.assets/build_tree_preorder_inorder_division.png)
<p align="center"> Fig. 在前序和中序遍历中划分子树 </p>
### 使用指针描述子树区间
### 基于变量描述子树区间
至此，**我们已经推导出根节点、左子树、右子树在 `preorder` 和 `inorder` 中的索引区间**。而为了描述这些索引区间，我们需要借助几个指针变量：
根据以上划分方法，**我们已经得到根节点、左子树、右子树在 `preorder` 和 `inorder` 中的索引区间**。而为了描述这些索引区间，我们需要借助几个指针变量：
- 将当前树的根节点在 `preorder` 中的索引记为 $i$ ；
- 将当前树的根节点在 `inorder` 中的索引记为 $m$ ；
- 将当前树在 `inorder` 中的索引区间记为 $[l, r]$ ；
下表整理了根节点、左子树和右子树的索引区间在这些变量下的具体表示。
如下表所示，通过以上变量即可表示根节点在 `preorder` 中的索引，以及子树在 `inorder` 中的索引区间。
<div class="center-table" markdown>
| | 子树根节点在 `preorder` 中的索引 | 子树在 `inorder` 中的索引区间 |
| | 根节点在 `preorder` 中的索引 | 子树在 `inorder` 中的索引区间 |
| ------ | -------------------------------- | ----------------------------- |
| 当前树 | $i$ | $[l, r]$ |
| 左子树 | $i + 1$ | $[l, m-1]$ |
@@ -68,7 +68,7 @@ status: new
### 代码实现
接下来就可以实现代码了。为了提升查询 $m$ 的效率，我们借助一个哈希表 `hmap` 来存储 `inorder` 列表元素到索引的映射。
为了提升查询 $m$ 的效率，我们借助一个哈希表 `hmap` 来存储数组 `inorder` 中元素到索引的映射。
=== "Java"
@@ -282,7 +282,7 @@ status: new
[class]{}-[func]{buildTree}
```
下图展示了构建二叉树的递归过程，各个节点是在向下“递”的过程中建立的，而各条边是在向上“归”的过程中建立的。
下图展示了构建二叉树的递归过程，各个节点是在向下“递”的过程中建立的，而各条边（即引用）是在向上“归”的过程中建立的。
=== "<1>"
![构建二叉树的递归过程](build_binary_tree_problem.assets/built_tree_step1.png)

32
chapter_divide_and_conquer/divide_and_conquer.md
View File

@@ -5,15 +5,15 @@ status: new
# 12.1. &nbsp; 分治算法
「分治 Divide and Conquer」，全称分而治之，是一种非常重要的算法策略。分治通常基于递归实现，包括“分”和“治”两部分，主要步骤如下：
「分治 Divide and Conquer」，全称分而治之，是一种非常重要且常见的算法策略。分治通常基于递归实现，包括“分”和“治”两步：
1. **分（划分阶段）**：递归地将原问题分解为两个或多个子问题，直至到达最小子问题时终止；
2. **治（合并阶段）**：从已知解的最小子问题开始，从底至顶地将子问题的解进行合并，从而构建出原问题的解；
之前学过的「归并排序」是分治策略的典型应用之一，对于该算法：
已介绍过的「归并排序」是分治策略的典型应用之一，它的分治策略为：
1. **分**：递归地将原数组（原问题）划分为两个子数组（子问题），直到子数组只剩一个元素（最小子问题）。
2. **治**：从底至顶地将有序的子数组进行合并，从而得到有序的原数组。
2. **治**：从底至顶地将有序的子数组（子问题的解）进行合并，从而得到有序的原数组（原问题的解）。
![归并排序的分治策略](divide_and_conquer.assets/divide_and_conquer_merge_sort.png)
@@ -25,26 +25,26 @@ status: new
1. **问题可以被分解**：原问题可以被分解成规模更小、类似的子问题，以及能够以相同方式递归地进行划分。
2. **子问题是独立的**：子问题之间是没有重叠的，互相没有依赖，可以被独立解决。
3. **子问题的解可以被合并**：原问题的解可以通过合并子问题的解得来。
3. **子问题的解可以被合并**：原问题的解通过合并子问题的解得来。
归并排序显然是满足以上三条判断依据的：
显然归并排序，满足以上三条判断依据：
1. 递归地将数组（原问题）划分为两个子数组（子问题），当子数组只有一个元素时天然有序；
2. 每个子数组都可以独立地进行排序，因此子问题是独立的；
1. 递归地将数组（原问题）划分为两个子数组（子问题）；
2. 每个子数组都可以独立地进行排序（子问题可以独立进行求解）；
3. 两个有序子数组（子问题的解）可以被合并为一个有序数组（原问题的解）；
## 12.1.2. &nbsp; 通过分治提升效率
分治不仅可以有效地解决算法问题，**往往还可以提升算法效率**。在排序算法中，归并排序相较于选择、冒泡、插入排序更快，就是因为其应用了分治策略。
分治不仅可以有效地解决算法问题，**往往还可以带来算法效率的提升**。在排序算法中，快速排序、归并排序、堆排序相较于选择、冒泡、插入排序更快，就是因为它们应用了分治策略。
那么，我们不禁发问：**为什么分治可以提升算法效率，其底层逻辑是什么**？换句话说，将大问题分解为多个子问题、解决子问题、将子问题的解合并为原问题的解，这三步为什么比直接解决原问题效率更高？这个问题可以从操作数量和并行计算两方面来讨论。
那么，我们不禁发问：**为什么分治可以提升算法效率，其底层逻辑是什么**？换句话说，将大问题分解为多个子问题、解决子问题、将子问题的解合并为原问题的解，这几步的效率为什么比直接解决原问题的效率更高？这个问题可以从操作数量和并行计算两方面来讨论。
### 操作数量优化
以「冒泡排序」为例，其处理一个长度为 $n$ 的数组需要 $O(n^2)$ 时间。假设我们把数组从中点分为两个子数组，则划分需要 $O(n)$ 时间，排序每个子数组需要 $O((n/2)^2)$ 时间，合并两个子数组需要 $O(n)$ 时间，总体时间复杂度为：
以「冒泡排序」为例，其处理一个长度为 $n$ 的数组需要 $O(n^2)$ 时间。假设我们把数组从中点分为两个子数组，则划分需要 $O(n)$ 时间，排序每个子数组需要 $O((\frac{n}{2})^2)$ 时间，合并两个子数组需要 $O(n)$ 时间，总体时间复杂度为：
$$
O(n + (n/2)^2 \times 2 + n) = O(n^2 / 2 + 2n)
O(n + (\frac{n}{2})^2 \times 2 + n) = O(\frac{n^2}{2} + 2n)
$$
![划分数组前后的冒泡排序](divide_and_conquer.assets/divide_and_conquer_bubble_sort.png)
@@ -61,11 +61,11 @@ n(n - 4) & > 0
\end{aligned}
$$
**这意味着当 $n > 4$ 时，划分后的操作数量更少，排序效率可能更高**。当然，划分后的时间复杂度仍然是平方阶 $O(n^2)$ ，即复杂度并没有降低，只是其中的常数项变小了。
**这意味着当 $n > 4$ 时，划分后的操作数量更少，排序效率应该更高**。请注意，划分后的时间复杂度仍然是平方阶 $O(n^2)$ ，只是复杂度中的常数项变小了。
那么，**如果我们把子数组不断地再从中点划分为两个子数组**，直至子数组只剩一个元素时停止划分呢？这就达到了「归并排序」的情况，时间复杂度为 $O(n \log n)$ 。
进一步想，**如果我们把子数组不断地再从中点划分为两个子数组**，直至子数组只剩一个元素时停止划分呢？这种思路实际上就是「归并排序」，时间复杂度为 $O(n \log n)$ 。
再思考，**如果我们多设置几个划分点**，将原数组平均划分为 $k$ 个子数组呢？这种情况就与「桶排序」非常类似了，它非常适合排序海量数据，理论上时间复杂度可以达到 $O(n + k)$ 。
再思考，**如果我们多设置几个划分点**，将原数组平均划分为 $k$ 个子数组呢？这种情况与「桶排序」非常类似，它非常适合排序海量数据，理论上时间复杂度可以达到 $O(n + k)$ 。
### 并行计算优化
@@ -73,7 +73,7 @@ $$
并行优化在多核或多处理器的环境中尤其有效，因为系统可以同时处理多个子问题，更加充分地利用计算资源，从而显著减少总体的运行时间。
例如在桶排序中，我们将海量的数据平均分配到各个桶中，则可所有桶的排序任务分散到各个计算单元，完成后再进行结果合并。
比如在桶排序中，我们将海量的数据平均分配到各个桶中，则可所有桶的排序任务分散到各个计算单元，完成后再进行结果合并。
![桶排序的并行计算](divide_and_conquer.assets/divide_and_conquer_parallel_computing.png)
@@ -89,7 +89,7 @@ $$
- **汉诺塔问题**：汉诺塔问题可以视为典型的分治策略，通过递归解决。
- **求解逆序对**：在一个序列中，如果前面的数字大于后面的数字，那么这两个数字构成一个逆序对。求解逆序对问题可以通过分治的思想，借助归并排序进行求解。
另一方面，**分治在算法和数据结构的设计中应用非常广泛**，举几个已经学过的例子：
另一方面，分治在算法和数据结构的设计中应用非常广泛，举几个已经学过的例子：
- **二分查找**：二分查找是将有序数组从中点索引分为两部分，然后根据目标值与中间元素值比较结果，决定排除哪一半区间，然后在剩余区间执行相同的二分操作。
- **归并排序**：文章开头已介绍，不再赘述。

18
chapter_divide_and_conquer/hanota_problem.md
View File

@@ -5,7 +5,7 @@ status: new
# 12.4. &nbsp; 汉诺塔问题
在归并排序和构建二叉树中，我们将原问题分解为两个规模为原问题一半的子问题。然而，对于即将介绍的汉诺塔问题，我们采用不同的分解策略。
在归并排序和构建二叉树中，我们都是将原问题分解为两个规模为原问题一半的子问题。然而对于汉诺塔问题，我们采用不同的分解策略。
!!! question
@@ -19,7 +19,7 @@ status: new
<p align="center"> Fig. 汉诺塔问题示例 </p>
在本文中，**我们将规模为 $i$ 的汉诺塔问题记做 $f(i)$** 。例如 $f(3)$ 代表将 $3$ 个圆盘从 `A` 移动至 `C` 的汉诺塔问题。
**我们将规模为 $i$ 的汉诺塔问题记做 $f(i)$** 。例如 $f(3)$ 代表将 $3$ 个圆盘从 `A` 移动至 `C` 的汉诺塔问题。
### 考虑基本情况
@@ -37,7 +37,7 @@ status: new
2. 再将大圆盘从 `A` 移至 `C` ；
3. 最后将小圆盘从 `B` 移至 `C` ；
如下图所示，对于小圆盘的移动，**我们称 `C` 为目标柱、`B` 为缓冲柱**。
解决问题 $f(2)$ 的过程可总结为：**将两个圆盘借助 `B` 从 `A` 移至 `C`** 。其中，`C` 称为目标柱、`B` 称为缓冲柱。
=== "<1>"
![规模为 2 问题的解](hanota_problem.assets/hanota_f2_step1.png)
@@ -53,10 +53,10 @@ status: new
### 子问题分解
对于问题 $f(3)$ ，即当有三个圆盘时，情况变得稍微复杂了一些。由于已知 $f(1)$ 和 $f(2)$ 的解，我们可以从分治角度思考，**将 `A` 顶部的两个圆盘看做一个整体**，并执行以下步骤：
对于问题 $f(3)$ ，即当有三个圆盘时，情况变得稍微复杂了一些。由于已知 $f(1)$ 和 $f(2)$ 的解，因此可从分治角度思考，**将 `A` 顶部的两个圆盘看做一个整体**，执行以下步骤：
1. 令 `B` 为目标柱、`C` 为缓冲柱，将两个圆盘从 `A` 移动至 `B` ；
2. 将 `A` 中剩余的一个圆盘从 `A` 移动至 `C` ；
2. 将 `A` 中剩余的一个圆盘从 `A` 直接移动至 `C` ；
3. 令 `C` 为目标柱、`A` 为缓冲柱，将两个圆盘从 `B` 移动至 `C` ；
这样三个圆盘就被顺利地从 `A` 移动至 `C` 了。
@@ -73,15 +73,15 @@ status: new
=== "<4>"
![hanota_f3_step4](hanota_problem.assets/hanota_f3_step4.png)
本质上看，我们将问题 $f(3)$ 划分为两个子问题 $f(2)$ 和子问题 $f(1)$。按顺序解决这三个子问题之后，原问题随之得到解决。**以上分析说明了子问题的独立性，以及解是可以合并的**。
本质上看，**我们将问题 $f(3)$ 划分为两个子问题 $f(2)$ 和子问题 $f(1)$** 。按顺序解决这三个子问题之后，原问题随之得到解决。这说明子问题是独立的，且解是可以合并的。
至此，我们可总结出汉诺塔问题的分治策略：**将原问题 $f(n)$ 划分为两个子问题 $f(n-1)$ 和一个子问题 $f(1)$** 。子问题的解决顺序为：
至此，我们可总结出汉诺塔问题的分治策略：将原问题 $f(n)$ 划分为两个子问题 $f(n-1)$ 和一个子问题 $f(1)$ 。子问题的解决顺序为：
1. 将 $n-1$ 个圆盘借助 `C` 从 `A` 移至 `B` ；
2. 将剩余 $1$ 个圆盘从 `A` 直接移至 `C` ；
3. 将 $n-1$ 个圆盘借助 `A` 从 `B` 移至 `C` ；
并且，对于这两个子问题 $f(n-1)$ ，**可以通过相同的方式进行递归划分**，直至达到最小子问题 $f(1)$ 。而 $f(1)$ 的解是已知的，只需一次移动操作即可。
对于这两个子问题 $f(n-1)$ ，**可以通过相同的方式进行递归划分**，直至达到最小子问题 $f(1)$ 。而 $f(1)$ 的解是已知的，只需一次移动操作即可。
![汉诺塔问题的分治策略](hanota_problem.assets/hanota_divide_and_conquer.png)
@@ -89,7 +89,7 @@ status: new
### 代码实现
在代码实现中，我们声明一个递归函数 `dfs(i, src, buf, tar)` ，它的作用是将柱 `src` 顶部的 $i$ 个圆盘借助缓冲柱 `buf` 移动至目标柱 `tar` 。
在代码中，我们声明一个递归函数 `dfs(i, src, buf, tar)` ，它的作用是将柱 `src` 顶部的 $i$ 个圆盘借助缓冲柱 `buf` 移动至目标柱 `tar` 。
=== "Java"