Update

README.md

@@ -394,6 +394,7 @@
 |[0977.有序数组的平方](https://github.com/youngyangyang04/leetcode/blob/master/problems/0977.有序数组的平方.md) |数组 |中等|**双指针** 还是比较巧妙的|
 |[1002.查找常用字符](https://github.com/youngyangyang04/leetcode/blob/master/problems/1002.查找常用字符.md) |栈 |简单|**栈**|
 |[1047.删除字符串中的所有相邻重复项](https://github.com/youngyangyang04/leetcode/blob/master/problems/1047.删除字符串中的所有相邻重复项.md) |哈希表 |简单|**哈希表/数组**|
+|[1365.有多少小于当前数字的数字](https://github.com/youngyangyang04/leetcode/blob/master/problems/1365.有多少小于当前数字的数字.md) |数组、哈希表 |简单|**哈希** 从后遍历的技巧很不错|
 |[1382.将二叉搜索树变平衡](https://github.com/youngyangyang04/leetcode/blob/master/problems/1047.删除字符串中的所有相邻重复项.md) |二叉搜索树 |中等|**递归** **迭代** 98和108的组合题目|
 |[剑指Offer05.替换空格](https://github.com/youngyangyang04/leetcode/blob/master/problems/剑指Offer05.替换空格.md) |字符串 |简单|**双指针**|
 |[ 剑指Offer58-I.翻转单词顺序](https://github.com/youngyangyang04/leetcode/blob/master/problems/剑指Offer05.替换空格.md) |字符串 |简单|**模拟/双指针**|

problems/0077.组合.md

@@ -72,7 +72,17 @@ for (int i = 1; i <= n; i++) {
 用的就是回溯搜索法，**可以发现，每次搜索到了叶子节点，我们就找到了一个结果**。
 
 
-**这份模板，大家可以要记住了，后面做回溯搜索的题目，都离不开这个模板**。 
+**一些同学对递归操作本来就不熟练，递归上面又加上一个for循环，直接晕倒！** 
+
+## 
+
+我再给大家捋顺一下。
+
+这个backtracking（递归函数）是从根节点向树的叶子节点方向遍历，**for循环可以理解是横向遍历，backtracking（递归）就是纵向遍历**，这样就把这棵树全遍历完了，如图所示：
+
+<img src='../pics/77.组合1.png' width=600> </img></div>
+
+backtracking一直往深处遍历，总会遇到叶子节点，遇到了叶子节点就要返回，那么backtracking的下面部分就是回溯的操作了，撤销本次处理的结果。
 
 ## 求组合
 

problems/1365.有多少小于当前数字的数字.md

@@ -0,0 +1,75 @@
+
+两层for循环暴力查找，时间复杂度明显为O(n^2)。 
+
+那么我们来看一下如何优化。
+
+首先要找小于当前数字的数字，那么从小到大排序之后，该数字之前的数字就都是比它小的了。
+
+所以可以定义一个新数组，将数组排个序。
+
+**排序之后，其实每一个数值的下标就代表这前面有几个比它小的了**。
+
+代码如下：
+
+```
+vector<int> vec = nums;
+sort(vec.begin(), vec.end()); // 从小到大排序之后，元素下标就是小于当前数字的数字
+```
+
+此时用一个哈希表hash（本题可以就用一个数组）来做数值和下标的映射。这样就可以通过数值快速知道下标（也就是前面有几个比它小的）。
+
+此时有一个情况，就是数值相同怎么办？
+
+例如，数组：1 2 3 4 4 4 ，第一个数值4的下标是3，第二个数值4的下标是4了。
+
+这里就需要一个技巧了，**在构造数组hash的时候，从后向前遍历，这样hash里存放的就是相同元素最左面的数值和下标了**。
+代码如下：
+
+```
+int hash[101];
+for (int i = vec.size() - 1; i >= 0; i--) { // 从后向前，记录 vec[i] 对应的下标
+    hash[vec[i]] = i;
+}
+```
+
+最后在遍历原数组nums，用hash快速找到每一个数值 对应的 小于这个数值的个数。存放在将结果存放在另一个数组中。
+
+代码如下：
+
+```
+// 此时hash里保存的每一个元素数值 对应的 小于这个数值的个数
+for (int i = 0; i < nums.size(); i++) {
+    vec[i] = hash[nums[i]];
+}
+```
+
+流程如图：
+
+
+<img src='../pics/1365.有多少小于当前数字的数字.png' width=600> </img></div>
+
+关键地方讲完了，整体C++代码如下：
+```
+class Solution {
+public:
+    vector<int> smallerNumbersThanCurrent(vector<int>& nums) {
+        vector<int> vec = nums;
+        sort(vec.begin(), vec.end()); // 从小到大排序之后，元素下标就是小于当前数字的数字
+        int hash[101];
+        for (int i = vec.size() - 1; i >= 0; i--) { // 从后向前，记录 vec[i] 对应的下标
+            hash[vec[i]] = i;
+        }
+        // 此时hash里保存的每一个元素数值 对应的 小于这个数值的个数
+        for (int i = 0; i < nums.size(); i++) {
+            vec[i] = hash[nums[i]];
+        }
+        return vec;
+    }
+};
+```
+可以排序之后加哈希，时间复杂度为O(nlogn)
+
+
+今天上午有事情，题解写的匆忙，下午我会继续完善题解。
+
+

problems/回溯算法理论基础.md

@@ -1,118 +1,157 @@
 
-> 
+> 今天开始正式回溯法的讲解，老规矩，先概述
 
 # 什么是回溯法 
+
 回溯法也可以叫做回溯搜索法，它是一种搜索的方式。 
 
 在二叉树系列中，我们已经不止一次，提到了回溯，例如[二叉树：以为使用了递归，其实还隐藏着回溯](https://mp.weixin.qq.com/s/ivLkHzWdhjQQD1rQWe6zWA)。
 
 回溯是递归的副产品，只要有递归就会有回溯。
 
-回溯法的性能如何呢，这里要很大家说清楚了，**虽然回溯法很难，很不好理解，但是回溯法并不是什么高效的算法**。
+**所以以下讲解中，回溯函数也就是递归函数，指的都是一个函数**。
 
 # 回溯法的效率
 
+回溯法的性能如何呢，这里要和大家说清楚了，**虽然回溯法很难，很不好理解，但是回溯法并不是什么高效的算法**。
+
 **因为回溯的本质是穷举，穷举所有可能，然后选出我们想要的答案**，如果想让回溯法高效一些，可以加一些剪枝的操作，但也改不了回溯法就是穷举的本质。
 
 那么既然回溯法并不高效为什么还要用它呢？ 
 
-因为没得选，一些问题只能暴力搜，没有更优的算法了。
+因为没得选，一些问题能暴力搜出来就不错了，撑死了再剪枝一下，还没有更高效的解法。
+
+此时大家应该好奇了，都什么问题，这么牛逼，只能暴力搜索。
 
 # 回溯法解决的问题 
 
+回溯法，一般可以解决如下几种问题：
+
+* 组合问题：N个数里面按一定规则找出k个数的集合
+* 排列问题：N个数按一定规则全排列，有几种排列方式
+* 切割问题：一个字符串按一定规则有几种切割方式
+* 子集问题：一个N个数的集合里有多少符合条件的子集
+* 棋盘问题：N皇后，解数独等等
+
+**相信大家看着这些之后会发现，每个问题，都不简单！**
 
 
-回溯算法，相信
+另外，会有一些同学可能分不清什么是组合，什么是排列？
 
-**回溯的问题都可以抽象为一个树形结构，在求解组合问题的过程中，n相当于树的宽度，k相当于树的深度**。
-
-# 题外话 
-
-一些同学可能分不清什么是组合，什么是排列？
-
-组合是不强调元素顺序的，排列是强调元素顺序的。
+**组合是不强调元素顺序的，排列是强调元素顺序**。
 
 例如：{1, 2} 和 {2, 1} 在组合上，就是一个集合，因为不强调顺序，而要是排列的话，{1, 2} 和 {2, 1} 就是两个集合了。
 
-## 回溯算法模板 
+记住组合无序，排列有序，就可以了。
 
-这里将给出Carl总结的回溯算法模板，那么先来讲一讲回溯算法的模板伪代码。
+# 如何理解回溯法
 
-既然回溯是递归的副产品，那么必然要有递归。
+**回溯法解决的问题都可以抽象为树形结构**，是的，我指的是所有回溯法的问题都可以抽象为树形结构！
 
-**所以以下讲解中，回溯函数也就是递归函数，指的都是一个函数**。
+因为回溯法解决的都是在集合中递归查找子集，**集合的大小就构成了树的宽度，递归的深度，都构成的树的深度**。
+
+递归就要有终止条件，所以必然是一颗高度有限的树（N叉树）。
+
+这块可能初学者还不太理解，后面的回溯算法解决的所有题目中，我都会强调这一点并画图举相应的例子，现在有一个印象就行。
+
+
+# 回溯法模板 
+
+这里给出Carl总结的回溯算法模板。
 
 在讲[二叉树的递归](https://mp.weixin.qq.com/s/PwVIfxDlT3kRgMASWAMGhA)中我们说了递归三部曲，这里我再给大家列出回溯三部曲。
 
 * 回溯函数模板返回值以及参数 
 
+在回溯算法中，我的习惯是函数起名字为backtracking，这个起名大家随意。
+
+回溯算法中函数返回值一般为void。 
+
+再来看一下参数，因为回溯算法需要的参数可不像二叉树递归的时候那么容易一次性确定下来，所以一般是先写逻辑，然后需要什么参数，就填什么参数。
+
+但后面的回溯题目的讲解中，为了方便大家理解，我在一开始就帮大家把参数确定下来。
+
 回溯函数伪代码如下：
 
 ```
-backtracking(参数) 
+void backtracking(参数) 
 ```
 
-在回溯算法中，我的习惯函数起名字为backtracking，回溯中递归返回值一般为void。 
-
-在来看一下参数，因为回溯算法需要的参数，可不像二叉树递归的时候那么容易一次性确定下来，所以一般是先写逻辑，需要什么参数，就填什么参数。
-
-但后面的回溯题目的讲解中，为了方便理解，我在一开始就帮大家把参数确定下来。
-
 * 回溯函数终止条件 
 
-回溯函数终止条件伪代码如下：
-```
-if (终止条件) {
-    存放结果;
-}
-```
-
 既然是树形结构，那么我们在讲解[二叉树的递归](https://mp.weixin.qq.com/s/PwVIfxDlT3kRgMASWAMGhA)的时候，就知道遍历树形结构一定要有终止条件。
 
 所以回溯也有要终止条件。
 
-什么时候达到了终止条件，树中就可以看出，搜到了叶子节点了，就找到了一个符合题目要求的答案，就把这个答案存放起来。
+什么时候达到了终止条件，树中就可以看出，一般来说搜到叶子节点了，也就找到了满足条件的一条答案，把这个答案存放起来，并结束本层递归。
 
+所以回溯函数终止条件伪代码如下：
+```
+if (终止条件) {
+    存放结果;
+    return;
+}
+```
 
 * 回溯搜索的遍历过程 
 
+在上面我们提到了，回溯法一般是在集合中递归搜索，集合的大小构成了树的宽度，递归的深度构成的树的深度。
+
+如图： 
+
+<img src='../pics/回溯算法理论基础.png' width=600> </img></div>
+
+注意图中，我特意举例集合大小和孩子的数量是相等的！
+
 回溯函数遍历过程伪代码如下：
 ```
-for (选择：选择列表（可以想成树中每个节点孩子的数量）) {
-    递归，处理节点;
-    backtracking(路径，选择列表);
+for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
+    处理节点;
+    backtracking(路径，选择列表); // 递归
     回溯，撤销处理结果
 }
 ```
 
-看一下这个for循环，这个for循环是做什么呢？
 
-for 就是处理树中每一个节点的各个孩子的情况， 一个节点有多少个孩子，这个for循环就执行多少次。
+for循环就是遍历集合区间，可以理解一个节点有多少个孩子，这个for循环就执行多少次。
 
-注意这个backtracking就是自己调用自己，实现递归。
+backtracking这里自己调用自己，实现递归。
 
-**一些同学对递归操作本来就不熟练，递归上面又加上一个for循环，可能就更迷糊了**， 我再给大家捋顺一下。
-
-这个backtracking（递归函数）是从根节点向树的叶子节点方向遍历，**for循环可以理解是横向遍历，backtracking（递归）就是纵向遍历**，这样就把这棵树全遍历完了，如图所示：
-
-<img src='../pics/77.组合1.png' width=600> </img></div>
-
-backtracking一直往深处遍历，总会遇到叶子节点，遇到了叶子节点就要返回，那么backtracking的下面部分就是回溯的操作了，撤销本次处理的结果。
+大家可以从图中看出**for循环可以理解是横向遍历，backtracking（递归）就是纵向遍历**，这样就把这棵树全遍历完了，一般来说，搜索叶子节点就是找的其中一个结果了。
 
 分析完过程，回溯算法模板框架如下：
 
 ```
-backtracking(参数) {
+void backtracking(参数) {
     if (终止条件) {
         存放结果;
+        return;
     }
 
-    for (选择：选择列表（可以想成树中每个节点孩子的数量）) {
-        递归，处理节点;
-        backtracking(路径，选择列表);
+    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
+        处理节点;
+        backtracking(路径，选择列表); // 递归
         回溯，撤销处理结果
     }
 }
 
 ```
 
+**这份模板很重要，后面做回溯法的题目都靠它了！** 
+
+如果从来没有学过回溯算法的录友们，看到这里会有点懵，后面开始讲解具体题目的时候就会好一些了，已经做过回溯法题目的录友，看到这里应该会感同身受了。
+
+# 总结
+
+本篇我们讲解了，什么是回溯算法，知道了回溯和递归是相辅相成的。
+
+接着提到了回溯法的效率，回溯法其实就是暴力查找，并不是什么高效的算法。
+
+然后列出了回溯法可以解决几类问题，可以看出每一类问题都不简单。
+
+最后我们讲到回溯法解决的问题都可以抽象为树形结构（N叉树），并给出了回溯法的模板。
+
+今天是回溯算法的第一天，按照惯例Carl都是先概述一波，然后在开始讲解具体题目，没有接触过回溯法的同学刚学起来有点看不懂很正常，后面和具体题目结合起来会好一些。
+
+
+