diff --git a/README.md b/README.md
index d74d5e91..f75138b9 100644
--- a/README.md
+++ b/README.md
@@ -126,6 +126,8 @@
* [二叉树:搜索树转成累加树](https://mp.weixin.qq.com/s/hZtJh4T5lIGBarY-lZJf6Q)
* [二叉树:总结篇!(需要掌握的二叉树技能都在这里了)](https://mp.weixin.qq.com/s/-ZJn3jJVdF683ap90yIj4Q)
+* 回溯算法
+ * [关于回溯算法,你该了解这些!](https://mp.weixin.qq.com/s/gjSgJbNbd1eAA5WkA-HeWw)
(持续更新中....)
diff --git a/problems/0077.组合.md b/problems/0077.组合.md
index b3aeb25c..74b0d95a 100644
--- a/problems/0077.组合.md
+++ b/problems/0077.组合.md
@@ -1,47 +1,49 @@
+> 回溯法的第一道题目,就不简单呀!
+
# 第77题. 组合
题目链接:https://leetcode-cn.com/problems/combinations/
-给定两个整数 n 和 k,返回 1 ... n 中所有可能的 k 个数的组合。
-示例:
-
-输入: n = 4, k = 2
-输出:
-[
- [2,4],
- [3,4],
- [2,3],
- [1,2],
- [1,3],
- [1,4],
-]
+给定两个整数 n 和 k,返回 1 ... n 中所有可能的 k 个数的组合。
+示例:
+输入: n = 4, k = 2
+输出:
+[
+ [2,4],
+ [3,4],
+ [2,3],
+ [1,2],
+ [1,3],
+ [1,4],
+]
# 思路
-这是回溯法的经典题目。
+本题这是回溯法的经典题目。
-直觉上当然是使用for循环,例如示例中k为2,很容易想到 用两个for循环,这样就可以输出 和示例中一样的结果。
+直接的解法当然是使用for循环,例如示例中k为2,很容易想到 用两个for循环,这样就可以输出 和示例中一样的结果。
代码如下:
```
- int n = 4;
- for (int i = 1; i <= n; i++) {
- for (int j = i + 1; j <= n; j++) {
- cout << i << " " << j << endl;
- }
+int n = 4;
+for (int i = 1; i <= n; i++) {
+ for (int j = i + 1; j <= n; j++) {
+ cout << i << " " << j << endl;
}
+}
```
输入:n = 100, k = 3
那么就三层for循环,代码如下:
```
+int n = 100;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
- for (int u = j + 1; u <=n; n++) {
-
+ for (int u = j + 1; u <= n; n++) {
+ cout << i << " " << j << " " << u << endl;
}
}
}
@@ -49,46 +51,50 @@ for (int i = 1; i <= n; i++) {
**如果n为100,k为50呢,那就50层for循环,是不是开始窒息**。
-那么回溯法就能解决这个问题了。
+**此时就会发现虽然想暴力搜索,但是用for循环嵌套连暴力都写不出来!**
-回溯是用来做选择,递归用来做节点层叠嵌套(可以理解是随便开K的for循环),**每一次的递归相当于嵌套一个for循环,可以用于解决多层嵌套循环的问题了**。
+咋整?
-**回溯问题都可以抽象为一棵树形结构!用树形结构来理解回溯就容易多了**。
+回溯搜索法来了,虽然回溯法也是暴力,但至少能写出来,不像for循环嵌套k层让人绝望。
-那么我们把组合问题抽象为如下树形结构:
+那么回溯法怎么暴力搜呢?
+
+上面我们说了**要解决 n为100,k为50的情况,暴力写法需要嵌套50层for循环,那么回溯法就用递归来解决嵌套层数的问题**。
+
+递归来做层叠嵌套(可以理解是开k层for循环),**每一次的递归中嵌套一个for循环,那么递归就可以用于解决多层嵌套循环的问题了**。
+
+此时递归的层数大家应该知道了,例如:n为100,k为50的情况下,就是递归50层。
+
+一些同学本来对递归就懵,回溯法中递归还要嵌套for循环,可能就直接晕倒了!
+
+如果脑洞模拟回溯搜索的过程,绝对可以让人窒息,所以需要抽象图形结构来进一步理解。
+
+**我们在[关于回溯算法,你该了解这些!](https://mp.weixin.qq.com/s/gjSgJbNbd1eAA5WkA-HeWw)中说道回溯法解决的问题都可以抽象为树形结构(N叉树),用树形结构来理解回溯就容易多了**。
+
+那么我把组合问题抽象为如下树形结构:
可以看出这个棵树,一开始集合是 1,2,3,4, 从左向右取数,取过的数,不在重复取。
-第一次取1,集合变为2,3,4 ,因为k为2,我们只需要再取一个数就可以了,分别取,2,3,4, 得到集合[1,2] [1,3] [1,4],以此类推。
+第一次取1,集合变为2,3,4 ,因为k为2,我们只需要再取一个数就可以了,分别取2,3,4,得到集合[1,2] [1,3] [1,4],以此类推。
-**回溯的问题都可以抽象为一个树形结构,在求解组合问题的过程中,n相当于树的宽度,k相当于树的深度**。
+**每次从集合中选取元素,可选择的范围随着选择的进行而收缩,调整可选择的范围**。
-**每次从集合中选组元素,可选择的范围随着选择的进行而限缩,调整可选择的范围**
+**图中可以发现n相当于树的宽度,k相当于树的深度**。
-如何在这个树上遍历,然后收集到我们要的结果集呢?
+那么如何在这个树上遍历,然后收集到我们要的结果集呢?
-用的就是回溯搜索法,**可以发现,每次搜索到了叶子节点,我们就找到了一个结果**。
+**图中每次搜索到了叶子节点,我们就找到了一个结果**。
+
+相当于只需要把达到叶子节点的结果收集起来,就可以求得 n个数中k个数的组合集合。
+
+在[关于回溯算法,你该了解这些!](https://mp.weixin.qq.com/s/gjSgJbNbd1eAA5WkA-HeWw)中我们提到了回溯法三部曲,那么我们按照回溯法三部曲开始正式讲解代码了。
-**一些同学对递归操作本来就不熟练,递归上面又加上一个for循环,直接晕倒!**
+## 回溯法三部曲
-##
-
-我再给大家捋顺一下。
-
-这个backtracking(递归函数)是从根节点向树的叶子节点方向遍历,**for循环可以理解是横向遍历,backtracking(递归)就是纵向遍历**,这样就把这棵树全遍历完了,如图所示:
-
-
-
-backtracking一直往深处遍历,总会遇到叶子节点,遇到了叶子节点就要返回,那么backtracking的下面部分就是回溯的操作了,撤销本次处理的结果。
-
-## 求组合
-
-掌握了模板之后,我们再来看一下这道求组合的题目。
-
-* 回溯函数返回值以及参数
+* 递归函数的返回值以及参数
在这里要定义两个全局变量,一个用来存放符合条件单一结果,一个用来存放符合条件结果的集合。
@@ -99,14 +105,16 @@ vector> result; // 存放符合条件结果的集合
vector path; // 用来存放符合条件结果
```
-其实不定义这两个全局遍历也是可以的,把这两个变量放进回溯函数的参数里,但为了函数里参数太多影响可读性,所以我定义全局变量。
+其实不定义这两个全局遍历也是可以的,把这两个变量放进递归函数的参数里,但函数里参数太多影响可读性,所以我定义全局变量了。
-首先两个参数,集合n里面取k的数,是两个int型的变量。
+函数里一定有两个参数,既然是集合n里面取k的数,那么n和k是两个int型的参数。
-然后还需要一个参数,也为int型变量startIndex,这个参数用来记录本层递归的中,集合从哪里开始遍历(集合就是[1,...,n] )。
+然后还需要一个参数,为int型变量startIndex,这个参数用来记录本层递归的中,集合从哪里开始遍历(集合就是[1,...,n] )。
为什么要有这个startIndex呢?
+**每次从集合中选取元素,可选择的范围随着选择的进行而收缩,调整可选择的范围,就是要靠startIndex**。
+
从下图中红线部分可以看出,在集合[1,2,3,4]取1之后,下一层递归,就要在[2,3,4]中取数了,那么下一层递归如何知道从[2,3,4]中取数呢,靠的就是startIndex。
@@ -125,7 +133,7 @@ void backtracking(int n, int k, int startIndex)
什么时候到达所谓的叶子节点了呢?
-就是path这个数组的大小如果达到k,说明我们找到了一个集合大小为k的组合了,在图中path存的就是根节点到叶子节点的路径。
+path这个数组的大小如果达到k,说明我们找到了一个子集大小为k的组合了,在图中path存的就是根节点到叶子节点的路径。
如图红色部分:
@@ -142,26 +150,30 @@ if (path.size() == k) {
}
```
+* 单层搜索的过程
-* 回溯搜索的遍历过程
+回溯法的搜索过程就是一个树型结构的遍历过程,在如下图中,可以看出for循环用来横向遍历,递归的过程是纵向遍历。
-在如下如中,我们知道for循环用来横向遍历,递归的过程是纵向遍历。
如此我们才遍历完图中的这棵树。
-那么for循环每次就是从startIndex开始遍历,然后用path保存每次遍历到的节点。
+for循环每次从startIndex开始遍历,然后用path保存取到的节点i。
代码如下:
```
-for (int i = startIndex; i <= n; i++) {
+for (int i = startIndex; i <= n; i++) { // 控制树的横向遍历
path.push_back(i); // 处理节点
- backtracking(n, k, i + 1); // 注意下一层搜索要从i+1开始
+ backtracking(n, k, i + 1); // 递归:控制树的纵向遍历,注意下一层搜索要从i+1开始
path.pop_back(); // 回溯,撤销处理的节点
}
```
+可以看出backtracking(递归函数)通过不断调用自己一直往深处遍历,总会遇到叶子节点,遇到了叶子节点就要返回。
+
+backtracking的下面部分就是回溯的操作了,撤销本次处理的结果。
+
关键地方都讲完了,组合问题C++完整代码如下:
@@ -177,71 +189,51 @@ private:
}
for (int i = startIndex; i <= n; i++) {
path.push_back(i); // 处理节点
- backtracking(n, k, i + 1);
+ backtracking(n, k, i + 1); // 递归
path.pop_back(); // 回溯,撤销处理的节点
}
}
public:
vector> combine(int n, int k) {
- result.clear(); // 可以不写
- path.clear(); // 可以不写
+ result.clear(); // 可以不写
+ path.clear(); // 可以不写
backtracking(n, k, 1);
return result;
}
};
```
-## 剪枝优化
-
-在遍历的过程中如下代码 :
+还记得我们在[关于回溯算法,你该了解这些!](https://mp.weixin.qq.com/s/gjSgJbNbd1eAA5WkA-HeWw)中给出的回溯法模板么?
+如下:
```
-for (int i = startIndex; i <= n; i++)
-```
-
-这个遍历的范围是可以剪枝优化的,怎么优化呢?
-
-来举一个例子,n = 4, k = 4的话,那么从2开始的遍历都没有意义了。
-
-已经选择的元素个数:path.size();
-
-要选择的元素个数 : k - path.size();
-
-在集合n中开始选择的起始位置 : n - (k - path.size());
-
-因为起始位置是从1开始的,而且代码里是n <= 起始位置,所以 集合n中开始选择的起始位置 : n - (k - path.size()) + 1;
-
-所以优化之后是:
-
-```
-for (int i = startIndex; i <= n - (k - path.size()) + 1; i++)
-```
-
-优化后整体代码如下:
-
-```
-class Solution {
-private:
- vector> result; // 存放符合条件结果的集合
- vector path; // 用来存放符合条件结果
- void backtracking(int n, int k, int startIndex) {
- if (path.size() == k) {
- result.push_back(path);
- return;
- }
- for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) {
- path.push_back(i); // 处理节点
- backtracking(n, k, i + 1);
- path.pop_back(); // 回溯,撤销处理的节点
- }
+void backtracking(参数) {
+ if (终止条件) {
+ 存放结果;
+ return;
}
-public:
- vector> combine(int n, int k) {
- backtracking(n, k, 1);
- return result;
+ for (选择:本层集合中元素(树中节点孩子的数量就是集合的大小)) {
+ 处理节点;
+ backtracking(路径,选择列表); // 递归
+ 回溯,撤销处理结果
}
-};
+}
```
+**对比一下本题的代码,是不是发现有点像!** 所以有了这个模板,就有解题的大体方向,不至于毫无头绪。
+
+# 总结
+
+组合问题是回溯法解决的经典问题,我们开始的时候给大家列举一个很形象的例子,就是n为100,k为50的话,直接想法就需要50层for循环。
+
+从而引出了回溯法就是解决这种k层for循环嵌套的问题。
+
+然后进一步把回溯法的搜索过程抽象为树形结构,可以直观的看出搜索的过程。
+
+接着用回溯法三部曲,逐步分析了函数参数、终止条件和单层搜索的过程。
+
+**本题其实是可以剪枝优化的,大家可以思考一下,具体如何剪枝我会在下一篇详细讲解,敬请期待!**
+
+**就酱,如果对你有帮助,就帮Carl转发一下吧,让更多的同学发现这里!**
diff --git a/problems/0077.组合优化.md b/problems/0077.组合优化.md
new file mode 100644
index 00000000..8d9a1ed6
--- /dev/null
+++ b/problems/0077.组合优化.md
@@ -0,0 +1,59 @@
+
+## 剪枝优化
+
+我们说过,回溯法虽然是暴力搜索,但也有时候可以有点剪枝优化一下的。
+
+在遍历的过程中有如下代码 :
+
+```
+for (int i = startIndex; i <= n; i++)
+```
+
+这个遍历的范围是可以剪枝优化的,怎么优化呢?
+
+来举一个例子,n = 4, k = 4的话,那么从2开始的遍历都没有意义了。
+
+所以,可以优化递归中每一层中for循环搜索的起始位置。
+
+优化过程如下:
+
+1. 已经选择的元素个数:path.size();
+
+2. 要选择的元素个数 : k - path.size();
+
+3. 在集合n中开始选择的起始位置 : n - (k - path.size());
+
+因为起始位置是从1开始的,而且代码里是n <= 起始位置,所以 集合n中开始选择的起始位置 : n - (k - path.size()) + 1;
+
+所以优化之后是:
+
+```
+for (int i = startIndex; i <= n - (k - path.size()) + 1; i++)
+```
+
+优化后整体代码如下:
+
+```
+class Solution {
+private:
+ vector> result; // 存放符合条件结果的集合
+ vector path; // 用来存放符合条件结果
+ void backtracking(int n, int k, int startIndex) {
+ if (path.size() == k) {
+ result.push_back(path);
+ return;
+ }
+ for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) {
+ path.push_back(i); // 处理节点
+ backtracking(n, k, i + 1);
+ path.pop_back(); // 回溯,撤销处理的节点
+ }
+ }
+public:
+
+ vector> combine(int n, int k) {
+ backtracking(n, k, 1);
+ return result;
+ }
+};
+```
diff --git a/problems/算法模板.md b/problems/算法模板.md
index 2656e62f..60046b68 100644
--- a/problems/算法模板.md
+++ b/problems/算法模板.md
@@ -222,16 +222,16 @@ int countNodes(TreeNode* root) {
```
## 回溯算法
-
```
-backtracking() {
+void backtracking(参数) {
if (终止条件) {
存放结果;
+ return;
}
- for (选择:选择列表(可以想成树中节点孩子的数量)) {
- 递归,处理节点;
- backtracking();
+ for (选择:本层集合中元素(树中节点孩子的数量就是集合的大小)) {
+ 处理节点;
+ backtracking(路径,选择列表); // 递归
回溯,撤销处理结果
}
}