Finetune the articles.
|
@ -2,7 +2,7 @@
|
|||
|
||||
「回溯算法 Backtracking Algorithm」是一种通过穷举来解决问题的方法,它的核心思想是从一个初始状态出发,暴力搜索所有可能的解决方案,当遇到正确的解则将其记录,直到找到解或者尝试了所有可能的选择都无法找到解为止。
|
||||
|
||||
回溯算法通常采用「深度优先搜索」来遍历解空间。在二叉树章节中,我们提到前序、中序和后序遍历都属于深度优先搜索。下面,我们将从前序遍历入手,逐步了解回溯算法的工作原理。
|
||||
回溯算法通常采用「深度优先搜索」来遍历解空间。在二叉树章节中,我们提到前序、中序和后序遍历都属于深度优先搜索。接下来我们先用前序遍历构造一个回溯问题,逐步了解回溯算法的工作原理。
|
||||
|
||||
!!! question "例题一"
|
||||
|
||||
|
@ -728,6 +728,20 @@
|
|||
|
||||
相较于基于前序遍历的实现代码,基于回溯算法框架的实现代码虽然显得啰嗦,但通用性更好。实际上,**所有回溯问题都可以在该框架下解决**。我们需要根据具体问题来定义 `state` 和 `choices` ,并实现框架中的各个方法。
|
||||
|
||||
## 优势与局限性
|
||||
|
||||
回溯算法本质上是一种深度优先搜索算法,它尝试所有可能的解决方案直到找到满足条件的解。这种方法的优势在于它能够找到所有可能的解决方案,而且在合理的剪枝操作下,具有很高的效率。
|
||||
|
||||
然而,在处理大规模或者复杂问题时,**回溯算法的运行效率可能难以接受**。
|
||||
|
||||
- 在最坏的情况下,回溯算法需要遍历解空间的所有可能解,所需时间很长。例如,求解 $n$ 皇后问题的时间复杂度可以达到 $O(n!)$ 。
|
||||
- 在每一次递归调用时,都需要保存当前的状态(例如选择路径、用于剪枝的辅助变量等),对于深度很大的递归,空间需求可能会变得非常大。
|
||||
|
||||
即便如此,**回溯算法仍然是某些搜索问题和约束满足问题的最佳解决方案**。对于这些问题,由于无法预测哪些选择可生成有效的解,因此我们必须对所有可能的选择进行遍历。在这种情况下,**关键是如何进行效率优化**:
|
||||
|
||||
- 上文介绍过的剪枝是一种常用的优化方法。它可以避免搜索那些肯定不会产生有效解的路径,从而节省时间和空间。
|
||||
- 另一个常用的优化方法是加入「启发式搜索 Heuristic Search」策略,它在搜索过程中引入一些策略或者估计值,从而优先搜索最有可能产生有效解的路径。
|
||||
|
||||
## 典型例题
|
||||
|
||||
**搜索问题**:这类问题的目标是找到满足特定条件的解决方案。
|
||||
|
@ -749,14 +763,3 @@
|
|||
- 最大团问题:给定一个无向图,找到最大的完全子图,即子图中的任意两个顶点之间都有边相连。
|
||||
|
||||
请注意,回溯算法通常不是解决组合优化问题的最优方法。0-1 背包问题通常使用动态规划解决;旅行商是一个 NP-Hard 问题,常用解决方法有遗传算法和蚁群算法等;最大团问题是图轮中的一个经典 NP-Hard 问题,通常用贪心算法等启发式算法来解决。
|
||||
|
||||
## 优势与局限性
|
||||
|
||||
回溯算法本质上是一种深度优先搜索算法,它尝试所有可能的解决方案直到找到满足条件的解。这种方法的优势在于它能够找到所有可能的解决方案,而且在合理的剪枝操作下,具有很高的效率。
|
||||
|
||||
然而,在处理大规模或者复杂问题时,**回溯算法的运行效率可能难以接受**。这是因为在最坏的情况下,回溯算法需要遍历解空间的所有可能解。例如,求解 $n$ 皇后问题的时间复杂度可以达到 $O(n!)$ 。回溯算法的空间复杂度也可能较高。因为在每一次递归调用时,都需要保存当前的状态(例如选择路径、用于剪枝的辅助变量等),对于深度很大的递归,空间需求可能会变得非常大。
|
||||
|
||||
即便如此,**回溯算法仍然是某些搜索问题和约束满足问题的最佳解决方案**。对于这些问题,由于我们无法预测哪些选择可生成有效的解,因此我们必须对所有可能的选择进行遍历。在这种情况下,**关键是如何进行效率优化**:
|
||||
|
||||
- 上文介绍过的剪枝是一种常用的优化方法。它可以避免搜索那些肯定不会产生有效解的路径,从而节省时间和空间。
|
||||
- 另一个常用的优化方法是加入「启发式搜索 Heuristic Search」策略,它在搜索过程中引入一些策略或者估计值,从而优先搜索最有可能产生有效解的路径。
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
全排列问题是回溯算法的一个典型应用。它的定义是在给定一个集合(如一个数组或字符串)的情况下,找出这个集合中元素的所有可能的排列。
|
||||
|
||||
如下表所示,列举了几个示例数组和其对应的所有排列。
|
||||
下表列举了几个示例数据,包括输入数组和对应的所有排列。
|
||||
|
||||
<div class="center-table" markdown>
|
||||
|
||||
|
@ -120,7 +120,7 @@
|
|||
|
||||
需要重点关注的是,我们引入了一个布尔型数组 `selected` ,它的长度与输入数组长度相等,其中 `selected[i]` 表示 `choices[i]` 是否已被选择。我们利用 `selected` 避免某个元素被重复选择,从而实现剪枝。
|
||||
|
||||
如下图所示,假设我们第一轮选择 1 ,第二轮选择 3 ,第三轮选择 2 ,则需要在第二轮剪掉元素 1 的分支,在第三轮剪掉元素 1, 3 的分支。**从本质上理解,此剪枝操作可将搜索空间大小从 $O(n^n)$ 降低至 $O(n!)$** 。
|
||||
如下图所示,假设我们第一轮选择 1 ,第二轮选择 3 ,第三轮选择 2 ,则需要在第二轮剪掉元素 1 的分支,在第三轮剪掉元素 1, 3 的分支。**此剪枝操作可将搜索空间大小从 $O(n^n)$ 降低至 $O(n!)$** 。
|
||||
|
||||
![全排列剪枝示例](permutations_problem.assets/permutations_i_pruning.png)
|
||||
|
||||
|
@ -134,7 +134,7 @@
|
|||
|
||||
![重复排列](permutations_problem.assets/permutations_ii.png)
|
||||
|
||||
那么,如何去除重复的排列呢?最直接地,我们可以借助一个哈希表,直接对排列结果进行去重。然而,这样做不够优雅,因为生成重复排列的搜索分支是没有必要的,应当被提前识别并剪枝,这样可以提升算法效率。
|
||||
那么,如何去除重复的排列呢?最直接地,我们可以借助一个哈希表,直接对排列结果进行去重。然而这样做不够优雅,**因为生成重复排列的搜索分支是没有必要的,应当被提前识别并剪枝**,这样可以进一步提升算法效率。
|
||||
|
||||
观察发现,在第一轮中,选择 $1$ 或选择 $\hat{1}$ 是等价的,因为在这两个选择之下生成的所有排列都是重复的。因此,我们应该把 $\hat{1}$ 剪枝掉。同理,在第一轮选择 $2$ 后,第二轮选择中的 $1$ 和 $\hat{1}$ 也会产生重复分支,因此也需要将第二轮的 $\hat{1}$ 剪枝。
|
||||
|
||||
|
|
|
@ -44,7 +44,7 @@
|
|||
=== "Java"
|
||||
|
||||
```java title=""
|
||||
/* 使用多种「基本数据类型」来初始化「数组」 */
|
||||
// 使用多种基本数据类型来初始化数组
|
||||
int[] numbers = new int[5];
|
||||
float[] decimals = new float[5];
|
||||
char[] characters = new char[5];
|
||||
|
@ -54,7 +54,7 @@
|
|||
=== "C++"
|
||||
|
||||
```cpp title=""
|
||||
/* 使用多种「基本数据类型」来初始化「数组」 */
|
||||
// 使用多种基本数据类型来初始化数组
|
||||
int numbers[5];
|
||||
float decimals[5];
|
||||
char characters[5];
|
||||
|
@ -81,14 +81,14 @@
|
|||
=== "JavaScript"
|
||||
|
||||
```javascript title=""
|
||||
/* JavaScript 的数组可以自由存储各种基本数据类型和对象 */
|
||||
// JavaScript 的数组可以自由存储各种基本数据类型和对象
|
||||
const array = [0, 0.0, 'a', false];
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title=""
|
||||
/* 使用多种「基本数据类型」来初始化「数组」 */
|
||||
// 使用多种基本数据类型来初始化数组
|
||||
const numbers: number[] = [];
|
||||
const characters: string[] = [];
|
||||
const booleans: boolean[] = [];
|
||||
|
@ -97,7 +97,7 @@
|
|||
=== "C"
|
||||
|
||||
```c title=""
|
||||
/* 使用多种「基本数据类型」来初始化「数组」 */
|
||||
// 使用多种基本数据类型来初始化数组
|
||||
int numbers[10];
|
||||
float decimals[10];
|
||||
char characters[10];
|
||||
|
@ -107,7 +107,7 @@
|
|||
=== "C#"
|
||||
|
||||
```csharp title=""
|
||||
/* 使用多种「基本数据类型」来初始化「数组」 */
|
||||
// 使用多种基本数据类型来初始化数组
|
||||
int[] numbers = new int[5];
|
||||
float[] decimals = new float[5];
|
||||
char[] characters = new char[5];
|
||||
|
@ -117,7 +117,7 @@
|
|||
=== "Swift"
|
||||
|
||||
```swift title=""
|
||||
/* 使用多种「基本数据类型」来初始化「数组」 */
|
||||
// 使用多种基本数据类型来初始化数组
|
||||
let numbers = Array(repeating: Int(), count: 5)
|
||||
let decimals = Array(repeating: Double(), count: 5)
|
||||
let characters = Array(repeating: Character("a"), count: 5)
|
||||
|
@ -133,7 +133,7 @@
|
|||
=== "Dart"
|
||||
|
||||
```dart title=""
|
||||
/* 使用多种「基本数据类型」来初始化「数组」 */
|
||||
// 使用多种基本数据类型来初始化数组
|
||||
List<int> numbers = List.filled(5, 0);
|
||||
List<double> decimals = List.filled(5, 0.0);
|
||||
List<String> characters = List.filled(5, 'a');
|
||||
|
|
|
@ -6,16 +6,22 @@
|
|||
|
||||
**「逻辑结构」揭示了数据元素之间的逻辑关系**。在数组和链表中,数据按照顺序依次排列,体现了数据之间的线性关系;而在树中,数据从顶部向下按层次排列,表现出祖先与后代之间的派生关系;图则由节点和边构成,反映了复杂的网络关系。
|
||||
|
||||
逻辑结构通常分为「线性」和「非线性」两类。线性结构比较直观,指数据在逻辑关系上呈线性排列;非线性结构则相反,呈非线性排列,例如网状或树状结构。
|
||||
逻辑结构通常分为“线性”和“非线性”两类。线性结构比较直观,指数据在逻辑关系上呈线性排列;非线性结构则相反,呈非线性排列。
|
||||
|
||||
- **线性数据结构**:数组、链表、栈、队列、哈希表;
|
||||
- **非线性数据结构**:树、图、堆、哈希表;
|
||||
- **非线性数据结构**:树、堆、图、哈希表;
|
||||
|
||||
![线性与非线性数据结构](classification_of_data_structure.assets/classification_logic_structure.png)
|
||||
|
||||
非线性数据结构可以进一步被划分为树形结构和网状结构。
|
||||
|
||||
- **线性结构**:数组、链表、队列、栈、哈希表,元素存在一对一的顺序关系;
|
||||
- **树形结构**:树、堆、哈希表,元素存在一对多的关系;
|
||||
- **网状结构**:图,元素存在多对多的关系;
|
||||
|
||||
## 物理结构:连续与离散
|
||||
|
||||
在计算机中,内存和硬盘是两种主要的存储硬件设备。「硬盘」主要用于长期存储数据,容量较大(通常可达到 TB 级别)、速度较慢。「内存」用于运行程序时暂存数据,速度较快,但容量较小(通常为 GB 级别)。
|
||||
在计算机中,内存和硬盘是两种主要的存储硬件设备。硬盘主要用于长期存储数据,容量较大(通常可达到 TB 级别)、速度较慢。内存用于运行程序时暂存数据,速度较快,但容量较小(通常为 GB 级别)。
|
||||
|
||||
**在算法运行过程中,相关数据都存储在内存中**。下图展示了一个计算机内存条,其中每个黑色方块都包含一块内存空间。我们可以将内存想象成一个巨大的 Excel 表格,其中每个单元格都可以存储 1 byte 的数据,在算法运行时,所有数据都被存储在这些单元格中。
|
||||
|
||||
|
@ -34,7 +40,7 @@
|
|||
- **基于数组可实现**:栈、队列、哈希表、树、堆、图、矩阵、张量(维度 $\geq 3$ 的数组)等;
|
||||
- **基于链表可实现**:栈、队列、哈希表、树、堆、图等;
|
||||
|
||||
基于数组实现的数据结构也被称为「静态数据结构」,这意味着此类数据结构在初始化后长度不可变。相对应地,基于链表实现的数据结构被称为「动态数据结构」,这类数据结构在初始化后,仍可以在程序运行过程中对其长度进行调整。
|
||||
基于数组实现的数据结构也被称为“静态数据结构”,这意味着此类数据结构在初始化后长度不可变。相对应地,基于链表实现的数据结构被称为“动态数据结构”,这类数据结构在初始化后,仍可以在程序运行过程中对其长度进行调整。
|
||||
|
||||
!!! tip
|
||||
|
||||
|
|
Before Width: | Height: | Size: 70 KiB After Width: | Height: | Size: 70 KiB |
Before Width: | Height: | Size: 64 KiB After Width: | Height: | Size: 64 KiB |
Before Width: | Height: | Size: 67 KiB After Width: | Height: | Size: 67 KiB |
Before Width: | Height: | Size: 69 KiB After Width: | Height: | Size: 69 KiB |
|
@ -14,7 +14,7 @@
|
|||
|
||||
如下图所示,若第 $1$ , $2$ , $3$ 阶的代价分别为 $1$ , $10$ , $1$ ,则从地面爬到第 $3$ 阶的最小代价为 $2$ 。
|
||||
|
||||
![爬到第 3 阶的最小代价](intro_to_dynamic_programming.assets/min_cost_cs_example.png)
|
||||
![爬到第 3 阶的最小代价](dp_problem_features.assets/min_cost_cs_example.png)
|
||||
|
||||
设 $dp[i]$ 为爬到第 $i$ 阶累计付出的代价,由于第 $i$ 阶只可能从 $i - 1$ 阶或 $i - 2$ 阶走来,因此 $dp[i]$ 只可能等于 $dp[i - 1] + cost[i]$ 或 $dp[i - 2] + cost[i]$ 。为了尽可能减少代价,我们应该选择两者中较小的那一个,即:
|
||||
|
||||
|
@ -96,7 +96,7 @@ $$
|
|||
[class]{}-[func]{minCostClimbingStairsDP}
|
||||
```
|
||||
|
||||
![爬楼梯最小代价的动态规划过程](intro_to_dynamic_programming.assets/min_cost_cs_dp.png)
|
||||
![爬楼梯最小代价的动态规划过程](dp_problem_features.assets/min_cost_cs_dp.png)
|
||||
|
||||
这道题同样也可以进行状态压缩,将一维压缩至零维,使得空间复杂度从 $O(n)$ 降低至 $O(1)$ 。
|
||||
|
||||
|
@ -180,7 +180,7 @@ $$
|
|||
|
||||
例如,爬上第 $3$ 阶仅剩 $2$ 种可行方案,其中连续三次跳 $1$ 阶的方案不满足约束条件,因此被舍弃。
|
||||
|
||||
![带约束爬到第 3 阶的方案数量](intro_to_dynamic_programming.assets/climbing_stairs_constraint_example.png)
|
||||
![带约束爬到第 3 阶的方案数量](dp_problem_features.assets/climbing_stairs_constraint_example.png)
|
||||
|
||||
在该问题中,**下一步选择不能由当前状态(当前楼梯阶数)独立决定,还和前一个状态(上轮楼梯阶数)有关**。如果上一轮是跳 $1$ 阶上来的,那么下一轮就必须跳 $2$ 阶。
|
||||
|
||||
|
@ -200,7 +200,7 @@ dp[i, 2] = dp[i-2, 1] + dp[i-2, 2]
|
|||
\end{cases}
|
||||
$$
|
||||
|
||||
![考虑约束下的递推关系](intro_to_dynamic_programming.assets/climbing_stairs_constraint_state_transfer.png)
|
||||
![考虑约束下的递推关系](dp_problem_features.assets/climbing_stairs_constraint_state_transfer.png)
|
||||
|
||||
最终,返回 $dp[n, 1] + dp[n, 2]$ 即可,两者之和代表爬到第 $n$ 阶的方案总数。
|
||||
|
||||
|
|
|
@ -85,14 +85,14 @@ $$
|
|||
|
||||
边界条件即初始状态,在搜索中用于剪枝,在动态规划中用于初始化 $dp$ 表。状态转移顺序的核心是要保证在计算当前问题时,所有它依赖的更小子问题都已经被正确地计算出来。
|
||||
|
||||
最后,我们基于以上结果实现解法即可。熟练度较高同学可以直接写出动态规划解法,初学者可以按照“暴力搜索 $\rightarrow$ 记忆化搜索 $\rightarrow$ 动态规划” 的顺序实现。
|
||||
接下来,我们就可以实现动态规划代码了。然而,由于子问题分解是一种从顶至底的思想,因此按照“暴力搜索 $\rightarrow$ 记忆化搜索 $\rightarrow$ 动态规划”的顺序实现更加符合思维习惯。
|
||||
|
||||
## 方法一:暴力搜索
|
||||
|
||||
从状态 $[i, j]$ 开始搜索,不断分解为更小的状态 $[i-1, j]$ 和 $[i, j-1]$ ,包括以下递归要素:
|
||||
|
||||
- **递归参数**:状态 $[i, j]$ ;**返回值**:从 $[0, 0]$ 到 $[i, j]$ 的最小路径和 $dp[i, j]$ ;
|
||||
- **终止条件**:当 $i = 0$ 且 $j = 0$ 时,返回代价 $grid[0][0]$ ;
|
||||
- **终止条件**:当 $i = 0$ 且 $j = 0$ 时,返回代价 $grid[0, 0]$ ;
|
||||
- **剪枝**:当 $i < 0$ 时或 $j < 0$ 时索引越界,此时返回代价 $+\infty$ ,代表不可行;
|
||||
|
||||
=== "Java"
|
||||
|
@ -250,7 +250,7 @@ $$
|
|||
=== "Java"
|
||||
|
||||
```java title="min_path_sum.java"
|
||||
[class]{min}-[func]{minPathSumDP}
|
||||
[class]{min_path_sum}-[func]{minPathSumDP}
|
||||
```
|
||||
|
||||
=== "C++"
|
||||
|
@ -358,7 +358,7 @@ $$
|
|||
=== "Java"
|
||||
|
||||
```java title="min_path_sum.java"
|
||||
[class]{min}-[func]{minPathSumDPComp}
|
||||
[class]{min_path_sum}-[func]{minPathSumDPComp}
|
||||
```
|
||||
|
||||
=== "C++"
|
||||
|
|
|
@ -22,7 +22,7 @@
|
|||
|
||||
状态 $[i, c]$ 对应的子问题为:**前 $i$ 个物品在剩余容量为 $c$ 的背包中的最大价值**,记为 $dp[i, c]$ 。
|
||||
|
||||
至此,我们得到一个尺寸为 $n \times cap$ 的二维 $dp$ 矩阵。
|
||||
需要求解的是 $dp[n, cap]$ ,因此需要一个尺寸为 $(n+1) \times (cap+1)$ 的二维 $dp$ 表。
|
||||
|
||||
**第二步:找出最优子结构,进而推导出状态转移方程**
|
||||
|
||||
|
@ -45,6 +45,10 @@ $$
|
|||
|
||||
当前状态 $[i, c]$ 从上方的状态 $[i-1, c]$ 和左上方的状态 $[i-1, c-wgt[i-1]]$ 转移而来,因此通过两层循环正序遍历整个 $dp$ 表即可。
|
||||
|
||||
!!! tip
|
||||
|
||||
完成以上三步后,我们可以直接实现从底至顶的动态规划解法。而为了展示本题包含的重叠子问题,本文也同时给出从顶至底的暴力搜索和记忆化搜索解法。
|
||||
|
||||
## 方法一:暴力搜索
|
||||
|
||||
搜索代码包含以下要素:
|
||||
|
@ -201,7 +205,7 @@ $$
|
|||
|
||||
## 方法三:动态规划
|
||||
|
||||
动态规划解法本质上就是在状态转移中填充 `dp` 矩阵的过程,代码如下所示。
|
||||
动态规划解法本质上就是在状态转移中填充 $dp$ 表的过程,代码如下所示。
|
||||
|
||||
=== "Java"
|
||||
|
||||
|
@ -269,7 +273,7 @@ $$
|
|||
[class]{}-[func]{knapsackDP}
|
||||
```
|
||||
|
||||
如下图所示,时间复杂度由 `dp` 矩阵大小决定,为 $O(n \times cap)$ 。
|
||||
如下图所示,时间复杂度由数组 `dp` 大小决定,为 $O(n \times cap)$ 。
|
||||
|
||||
=== "<1>"
|
||||
![0-1 背包的动态规划过程](knapsack_problem.assets/knapsack_dp_step1.png)
|
||||
|
@ -313,9 +317,9 @@ $$
|
|||
=== "<14>"
|
||||
![knapsack_dp_step14](knapsack_problem.assets/knapsack_dp_step14.png)
|
||||
|
||||
**最后考虑状态压缩**。以上代码中的 `dp` 矩阵占用 $O(n \times cap)$ 空间。由于每个状态都只与其上一行的状态有关,因此我们可以使用两个数组滚动前进,将空间复杂度从 $O(n^2)$ 将低至 $O(n)$ 。代码省略,有兴趣的同学可以自行实现。
|
||||
**最后考虑状态压缩**。以上代码中的数组 `dp` 占用 $O(n \times cap)$ 空间。由于每个状态都只与其上一行的状态有关,因此我们可以使用两个数组滚动前进,将空间复杂度从 $O(n^2)$ 将低至 $O(n)$ 。代码省略,有兴趣的同学可以自行实现。
|
||||
|
||||
那么,我们是否可以仅用一个数组实现状态压缩呢?观察可知,每个状态都是由左上方或正上方的格子转移过来的。假设只有一个数组,当遍历到第 $i$ 行时,该数组存储的仍然是第 $i-1$ 行的状态,为了避免左边区域的格子在状态转移中被覆盖,我们应采取倒序遍历。
|
||||
那么,我们是否可以仅用一个数组实现状态压缩呢?观察可知,每个状态都是由左上方或正上方的格子转移过来的。假设只有一个数组,当遍历到第 $i$ 行时,该数组存储的仍然是第 $i-1$ 行的状态,**为了避免左方区域的格子在状态转移中被覆盖,应该采取倒序遍历**。
|
||||
|
||||
以下动画展示了在单个数组下从第 $i=1$ 行转换至第 $i=2$ 行的过程。建议你思考一下正序遍历和倒序遍历的区别。
|
||||
|
||||
|
@ -337,7 +341,7 @@ $$
|
|||
=== "<6>"
|
||||
![knapsack_dp_comp_step6](knapsack_problem.assets/knapsack_dp_comp_step6.png)
|
||||
|
||||
如以下代码所示,我们仅需将 `dp` 矩阵的第一维 $i$ 直接删除,并且将内循环修改为倒序遍历即可。
|
||||
如以下代码所示,我们仅需将数组 `dp` 的第一维 $i$ 直接删除,并且将内循环修改为倒序遍历即可。
|
||||
|
||||
=== "Java"
|
||||
|
||||
|
|