Update

Author: youngyangyang04

README.md

@@ -148,6 +148,8 @@
     * [回溯算法：排列问题！](https://mp.weixin.qq.com/s/SCOjeMX1t41wcvJq49GhMw)
     * [回溯算法：排列问题（二）](https://mp.weixin.qq.com/s/9L8h3WqRP_h8LLWNT34YlA)
     * [本周小结！（回溯算法系列三）](https://mp.weixin.qq.com/s/tLkt9PSo42X60w8i94ViiA)
+    * [本周小结！（回溯算法系列三）续集](https://mp.weixin.qq.com/s/kSMGHc_YpsqL2j-jb_E_Ag)
+    * [视频来了！！带你学透回溯算法（理论篇）](https://mp.weixin.qq.com/s/wDd5azGIYWjbU0fdua_qBg)
 
 
 （持续更新中....）
@@ -388,6 +390,7 @@
 |[0350.两个数组的交集II](https://github.com/youngyangyang04/leetcode/blob/master/problems/0350.两个数组的交集II.md) |哈希表 |简单|**哈希**|
 |[0383.赎金信](https://github.com/youngyangyang04/leetcode/blob/master/problems/0383.赎金信.md) |数组 |简单|**暴力** **字典计数** **哈希**|
 |[0404.左叶子之和](https://github.com/youngyangyang04/leetcode/blob/master/problems/0404.左叶子之和.md) |树/二叉树 |简单|**递归** **迭代**|
+|[0406.根据身高重建队列](https://github.com/youngyangyang04/leetcode/blob/master/problems/0406.根据身高重建队列.md) |树/二叉树 |简单|**递归** **迭代**|
 |[0416.分割等和子集](https://github.com/youngyangyang04/leetcode/blob/master/problems/0416.分割等和子集.md) |动态规划 |中等|**背包问题/01背包**|
 |[0429.N叉树的层序遍历](https://github.com/youngyangyang04/leetcode/blob/master/problems/0429.N叉树的层序遍历.md) |树 |简单|**队列/广度优先搜索**|
 |[0434.字符串中的单词数](https://github.com/youngyangyang04/leetcode/blob/master/problems/0434.字符串中的单词数.md) |字符串 |简单|**模拟**|

pics/135.分发糖果.png

@@ -320,7 +320,7 @@ void getNext(int* next, const string& s){
 
 在文本串s里 找是否出现过模式串t。
 
-定义两个下表j 指向模式串起始位置，i指向文本串其实位置。
+定义两个下表j 指向模式串起始位置，i指向文本串起始位置。
 
 那么j初始值依然为-1，为什么呢？ **依然因为next数组里记录的起始位置为-1。**
 

pics/135.分发糖果1.png

@@ -1,9 +1,12 @@
+> 开始棋盘问题，如果对回溯法还不了解的同学可以看这个视频
 
-# 题目链接 
+如果对回溯法理论还不清楚的同学，可以先看这个视频[视频来了！！带你学透回溯算法（理论篇）](https://mp.weixin.qq.com/s/wDd5azGIYWjbU0fdua_qBg)
 
-https://leetcode-cn.com/problems/n-queens/ 
 
 # 第51题. N皇后
+
+题目链接： https://leetcode-cn.com/problems/n-queens/ 
+
 n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。 
 
 上图为 8 皇后问题的一种解法。
@@ -14,86 +17,168 @@ n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并
 每一种解法包含一个明确的 n 皇后问题的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。
 
 示例:
-
-输入: 4
-输出: [
- [".Q..",  // 解法 1
-  "...Q",
-  "Q...",
-  "..Q."],
-
- ["..Q.",  // 解法 2
-  "Q...",
-  "...Q",
-  ".Q.."]
-]
-解释: 4 皇后问题存在两个不同的解法。
-
-提示：
-
+输入: 4    
+输出: [   
+ [".Q..",  // 解法 1   
+  "...Q",    
+  "Q...",   
+  "..Q."],   
+     
+ ["..Q.",  // 解法 2    
+  "Q...",    
+  "...Q",   
+  ".Q.."]   
+]   
+解释: 4 皇后问题存在两个不同的解法。    
+    
+提示：    
 > 皇后，是国际象棋中的棋子，意味着国王的妻子。皇后只做一件事，那就是“吃子”。当她遇见可以吃的棋子时，就迅速冲上去吃掉棋子。当然，她横、竖、斜都可走一到七步，可进可退。（引用自 百度百科 - 皇后 ）
 
 
 # 思路
 
-都知道n皇后问题是回溯算法解决的经典问题，但是用回溯解决多了 排列，组合，子集问题之后，遇到这种二位矩阵还会有点不知所措。
+都知道n皇后问题是回溯算法解决的经典问题，但是用回溯解决多了组合、切割、子集、排列问题之后，遇到这种二位矩阵还会有点不知所措。
 
 首先来看一下皇后们的约束条件：
 
 1. 不能同行
 2. 不能同列 
 3. 不能同斜线
 
-
 确定完约束条件，来看看究竟要怎么去搜索皇后们的位置，其实搜索皇后的位置，可以抽象为一棵树。
 
-下面我用一个3 * 3 的棋牌，如图：
+下面我用一个3 * 3 的棋牌，将搜索过程抽象为一颗树，如图：
 
-<img src='../pics/51.N皇后1.png' width=600> </img></div>
+![51.N皇后](https://img-blog.csdnimg.cn/20201116173551789.png)
 
-将搜索过程抽象为一颗树，如图：
+从图中，可以看出，二维矩阵中矩阵的高就是这颗树的高度，矩阵的宽就是树形结构中每一个节点的宽度。
 
+那么我们用皇后们的约束条件，来回溯搜索这颗树，**只要搜索到了树的叶子节点，说明就找到了皇后们的合理位置了**。 
 
-<img src='../pics/51.N皇后.png' width=600> </img></div>
+## 回溯三部曲 
 
-从图中，可以看出，二维矩阵，其实矩阵的行，就是 这颗树的高度，矩阵的宽就是二叉树没一个节点孩子的宽度。
+按照我总结的如下回溯模板，我们来依次分析：
 
+```
+void backtracking(参数) {
+    if (终止条件) {
+        存放结果;
+        return;
+    }
+    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
+        处理节点;
+        backtracking(路径，选择列表); // 递归
+        回溯，撤销处理结果
+    }
+}
+```
+
+* 递归函数参数 
 
-那么我们用皇后们的约束条件，来回溯搜索这颗二叉树，**只要搜索到了树的叶子节点，说明就找到了皇后们的合理位置了。** 
+我依然是定义全局变量二维数组result来记录最终结果。
 
-我总结的回溯模板如下：
+参数n是棋牌的大小，然后用row来记录当前遍历到棋盘的第几层了。 
+
+代码如下：
 
 ```
-backtracking() {
-    if (终止条件) {
-        存放结果;
+vector<vector<string>> result;
+void backtracking(int n, int row, vector<string>& chessboard) {
+```
+
+* 递归终止条件 
+
+在如下树形结构中：
+![51.N皇后](https://img-blog.csdnimg.cn/20201116173551789.png)
+
+可以看出，当递归到棋盘最底层（也就是叶子节点）的时候，就可以收集结果并返回了。
+
+代码如下：
+
+```
+if (row == n) {
+    result.push_back(chessboard);
+    return;
+}
+```
+
+* 单层搜索的逻辑 
+
+递归深度就是row控制棋盘的行，每一层里for循环的col控制棋盘的列，一行一列，确定了放置皇后的位置。 
+
+每次都是要从新的一行的起始位置开始搜，所以都是从0开始。
+
+代码如下：
+
+```
+for (int col = 0; col < n; col++) {
+    if (isValid(row, col, chessboard, n)) { // 验证合法就可以放
+        chessboard[row][col] = 'Q'; // 放置皇后
+        backtracking(n, row + 1, chessboard);
+        chessboard[row][col] = '.'; // 回溯，撤销皇后
     }
+}
+```
 
-    for (枚举同一个位置的所有可能性，可以想成节点孩子的数量) {
-        递归，处理节点;
-        backtracking();
-        回溯，撤销处理结果
+* 验证棋牌是否合法
+
+按照如下标准去重：
+
+1. 不能同行
+2. 不能同列 
+3. 不能同斜线 （45度和135度角）
+
+代码如下： 
+
+```
+bool isValid(int row, int col, vector<string>& chessboard, int n) {
+    int count = 0;
+    // 检查列
+    for (int i = 0; i < row; i++) { // 这是一个剪枝
+        if (chessboard[i][col] == 'Q') {
+            return false;
+        }
+    }
+    // 检查 45度角是否有皇后
+    for (int i = row - 1, j = col - 1; i >=0 && j >= 0; i--, j--) {
+        if (chessboard[i][j] == 'Q') {
+            return false;
+        }
+    }
+    // 检查 135度角是否有皇后
+    for(int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
+        if (chessboard[i][j] == 'Q') {
+            return false;
+        }
     }
+    return true;
 }
 ```
 
-那么按照这个模板不能写出如下代码：
+在这份代码中，细心的同学可以发现为什么没有在同行进行检查呢？ 
+
+因为在单层搜索的过程中，每一层递归，只会选for循环（也就是同一行）里的一个元素，所以不用去重了。
+
+那么按照这个模板不难写出如下代码：
 
-# C++代码
+## C++代码
 
 ```
 class Solution {
 private:
-void backtracking(int n, int row, vector<string>& chessboard, vector<vector<string>>& result) {
+vector<vector<string>> result;
+// n 为输入的棋盘大小
+// row 是当前递归到棋牌的第几行了
+void backtracking(int n, int row, vector<string>& chessboard) {
     if (row == n) {
         result.push_back(chessboard);
         return;
     }
     for (int col = 0; col < n; col++) {
-        if (isValid(row, col, chessboard, n)) {
-            chessboard[row][col] = 'Q';
-            backtracking(n, row + 1, chessboard, result);
-            chessboard[row][col] = '.';
+        if (isValid(row, col, chessboard, n)) { // 验证合法就可以放
+            chessboard[row][col] = 'Q'; // 放置皇后
+            backtracking(n, row + 1, chessboard);
+            chessboard[row][col] = '.'; // 回溯，撤销皇后
         }
     }
 }
@@ -121,11 +206,25 @@ bool isValid(int row, int col, vector<string>& chessboard, int n) {
 }
 public:
     vector<vector<string>> solveNQueens(int n) {
+        result.clear();
         std::vector<std::string> chessboard(n, std::string(n, '.'));
-        vector<vector<string>> result;
-
-        backtracking(n, 0, chessboard, result);
+        backtracking(n, 0, chessboard);
         return result;
     }
 };
 ```
+
+可以看出，除了验证棋盘合法性的代码，省下来部分就是按照回溯法模板来的。
+
+# 总结 
+
+本题是我们解决棋盘问题的第一道题目。
+
+如果从来没有接触过N皇后问题的同学看着这样的题会感觉无从下手，可能知道要用回溯法，但也不知道该怎么去搜。
+
+**这里我明确给出了棋盘的宽度就是for循环的长度，递归的深度就是棋盘的高度，这样就可以套进回溯法的模板里了**。
+
+大家可以在仔细体会体会！
+
+就酱，如果感觉「代码随想录」干货满满，就分享给身边的朋友同学吧，他们可能也需要！
+

pics/406.根据身高重建队列.png

@@ -49,7 +49,7 @@ public:
 
 <img src='../video/53.最大子序和.gif' width=600> </img></div>
 
-红色的其实位置就是贪心每次取count为正数的时候，开始一个区间的统计。
+红色的起始位置就是贪心每次取count为正数的时候，开始一个区间的统计。
 
 不难写出如下C++代码（关键地方已经注释）
 

pics/51.N皇后.png

@@ -1,27 +1,85 @@
 
+## 思路 
+
+这道题目一定是要确定一边之后，再确定另一边，例如比较每一个孩子的左边，然后再比较右边，如果两边一起考虑就会顾此失彼。
+
+本题贪心贪在哪里呢？ 
+
+先确定每个孩子左边的情况（也就是从前向后遍历）
+
+如果ratings[i] > ratings[i - 1] 那么[i]的糖 一定要比[i - 1]的糖多一个，所以贪心：candyVec[i] = candyVec[i - 1] + 1 
+
+代码如下：
+
+```
+// 从前向后 
+for (int i = 1; i < ratings.size(); i++) {
+    if (ratings[i] > ratings[i - 1]) candyVec[i] = candyVec[i - 1] + 1;
+}
+```
+
+如图：
+
+![135.分发糖果](https://img-blog.csdnimg.cn/20201117114916878.png)
+
+再确定每个孩子右边的情况（从后向前遍历） 
+
+遍历顺序这里有同学可能会有疑问，为什么不能从前向后遍历呢？ 
+
+因为如果从前向后遍历，根据 ratings[i + 1] 来确定 ratings[i] 对应的糖果，那么每次都不能利用上前一次的比较结果了。 
+**所以确定每个孩子右边的情况一定要从后向前遍历！** 
+
+此时又要开始贪心，如果 ratings[i] > ratings[i + 1]，就取candyVec[i + 1] + 1 和 candyVec[i] 最大的糖果数量，**因为candyVec[i]只有取最大的才能既保持对左边candyVec[i - 1]的糖果多，也比右边candyVec[i + 1]的糖果多**。
+
+如图：
+
+![135.分发糖果1](https://img-blog.csdnimg.cn/20201117115658791.png)
+
+所以代码如下：
+
+```
+// 从后向前
+for (int i = ratings.size() - 2; i >= 0; i--) {
+    if (ratings[i] > ratings[i + 1] ) {
+        candyVec[i] = max(candyVec[i], candyVec[i + 1] + 1);
+    }
+}
+```
+
+* 将问题分解为若干个子问题
+* 找出适合的贪心策略
+* 求解每一个子问题的最优解
+* 将局部最优解堆叠成全局最优解
+
+* 分解为子问题 
+
+
+
 这道题目上来也是没什么思路啊
 
 
 这道题目不好想啊，贪心很巧妙
+
 ```
 class Solution {
 public:
     int candy(vector<int>& ratings) {
         vector<int> candyVec(ratings.size(), 1);
-        // 从前向后 
+        // 从前向后
         for (int i = 1; i < ratings.size(); i++) {
             if (ratings[i] > ratings[i - 1]) candyVec[i] = candyVec[i - 1] + 1;
         }
         // 从后向前
         for (int i = ratings.size() - 2; i >= 0; i--) {
-            if (ratings[i] > ratings[i + 1] && candyVec[i] < candyVec[i + 1] + 1) {
-                candyVec[i] = candyVec[i + 1] + 1;
+            if (ratings[i] > ratings[i + 1] ) {
+                candyVec[i] = max(candyVec[i], candyVec[i + 1] + 1);
             }
         }
-        // 统计结果 
+        // 统计结果
         int result = 0;
         for (int i = 0; i < candyVec.size(); i++) result += candyVec[i];
         return result;
     }
 };
+
 ```

problems/0028.实现strStr().md

@@ -172,7 +172,7 @@ if (result.size() == ticketNum + 1) {
         if (target.second > 0 ) { // 记录到达机场是否飞过了
             result.push_back(target.first);
             target.second--;
-            if (backtracking(ticketNum, index + 1, result)) return true;
+            if (backtracking(ticketNum, result)) return true;
             result.pop_back();
             target.second++;
         }