Update

Author: youngyangyang04

README.md

@@ -14,6 +14,8 @@
 
 # 算法文章精选
 
+**提示：在电脑端看如下文章的，看不到文章的评论区，建议在手机端「代码随想录」公众号里也翻一下对应的文章，评论区有录友们的打卡总结，相信会和你有不少共鸣！**
+
 * 编程语言
     * [C++面试&C++学习指南知识点整理](https://github.com/youngyangyang04/TechCPP)
 
@@ -414,17 +416,16 @@
 
 大家好，我是程序员Carl，哈工大师兄，ACM 校赛、黑龙江省赛、东北四省赛金牌、亚洲区域赛铜牌获得者，先后在腾讯和百度从事后端技术研发，CSDN博客专家。对算法和C++后端技术有一定的见解，利用工作之余重新刷leetcode。 
 
-**加我的微信，备注：「个人简单介绍」+「组队刷题」**， 拉你进刷题群，每天一道经典题目分析，而且题目不是孤立的，每一道题目之间都是有关系的，都是由浅入深一脉相承的，所以学习效果最好是每篇连续着看，也许之前你会某些知识点，但是一直没有把知识点串起来，这里每天一篇文章就会帮你把知识点串起来。我也花了不少精力来整理我的题解，**而且我不会在群里发任何广告，纯自己学习和分享。 欢迎你的加入！**
+**加我的微信，备注：「个人简单介绍」+「组队刷题」**， 拉你进刷题群，每天一道经典题目分析，而且题目不是孤立的，每一道题目之间都是有关系的，都是由浅入深一脉相承的，所以学习效果最好是每篇连续着看，也许之前你会某些知识点，但是一直没有把知识点串起来，这里每天一篇文章就会帮你把知识点串起来。
 
 <a name="微信"></a>
 <img src="https://img-blog.csdnimg.cn/20200814140330894.png" data-img="1" width="175" height="175">
 
 # 我的公众号
 
+更多精彩文章持续更新，微信搜索：「代码随想录」第一时间围观，关注后回复：「简历模板」「java」「C++」「python」等关键字就可以获得我多年整理出来的学习资料。
 
-更多精彩文章持续更新，微信搜索：「代码随想录」第一时间围观，关注后回复： 「简历模板」「java」「C++」「python」「算法与数据结构」 等关键字就可以获得我多年整理出来的学习资料。
-
-**每天8：35准时为你推送一篇经典面试题目，帮你梳理算法知识体系，轻松学习算法！**，并且公众号里有大量学习资源，也有我自己的学习心得和方法总结，相信你一定会有所收获！
+**每天8：35准时为你推送一篇经典面试题目，帮你梳理算法知识体系，轻松学习算法！**，并且公众号里有大量学习资源，也有我自己的学习心得和方法总结，更有很多志同道合的好伙伴在这里打卡学习，来看看就你知道了，相信一定会有所收获！
 
 <a name="公众号"></a>
 

pics/216.组合总和III.png

@@ -237,3 +237,5 @@ void backtracking(参数) {
 
 **就酱，如果对你有帮助，就帮Carl转发一下吧，让更多的同学发现这里！**
 
+
+**[本题剪枝操作文章链接](https://mp.weixin.qq.com/s/Ri7spcJMUmph4c6XjPWXQA)**

pics/216.组合总和III1.png

@@ -1,84 +1,217 @@
-# 第216题. 组合总和 III
-找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。
+## 链接
+https://leetcode-cn.com/problems/combination-sum-iii/ 
+
+> 别看本篇选的是组合总和III，而不是组合总和，本题和上一篇[回溯算法：求组合问题！](https://mp.weixin.qq.com/s/OnBjbLzuipWz_u4QfmgcqQ)相比难度刚刚好！
 
-说明：
+# 第216题.组合总和III
 
-所有数字都是正整数。
-解集不能包含重复的组合。 
+链接：https://leetcode-cn.com/problems/combination-sum-iii/
 
-示例 1:
+找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。
 
-输入: k = 3, n = 7
-输出: [[1,2,4]]
-示例 2:
+说明：  
+* 所有数字都是正整数。
+* 解集不能包含重复的组合。 
 
-输入: k = 3, n = 9
-输出: [[1,2,6], [1,3,5], [2,3,4]]
+示例 1:   
+输入: k = 3, n = 7   
+输出: [[1,2,4]]   
+
+示例 2:     
+输入: k = 3, n = 9   
+输出: [[1,2,6], [1,3,5], [2,3,4]]   
 
 
 # 思路 
 
-这道题目注意一下几点：
+本题就是在[1,2,3,4,5,6,7,8,9]这个集合中找到和为n的k个数的组合。  
+
+相对于[回溯算法：求组合问题！](https://mp.weixin.qq.com/s/OnBjbLzuipWz_u4QfmgcqQ)，无非就是多了一个限制，本题是要找到和为n的k个数的组合，而整个集合已经是固定的了[1,...,9]。 
 
-* 解集不能包含重复的组合。 说明不用去重了，难度就小一些。
-* 求的是组合，那么集合没有顺序，for里面依然要从startIndex开始（如果是排列的话，就从0开始）
+想到这一点了，做过[77. 组合](https://mp.weixin.qq.com/s/OnBjbLzuipWz_u4QfmgcqQ)之后，本题是简单一些了。
 
-本题k相当于限制了树的深度，9就是树的宽度。
+本题k相当于了树的深度，9（因为整个集合就是9个数）就是树的宽度。
+
+例如 k = 2，n = 4的话，就是在集合[1,2,3,4,5,6,7,8,9]中求 k（个数） = 2, n（和） = 4的组合。
 
 选取过程如图：
 
 <img src='../pics/216.组合总和III.png' width=600> </img></div>
 
-那么这还是一道标准的模板题，模板：
+图中，可以看出，只有最后取到集合（1，3）和为4 符合条件。
+
+
+## 回溯三部曲
+
+* **确定递归函数参数** 
+
+和[回溯算法：求组合问题！](https://mp.weixin.qq.com/s/OnBjbLzuipWz_u4QfmgcqQ)一样，依然需要一维数组path来存放符合条件的结果，二维数组result来存放结果集。
+
+这里我依然定义path 和 result为全局变量。 
+
+至于为什么取名为path？从上面树形结构中，可以看出，结果其实就是一条根节点到叶子节点的路径。
+
+```
+vector<vector<int>> result; // 存放结果集 
+vector<int> path; // 符合条件的结果
+```
+
+接下来还需要如下参数：
+
+* targetSum（int）目标和，也就是题目中的n。 
+* k（int）就是题目中要求k个数的集合。 
+* sum（int）为已经收集的元素的总和，也就是path里元素的总和。 
+* startIndex（int）为下一层for循环搜索的起始位置。
+
+所以代码如下：
 
 ```
-backtracking() {
-    if (终止条件) {
-        存放结果;
+vector<vector<int>> result;
+vector<int> path;
+void backtracking(int targetSum, int k, int sum, int startIndex) 
+```
+其实这里sum这个参数也可以省略，每次targetSum减去选取的元素数值，然后判断如果targetSum为0了，说明收集到符合条件的结果了，我这里为了直观便于理解，还是加一个sum参数。
+
+还要强调一下，回溯法中递归函数参数很难一次性确定下来，一般先写逻辑，需要啥参数了，填什么参数。
+
+* 确定终止条件 
+
+什么时候终止呢？
+
+在上面已经说了，k其实就已经限制树的深度，因为就取k个元素，树再往下深了没有意义。 
+
+所以如果path.size() 和 k相等了，就终止。
+
+如果此时path里收集到的元素和（sum） 和targetSum（就是题目描述的n）相同了，就用result收集当前的结果。
+
+所以 终止代码如下：
+
+```
+if (path.size() == k) {
+    if (sum == targetSum) result.push_back(path);
+    return; // 如果path.size() == k 但sum != targetSum 直接返回
+}
+```
+
+* **单层搜索过程**
+
+本题和[回溯算法：求组合问题！](https://mp.weixin.qq.com/s/OnBjbLzuipWz_u4QfmgcqQ)区别之一就是集合固定的就是9个数[1,...,9]，所以for循环固定i<=9
+
+如图：
+<img src='../pics/216.组合总和III.png' width=600> </img></div>
+
+处理过程就是 path收集每次选取的元素，相当于树型结构里的边，sum来统计path里元素的总和。
+
+代码如下：
+
+```
+for (int i = startIndex; i <= 9; i++) {
+    sum += i;
+    path.push_back(i);
+    backtracking(targetSum, k, sum, i + 1); // 注意i+1调整startIndex
+    sum -= i; // 回溯 
+    path.pop_back(); // 回溯 
+}
+```
+
+**别忘了处理过程 和 回溯过程是一一对应的，处理有加，回溯就要有减！**
+
+参照[关于回溯算法，你该了解这些！](https://mp.weixin.qq.com/s/gjSgJbNbd1eAA5WkA-HeWw)中的模板，不难写出如下C++代码：
+
+```
+class Solution {
+private:
+    vector<vector<int>> result; // 存放结果集 
+    vector<int> path; // 符合条件的结果
+    // targetSum：目标和，也就是题目中的n。 
+    // k：题目中要求k个数的集合。 
+    // sum：已经收集的元素的总和，也就是path里元素的总和。 
+    // startIndex：下一层for循环搜索的起始位置。
+    void backtracking(int targetSum, int k, int sum, int startIndex) {
+        if (path.size() == k) {
+            if (sum == targetSum) result.push_back(path);
+            return; // 如果path.size() == k 但sum != targetSum 直接返回
+        }
+        for (int i = startIndex; i <= 9; i++) {
+            sum += i; // 处理
+            path.push_back(i); // 处理
+            backtracking(targetSum, k, sum, i + 1); // 注意i+1调整startIndex
+            sum -= i; // 回溯
+            path.pop_back(); // 回溯
+        }
     }
 
-    for (选择：选择列表（可以想成树中节点孩子的数量）) {
-        递归，处理节点;
-        backtracking();
-        回溯，撤销处理结果
+public:
+    vector<vector<int>> combinationSum3(int k, int n) {
+        result.clear(); // 可以不加
+        path.clear();   // 可以不加
+        backtracking(n, k, 0, 1);
+        return result;
     }
-}
+};
 ```
 
+## 剪枝 
+
+这道题目，剪枝操作其实是很容易想到了，想必大家看上面的树形图的时候已经想到了。
+
+如图：
+<img src='../pics/216.组合总和III1.png' width=600> </img></div>
+
+已选元素总和如果已经大于n（图中数值为4）了，那么往后遍历就没有意义了，直接剪掉。
 
+那么剪枝的地方一定是在递归终止的地方剪，剪枝代码如下：
+
+```
+if (sum > targetSum) { // 剪枝操作
+    return;
+}
+```
 
-# C++代码
+最后C++代码如下：
 
 ```
 class Solution {
 private:
-    vector<vector<int>> result;
-    vector<int> path;
-    void backtracking(int target, int k, int num, int sum, int startIndex) {
-        if (sum > target || num > k) { // 剪枝操作，如果sum大于target或者num大于k了没有继续搜索的必要了
-            return;
+    vector<vector<int>> result; // 存放结果集
+    vector<int> path; // 符合条件的结果
+    // targetSum：目标和，也就是题目中的n。
+    // k：题目中要求k个数的集合。
+    // sum：已经收集的元素的总和，也就是path里元素的总和。
+    // startIndex：下一层for循环搜索的起始位置。
+    void backtracking(int targetSum, int k, int sum, int startIndex) {
+        if (sum > targetSum) { // 剪枝操作
+            return; // 如果path.size() == k 但sum != targetSum 直接返回
         }
-        if (num == k && sum == target) {
-            result.push_back(path);
+        if (path.size() == k) {
+            if (sum == targetSum) result.push_back(path);
             return;
         }
-
         for (int i = startIndex; i <= 9; i++) {
-            sum += i;
-            path.push_back(i);
-            num++;
-            backtracking(target, k, num, sum, i + 1);
-            num--;
-            sum -= i;
-            path.pop_back();
+            sum += i; // 处理
+            path.push_back(i); // 处理
+            backtracking(targetSum, k, sum, i + 1); // 注意i+1调整startIndex
+            sum -= i; // 回溯
+            path.pop_back(); // 回溯
         }
     }
 
 public:
     vector<vector<int>> combinationSum3(int k, int n) {
-        backtracking(n, k, 0, 0, 1);
+        result.clear(); // 可以不加
+        path.clear();   // 可以不加
+        backtracking(n, k, 0, 1);
         return result;
-
     }
 };
 ```
+
+# 总结 
+
+开篇就介绍了本题与[回溯算法：求组合问题！](https://mp.weixin.qq.com/s/OnBjbLzuipWz_u4QfmgcqQ)的区别，相对来说加了元素总和的限制，如果做完[回溯算法：求组合问题！](https://mp.weixin.qq.com/s/OnBjbLzuipWz_u4QfmgcqQ)再做本题在合适不过。
+
+分析完区别，依然把问题抽象为树形结构，按照回溯三部曲进行讲解，最后给出剪枝的优化。
+
+相信做完本题，大家对组合问题应该有初步了解了。
+
+**就酱，如果感觉对你有帮助，就帮Carl转发一下吧，让更多小伙伴知道这里！**

problems/0077.组合.md

@@ -0,0 +1,39 @@
+
+这道题也不是单调栈的简单题 
+
+需要记录 传入的所有price 
+
+注意 股票价格相同的情况 
+
+需要自己维护一个数组，用stack来记录下表， 因为数组下标从0开始的，注意 栈为空的两种情况（代码中注释）。
+
+如果这道题，不用这个应用场景，而是直接给出输入数组的话，会简单一些。
+
+这道题目他们都用两个栈来实现，貌似代码简介一些，但我这个最直观。 可以画一个图
+
+```
+class StockSpanner {
+public:
+    stack<int> st;
+    vector<int> prices;
+    StockSpanner() {
+    }
+
+    int next(int price) {
+        prices.push_back(price);
+        while (!st.empty() && prices[st.top()] <= price) { // 注意这里等于的情况
+            st.pop();
+        }
+        int result;
+        int curPriceIndex = prices.size() - 1;
+        if (!st.empty()) { // 栈不为空，求差值
+            result = curPriceIndex - st.top();
+        } else { // 栈为空
+            if (prices.size() == 1) result = 1; // 如果是放入第一个元素就是，result是1
+            else result = curPriceIndex + 1; // 不是放入的第一个元素了，那么就应该是当前索引+1
+        }
+        st.push(curPriceIndex);
+        return result;
+    }
+};
+```

problems/0216.组合总和III.md

@@ -1,4 +1,7 @@
 
+## 链接
+https://leetcode-cn.com/problems/unique-number-of-occurrences/
+
 ## 思路
 
 这道题目数组在是哈希法中的经典应用，如果对数组在哈希法中的使用还不熟悉的同学可以看这两篇：[数组在哈希法中的应用](https://mp.weixin.qq.com/s/vM6OszkM6L1Mx2Ralm9Dig)和[哈希法：383. 赎金信](https://mp.weixin.qq.com/s/sYZIR4dFBrw_lr3eJJnteQ)
@@ -7,8 +10,6 @@
 
 回归本题，**本题强调了-1000 <= arr[i] <= 1000**，那么就可以用数组来做哈希，arr[i]作为哈希表（数组）的下标，那么arr[i]可以是负数，怎么办？负数不能做数组下标。
 
-**PS：本文[leetcode刷题攻略](https://github.com/youngyangyang04/leetcode-master)已经收录，相信可以帮你稳稳的提升算法能力，给star支持一下吧！**
-
 
 **此时可以定义一个2000大小的数组，例如int count[2002];**，统计的时候，将arr[i]统一加1000，这样就可以统计arr[i]的出现频率了。