From a0cba4a75a4361f80a242906f9964e717ca4fc39 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sun, 13 Sep 2020 11:11:58 +0800
Subject: [PATCH 01/87] update
---
... 1219. \351\273\204\351\207\221\347\237\277\345\267\245.md" | 3 +++
1 file changed, 3 insertions(+)
diff --git "a/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 1219. \351\273\204\351\207\221\347\237\277\345\267\245.md" "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 1219. \351\273\204\351\207\221\347\237\277\345\267\245.md"
index ade2801..8a225a6 100644
--- "a/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 1219. \351\273\204\351\207\221\347\237\277\345\267\245.md"
+++ "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 1219. \351\273\204\351\207\221\347\237\277\345\267\245.md"
@@ -59,6 +59,9 @@
这题也是搜索相关，四个方向，不允许重复，不过这次我们需要从不同起点搜索，而且为了减少搜索次数，我们得从黄金数量不为0的点开始搜。然后每当走不下去的时候，就比较一下当前黄金数量，求出最大值即可。
+
+
+
```javascript
/**
* @param {number[][]} grid
From 1fa38dfe008ea8cac5101bd448304546b4376f66 Mon Sep 17 00:00:00 2001
From: yangchaoyi <61035508+Chocolate1999@users.noreply.github.com>
Date: Sun, 13 Sep 2020 11:31:26 +0800
Subject: [PATCH 02/87] Create LICENSE
---
LICENSE | 21 +++++++++++++++++++++
1 file changed, 21 insertions(+)
create mode 100644 LICENSE
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..61808c7
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 yangchaoyi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
From 419d6804bb3c2c5e8122de6f76f618443ea06e09 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sun, 13 Sep 2020 12:06:41 +0800
Subject: [PATCH 03/87] update
---
README.md | 77 ++++++++++++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 76 insertions(+), 1 deletion(-)
diff --git a/README.md b/README.md
index a9e82e8..322a541 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,76 @@
->如果有一天，你的努力配得上你的梦想，那么你的梦想也绝对不会辜负你的努力。
\ No newline at end of file
+## :sunny:leetcode-javascript
+
+
+
+
+## :seedling:仓库地址
+
+传送门：https://github.com/Chocolate1999/leetcode-javascript
+## :loudspeaker:公告
+感谢访问本站，若喜欢请收藏，star支持一下 ✿✿ヽ(°▽°)ノ✿
+
+>此处应该有一个思维导图，待更新，mark
+
+## :snowman:笔记网站（更新）
+
+https://yangchaoyi.vip/ （基于hexo-butterfly主题搭建的博客，整理面试记录）
+
+https://yangchaoyi.vip/iBook/ （基于vuepress搭建的前端学习笔记，目前还在建设当中）
+
+为了让您更好的阅读本仓库笔记，考虑还是建了个人网站，本仓库内容陆续都会更新到网站上，你可以根据分类找到你想阅读的文章，隆重感谢给本仓库点 Star 的小伙伴!
+
+
+## :bulb:前言
+本仓库刷题路线参考 ssh （给大佬点赞）
+
+仓库地址：https://github.com/sl1673495/leetcode-javascript
+
+感谢大佬的归纳总结，原本打算在大佬那里打卡学习，后面考虑不太友好，还是自己新建了一个仓库打卡学习。
+
+## :pushpin:仓库介绍
+本仓库将全程使用的语言是 `JavaScript`，是一个纯前端刷题路线，对于前端刷题没有方向的小伙伴简直是福音。解题代码会记录在本仓库的 `Issues` 中，会按照 `label `进行分类。比如想查看 「递归与回溯」 分类下的问题，那么选择标签进行筛选即可。
+
+同时，小伙伴们可以在 `Issues` 中提交自己的解题代码，🤝 欢迎 `Contributing` ，可打卡刷题，坚持下来的人最酷！Give a ⭐️ if this project helped you !
+
+
+
+座右铭: 学如逆水行舟，不进则退
+
+**【亡羊补牢】挑战数据结构与算法专栏**：博客地址
+
+最后，介绍本仓库的刷题专题系列了，一共会分为这些模块:
+
+>**专题目录**
+>链表篇、栈和队列篇、哈希表篇、二叉树篇、字典树、并查集、常见排序和查找算法、回溯算法、动态规划、贪心算法、LRU和LFU、字符串和正则篇
+
+内容还是很丰富的，仓库也会不断完善，让我们一起加油修炼内功~
+
+## :gift_heart:贡献
+欢迎对改善本仓库提出好的意见，也欢迎 `Contributor`，谢谢！
+
+将会持续更新 `LeetCode` 刷题路线，从零到拿到满意的Offer！觉得不错，来个Star!
+
+
+## :sunflower:版权申明
+
+博客中的每篇文章都是我一字一句敲出来的，如需转载，请附上原文链接，表示对原作者的尊重。谢谢合作！
+
+## :page_with_curl:排版
+
+笔记内容按照 中文文案排版指北进行排版。
+
+## :trophy:结尾
+
+欢迎关注微信公众号：小狮子前端Vue
+
+谢谢您的支持！✿✿ヽ(°▽°)ノ✿
+
+注：本仓库不参与商业行为，也请各位读者周知。(This warehouse is not involved in commercial activities.)
+
+转载使用请注明出处，谢谢！
+
+>如果有一天，你的努力配得上你的梦想，那么你的梦想也绝对不会辜负你的努力。
+
+## License
+
+MIT
From 8eefb2faf562f709da6865938df14fb17054eac9 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sun, 13 Sep 2020 13:40:49 +0800
Subject: [PATCH 04/87] =?UTF-8?q?add=20=E9=9D=A2=E8=AF=95=E9=A2=98=2008.08?=
=?UTF-8?q?.=20=E6=9C=89=E9=87=8D=E5=A4=8D=E5=AD=97=E7=AC=A6=E4=B8=B2?=
=?UTF-8?q?=E7=9A=84=E6=8E=92=E5=88=97=E7=BB=84=E5=90=88?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...350\257\215\346\220\234\347\264\242 II.md" | 0
...22\345\210\227\347\273\204\345\220\210.md" | 70 +++++++++++++++++++
2 files changed, 70 insertions(+)
create mode 100644 "\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 212. \345\215\225\350\257\215\346\220\234\347\264\242 II.md"
create mode 100644 "\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode \351\235\242\350\257\225\351\242\230 08.08. \346\234\211\351\207\215\345\244\215\345\255\227\347\254\246\344\270\262\347\232\204\346\216\222\345\210\227\347\273\204\345\220\210.md"
diff --git "a/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 212. \345\215\225\350\257\215\346\220\234\347\264\242 II.md" "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 212. \345\215\225\350\257\215\346\220\234\347\264\242 II.md"
new file mode 100644
index 0000000..e69de29
diff --git "a/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode \351\235\242\350\257\225\351\242\230 08.08. \346\234\211\351\207\215\345\244\215\345\255\227\347\254\246\344\270\262\347\232\204\346\216\222\345\210\227\347\273\204\345\220\210.md" "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode \351\235\242\350\257\225\351\242\230 08.08. \346\234\211\351\207\215\345\244\215\345\255\227\347\254\246\344\270\262\347\232\204\346\216\222\345\210\227\347\273\204\345\220\210.md"
new file mode 100644
index 0000000..dd31596
--- /dev/null
+++ "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode \351\235\242\350\257\225\351\242\230 08.08. \346\234\211\351\207\215\345\244\215\345\255\227\347\254\246\344\270\262\347\232\204\346\216\222\345\210\227\347\273\204\345\220\210.md"
@@ -0,0 +1,70 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+有重复字符串的排列组合。编写一种方法，计算某字符串的所有排列组合。
+
+示例1:
+
+```javascript
+ 输入：S = "qqe"
+ 输出：["eqq","qeq","qqe"]
+```
+
+示例2:
+
+```javascript
+ 输入：S = "ab"
+ 输出：["ab", "ba"]
+```
+
+提示:
+
+```javascript
+字符都是英文字母。
+字符串长度在[1, 9]之间。
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/permutation-ii-lcci
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+## 解题思路
+
+全排列，直接用回溯法即可，数据量比较小，暴力完事~
+
+```javascript
+var permutation = function (S) {
+ let res = new Set()
+ let vis = []
+ let dfs = (t) => {
+ if (t.length === S.length) return res.add(t)
+ for (let i = 0; i < S.length; i++) {
+ if (vis[i]) continue
+ vis[i] = true
+ dfs(t + S[i])
+ vis[i] = false
+ }
+ }
+ dfs('')
+ return [...res]
+}
+```
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 1757a50f47c0112f26d16bae33f03e7a2b7dfa9c Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sun, 13 Sep 2020 16:03:33 +0800
Subject: [PATCH 05/87] =?UTF-8?q?add=20LeetCode=20212.=20=E5=8D=95?=
=?UTF-8?q?=E8=AF=8D=E6=90=9C=E7=B4=A2=20II?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...350\257\215\346\220\234\347\264\242 II.md" | 228 ++++++++++++++++++
1 file changed, 228 insertions(+)
diff --git "a/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 212. \345\215\225\350\257\215\346\220\234\347\264\242 II.md" "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 212. \345\215\225\350\257\215\346\220\234\347\264\242 II.md"
index e69de29..eba5e72 100644
--- "a/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 212. \345\215\225\350\257\215\346\220\234\347\264\242 II.md"
+++ "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 212. \345\215\225\350\257\215\346\220\234\347\264\242 II.md"
@@ -0,0 +1,228 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+给定一个二维网格 `board` 和一个字典中的单词列表 `words`，找出所有同时在二维网格和字典中出现的单词。
+
+单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母在一个单词中不允许被重复使用。
+
+示例:
+
+```javascript
+输入:
+words = ["oath","pea","eat","rain"] and board =
+[
+ ['o','a','a','n'],
+ ['e','t','a','e'],
+ ['i','h','k','r'],
+ ['i','f','l','v']
+]
+
+输出: ["eat","oath"]
+说明:
+你可以假设所有输入都由小写字母 a-z 组成。
+```
+
+提示:
+
+```javascript
+你需要优化回溯算法以通过更大数据量的测试。你能否早点停止回溯？
+如果当前单词不存在于所有单词的前缀中，则可以立即停止回溯。什么样的数据结构可以有效地执行这样的操作？散列表是否可行？为什么？ 前缀树如何？如果你想学习如何实现一个基本的前缀树，请先查看这个问题： 实现Trie（前缀树）。
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/word-search-ii
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+
+## 解题思路
+参考力扣官网分析：实现 Trie (前缀树)
+
+- 判断是否找到了，通过传递节点的END来判断
+
+- 判断是否重复访问，通过动态更改走过的网格点来判断，就不需要再定义一个`vis`数组了
+
+参考大佬：秦时明月字典树建树解法（二）
+
+```javascript
+var findWords = function(grid, words) {
+ // 存放最终结果集
+ let res = []
+ // 字典树节点
+ class TrieNode {
+ constructor(){
+ this.end = false
+ this.child = {}
+ }
+ }
+ // 最终形成的字典树根节点
+ let root = null
+ let Trie = function(){
+ root = new TrieNode()
+ }
+ // 建立字典树
+ Trie.prototype.insert = (word) => {
+ let cur = root
+ for(let i=0;i {
+ if(cur.end){
+ res.push(t)
+ cur.end = false // 避免重复计算
+ }
+ // 剪枝条件：1.边界处理 2.下一步是否可走 3.下一步字典树是否可走
+ if(x<0 || x>=grid.length || y<0 || y>=grid[0].length || grid[x][y] == '#' || !cur.child[grid[x][y]]) return
+ let tmp = grid[x][y]
+ grid[x][y] = '#' // 走
+ cur = cur.child[tmp]
+ dfs(x+1,y,t+tmp,cur) // 上下左右四个方向遍历
+ dfs(x,y+1,t+tmp,cur)
+ dfs(x-1,y,t+tmp,cur)
+ dfs(x,y-1,t+tmp,cur)
+ grid[x][y] = tmp // 回溯（还原）
+ }
+ // 对单词表进行全局搜索
+ for(let i=0;i {
+ let cur = root
+ for(let i=0;i {
+ let cur = root
+ for(let i=0;i {
+ let cur = searchPrefix(word)
+ return cur !== null && cur.end
+ }
+ // 查找 Trie 树中的键前缀
+ Trie.prototype.startsWith = (pre) => {
+ return searchPrefix(pre) != null
+ }
+ // 创建根节点
+ let trie = new Trie()
+ // 进行建树操作
+ for(let i=0;i {
+ if(cur.end){
+ res.push(t)
+ cur.end = false // 避免重复计算
+ }
+ // 剪枝条件：1.边界处理 2.下一步是否可走 3.下一步字典树是否可走
+ if(x<0 || x>=grid.length || y<0 || y>=grid[0].length || grid[x][y] == '#' || !cur.child[grid[x][y]]) return
+ let tmp = grid[x][y]
+ grid[x][y] = '#' // 走
+ cur = cur.child[tmp]
+ dfs(x+1,y,t+tmp,cur) // 上下左右四个方向遍历
+ dfs(x,y+1,t+tmp,cur)
+ dfs(x-1,y,t+tmp,cur)
+ dfs(x,y-1,t+tmp,cur)
+ grid[x][y] = tmp // 回溯（还原）
+ }
+ // 对单词表进行全局搜索
+ for(let i=0;i小狮子前端の笔记仓库
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 6b7dbee823d1421e6bbe85766233b10ab5aa4c39 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sun, 13 Sep 2020 18:42:33 +0800
Subject: [PATCH 06/87] =?UTF-8?q?add=20LeetCode=2079.=20=E5=8D=95=E8=AF=8D?=
=?UTF-8?q?=E6=90=9C=E7=B4=A2?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...25\350\257\215\346\220\234\347\264\242.md" | 99 +++++++++++++++++++
1 file changed, 99 insertions(+)
create mode 100644 "\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 79. \345\215\225\350\257\215\346\220\234\347\264\242.md"
diff --git "a/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 79. \345\215\225\350\257\215\346\220\234\347\264\242.md" "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 79. \345\215\225\350\257\215\346\220\234\347\264\242.md"
new file mode 100644
index 0000000..28e7287
--- /dev/null
+++ "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 79. \345\215\225\350\257\215\346\220\234\347\264\242.md"
@@ -0,0 +1,99 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+给定一个二维网格和一个单词，找出该单词是否存在于网格中。
+
+单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。
+
+
+
+示例:
+
+```javascript
+board =
+[
+ ['A','B','C','E'],
+ ['S','F','C','S'],
+ ['A','D','E','E']
+]
+
+给定 word = "ABCCED", 返回 true
+给定 word = "SEE", 返回 true
+给定 word = "ABCB", 返回 false
+```
+
+提示：
+
+```javascript
+board 和 word 中只包含大写和小写英文字母。
+1 <= board.length <= 200
+1 <= board[i].length <= 200
+1 <= word.length <= 10^3
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/word-search
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+## 解题思路
+上一期做了单词搜索2 `hard` 版本之后，这道题也想用字典树玩一玩，没想到超时了，后面一想，数据确实有点大，而且对于一个单词来说，建立一颗字典树岂不是很浪费，还要花时间码代码...
+
+本题也是回溯的思路，不过期间做了一点小优化，还是通过动态更改当前所走的格子，省去了那份 开辟`vis` 数组的空间。
+
+对于递归层次，由于最后一次计算时，层次多算了一次（即多加了一次），所以条件为 `>`。
+
+
+
+
+
+```javascript
+var exist = function(grid, word) {
+ let dfs = (x,y,t) => {
+ // 最后一次还会 +1 因此，条件是大于
+ if(t > word.length-1){
+ return true
+ }
+ // 剪枝条件
+ if(x<0 || x>=grid.length || y<0 || y>=grid[0].length || grid[x][y]!= word[t] || grid[x][y] == '#') return false
+ let tmp = grid[x][y]
+ // 开始走
+ grid[x][y] = '#'
+ // 从四个方向搜索，只要一个方向搜索有结果，那么直接返回 true即可
+ let res = dfs(x+1,y,t+1) || dfs(x,y+1,t+1) || dfs(x-1,y,t+1) || dfs(x,y-1,t+1)
+ if(res) return true
+ // 回溯（重置）
+ grid[x][y] = tmp
+ return false
+ }
+ for(let i=0;i小狮子前端の笔记仓库
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
+
From 84f041e49740b1bfb50d83f0a0504624051bf4bf Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sun, 13 Sep 2020 18:46:58 +0800
Subject: [PATCH 07/87] =?UTF-8?q?add=20LeetCode=2020.=20=E6=9C=89=E6=95=88?=
=?UTF-8?q?=E7=9A=84=E6=8B=AC=E5=8F=B7?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...10\347\232\204\346\213\254\345\217\267.md" | 92 +++++++++++++++++++
1 file changed, 92 insertions(+)
create mode 100644 "\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 20. \346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.md"
diff --git "a/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 20. \346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.md" "b/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 20. \346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.md"
new file mode 100644
index 0000000..ccc2248
--- /dev/null
+++ "b/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 20. \346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.md"
@@ -0,0 +1,92 @@
+
+
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+
+给定一个只包括` '('，')'，'{'，'}'，'['，']' `的字符串，判断字符串是否有效。
+
+有效字符串需满足：
+
+左括号必须用相同类型的右括号闭合。
+左括号必须以正确的顺序闭合。
+注意空字符串可被认为是有效字符串。
+
+示例 1:
+
+```javascript
+输入: "()"
+输出: true
+```
+
+示例 2:
+
+```javascript
+输入: "()[]{}"
+输出: true
+```
+
+示例 3:
+
+```javascript
+输入: "(]"
+输出: false
+```
+
+示例 4:
+
+```javascript
+输入: "([)]"
+输出: false
+```
+
+示例 5:
+
+```javascript
+输入: "{[]}"
+输出: true
+```
+
+
+## 题解
+
+发现越靠后的左括号，最先匹配，也就是`后进先出`的思想，于是考虑使用栈这个数据结构。
+
+```javascript
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var isValid = function(s) {
+ // 如果是奇数，不可能匹配成功，直接返回false
+ if(s.length & 1) return false
+ let stack = []
+ for(let i=0;i小狮子前端の笔记仓库
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
\ No newline at end of file
From 63e60c652c184312af77ff16409edf3fa615b26a Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sun, 13 Sep 2020 18:48:56 +0800
Subject: [PATCH 08/87] =?UTF-8?q?add=20LeetCode=20933.=20=E6=9C=80?=
=?UTF-8?q?=E8=BF=91=E7=9A=84=E8=AF=B7=E6=B1=82=E6=AC=A1=E6=95=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...67\346\261\202\346\254\241\346\225\260.md" | 88 +++++++++++++++++++
1 file changed, 88 insertions(+)
create mode 100644 "\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 933. \346\234\200\350\277\221\347\232\204\350\257\267\346\261\202\346\254\241\346\225\260.md"
diff --git "a/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 933. \346\234\200\350\277\221\347\232\204\350\257\267\346\261\202\346\254\241\346\225\260.md" "b/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 933. \346\234\200\350\277\221\347\232\204\350\257\267\346\261\202\346\254\241\346\225\260.md"
new file mode 100644
index 0000000..9d72b7c
--- /dev/null
+++ "b/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 933. \346\234\200\350\277\221\347\232\204\350\257\267\346\261\202\346\254\241\346\225\260.md"
@@ -0,0 +1,88 @@
+
+
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+
+写一个` RecentCounter` 类来计算最近的请求。
+
+它只有一个方法：`ping(int t)`，其中 t 代表以毫秒为单位的某个时间。
+
+返回从 `3000 `毫秒前到现在的 ping 数。
+
+任何处于` [t - 3000, t] `时间范围之内的 `ping` 都将会被计算在内，包括当前（指 t 时刻）的 `ping`。
+
+保证每次对 `ping` 的调用都使用比之前更大的 t 值。
+
+
+
+示例：
+
+```javascript
+输入：inputs = ["RecentCounter","ping","ping","ping","ping"], inputs = [[],[1],[100],[3001],[3002]]
+输出：[null,1,2,3,3]
+```
+
+
+
+提示：
+
+每个测试用例最多调用` 10000 `次 ping。
+每个测试用例会使用严格递增的 `t `值来调用 `ping`。
+每次调用 ping 都有` 1 <= t <= 10^9`。
+
+
+## 题解
+根据样例，发现越早发出的请求越早不在 `3000ms` 内的请求里
+
+满足**先进先出**，考虑用队列
+
+那么就将新请求加入队列，`3000ms`前发出的请求就出队列
+
+
+队列的长度即为最近请求次数。
+
+```javascript
+var RecentCounter = function() {
+ this.queue = []
+};
+
+/**
+ * @param {number} t
+ * @return {number}
+ */
+RecentCounter.prototype.ping = function(t) {
+ // 将新请求加入队列
+ this.queue.push(t)
+ // 3000ms 前发出的请求就出队列
+ while(this.queue[0] < t-3000){
+ this.queue.shift()
+ }
+ return this.queue.length
+};
+
+/**
+ * Your RecentCounter object will be instantiated and called as such:
+ * var obj = new RecentCounter()
+ * var param_1 = obj.ping(t)
+ */
+```
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
\ No newline at end of file
From bbab88a1c02516d80f300d226dbedd04994cdc5a Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sun, 13 Sep 2020 18:50:35 +0800
Subject: [PATCH 09/87] =?UTF-8?q?add=20LeetCode=20946.=20=E9=AA=8C?=
=?UTF-8?q?=E8=AF=81=E6=A0=88=E5=BA=8F=E5=88=97?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...01\346\240\210\345\272\217\345\210\227.md" | 79 +++++++++++++++++++
1 file changed, 79 insertions(+)
create mode 100644 "\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 946. \351\252\214\350\257\201\346\240\210\345\272\217\345\210\227.md"
diff --git "a/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 946. \351\252\214\350\257\201\346\240\210\345\272\217\345\210\227.md" "b/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 946. \351\252\214\350\257\201\346\240\210\345\272\217\345\210\227.md"
new file mode 100644
index 0000000..caa10f5
--- /dev/null
+++ "b/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 946. \351\252\214\350\257\201\346\240\210\345\272\217\345\210\227.md"
@@ -0,0 +1,79 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+给定 `pushed` 和 `popped` 两个序列，每个序列中的 值都不重复，只有当它们可能是在最初空栈上进行的推入 `push` 和弹出 `pop` 操作序列的结果时，返回 `true`；否则，返回 `false` 。
+
+
+
+示例 1：
+
+```javascript
+输入：pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
+输出：true
+解释：我们可以按以下顺序执行：
+push(1), push(2), push(3), push(4), pop() -> 4,
+push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1
+```
+
+示例 2：
+
+```javascript
+输入：pushed = [1,2,3,4,5], popped = [4,3,5,1,2]
+输出：false
+解释：1 不能在 2 之前弹出。
+```
+
+
+提示：
+
+```javascript
+0 <= pushed.length == popped.length <= 1000
+0 <= pushed[i], popped[i] < 1000
+pushed 是 popped 的排列。
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/validate-stack-sequences
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+## 解题思路
+借助一个新栈来存放入栈的元素，然后每次和出栈的元素进行比对，如果匹配成功，双方进行出栈操作，最后，如果这个新栈为空，那么代表这个栈入栈和出栈序列是合理的，返回 `true`，否则返回`false`
+
+```javascript
+/**
+ * @param {number[]} pushed
+ * @param {number[]} popped
+ * @return {boolean}
+ */
+var validateStackSequences = function(pushed, popped) {
+ // 借助一个新的栈
+ let stack = []
+ for(let cur of pushed){
+ // 存放入栈的元素
+ stack.push(cur)
+ // 和出栈元素进行比对，如果匹配都弹出栈
+ while(stack[stack.length-1] === popped[0] && stack.length){
+ stack.pop()
+ popped.shift()
+ }
+ }
+ return !stack.length
+};
+```
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
\ No newline at end of file
From fb450033d3fda863ee12f255a3e26a0d17252d63 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sun, 13 Sep 2020 18:51:13 +0800
Subject: [PATCH 10/87] =?UTF-8?q?add=20LeetCode=20921.=20=E4=BD=BF?=
=?UTF-8?q?=E6=8B=AC=E5=8F=B7=E6=9C=89=E6=95=88=E7=9A=84=E6=9C=80=E5=B0=91?=
=?UTF-8?q?=E6=B7=BB=E5=8A=A0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...00\345\260\221\346\267\273\345\212\240.md" | 92 +++++++++++++++++++
1 file changed, 92 insertions(+)
create mode 100644 "\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 921. \344\275\277\346\213\254\345\217\267\346\234\211\346\225\210\347\232\204\346\234\200\345\260\221\346\267\273\345\212\240.md"
diff --git "a/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 921. \344\275\277\346\213\254\345\217\267\346\234\211\346\225\210\347\232\204\346\234\200\345\260\221\346\267\273\345\212\240.md" "b/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 921. \344\275\277\346\213\254\345\217\267\346\234\211\346\225\210\347\232\204\346\234\200\345\260\221\346\267\273\345\212\240.md"
new file mode 100644
index 0000000..cf702f2
--- /dev/null
+++ "b/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 921. \344\275\277\346\213\254\345\217\267\346\234\211\346\225\210\347\232\204\346\234\200\345\260\221\346\267\273\345\212\240.md"
@@ -0,0 +1,92 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+给定一个由` '('` 和` ')'` 括号组成的字符串 `S`，我们需要添加最少的括号`（ '(' 或是 ')'`，可以在任何位置），以使得到的括号字符串有效。
+
+从形式上讲，只有满足下面几点之一，括号字符串才是有效的：
+
+它是一个空字符串，或者
+它可以被写成 `AB` （A 与 B 连接）, 其中 A 和 B 都是有效字符串，或者
+它可以被写作 `(A)`，其中 A 是有效字符串。
+给定一个括号字符串，返回为使结果字符串有效而必须添加的最少括号数。
+
+
+
+示例 1：
+
+```javascript
+输入："())"
+输出：1
+```
+
+示例 2：
+
+```javascript
+输入："((("
+输出：3
+```
+
+示例 3：
+
+```javascript
+输入："()"
+输出：0
+```
+
+示例 4：
+
+```javascript
+输入："()))(("
+输出：4
+```
+
+提示：
+
+```javascript
+S.length <= 1000
+S 只包含 '(' 和 ')' 字符。
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/minimum-add-to-make-parentheses-valid
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+## 解题思路
+借助一个新栈，然后遍历当前字符串，如果当前栈顶元素和目前字符括号匹配，则弹出栈顶元素，否则进行入栈操作，最后需要的括号数即为栈剩余的元素个数
+
+```javascript
+/**
+ * @param {string} S
+ * @return {number}
+ */
+var minAddToMakeValid = function(S) {
+ // 长度为0，无须添加
+ if(!S.length) return 0
+ let stack = []
+ for(let i=0;i小狮子前端の笔记仓库
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
\ No newline at end of file
From d769c121b2d676904752e87c4c4a9c19aed52700 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sun, 13 Sep 2020 18:51:59 +0800
Subject: [PATCH 11/87] =?UTF-8?q?add=20LeetCode=20901.=20=E8=82=A1?=
=?UTF-8?q?=E7=A5=A8=E4=BB=B7=E6=A0=BC=E8=B7=A8=E5=BA=A6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...67\346\240\274\350\267\250\345\272\246.md" | 109 ++++++++++++++++++
1 file changed, 109 insertions(+)
create mode 100644 "\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 901. \350\202\241\347\245\250\344\273\267\346\240\274\350\267\250\345\272\246.md"
diff --git "a/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 901. \350\202\241\347\245\250\344\273\267\346\240\274\350\267\250\345\272\246.md" "b/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 901. \350\202\241\347\245\250\344\273\267\346\240\274\350\267\250\345\272\246.md"
new file mode 100644
index 0000000..31fee5e
--- /dev/null
+++ "b/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 901. \350\202\241\347\245\250\344\273\267\346\240\274\350\267\250\345\272\246.md"
@@ -0,0 +1,109 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+编写一个 `StockSpanner` 类，它收集某些股票的每日报价，并返回该股票当日价格的跨度。
+
+今天股票价格的跨度被定义为股票价格小于或等于今天价格的最大连续日数（从今天开始往回数，包括今天）。
+
+例如，如果未来7天股票的价格是` [100, 80, 60, 70, 60, 75, 85]`，那么股票跨度将是` [1, 1, 1, 2, 1, 4, 6]`。
+
+
+
+示例：
+
+```javascript
+输入：["StockSpanner","next","next","next","next","next","next","next"], [[],[100],[80],[60],[70],[60],[75],[85]]
+输出：[null,1,1,1,2,1,4,6]
+解释：
+首先，初始化 S = StockSpanner()，然后：
+S.next(100) 被调用并返回 1，
+S.next(80) 被调用并返回 1，
+S.next(60) 被调用并返回 1，
+S.next(70) 被调用并返回 2，
+S.next(60) 被调用并返回 1，
+S.next(75) 被调用并返回 4，
+S.next(85) 被调用并返回 6。
+```
+
+```javascript
+注意 (例如) S.next(75) 返回 4，因为截至今天的最后 4 个价格
+(包括今天的价格 75) 小于或等于今天的价格。
+```
+
+提示：
+
+```javascript
+调用 StockSpanner.next(int price) 时，将有 1 <= price <= 10^5。
+每个测试用例最多可以调用 10000 次 StockSpanner.next。
+在所有测试用例中，最多调用 150000 次 StockSpanner.next。
+此问题的总时间限制减少了 50%。
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/online-stock-span
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+## 解题思路
+正如题意，我们要求当前元素之前，比自己小（可以相等）的元素个数，并且元素个数包括本身，那么我们最后的结果应该还要加1.
+
+于是按题意，我们采用跨度法，举个例子，对于例子6，1，2，3，4，9，从后往前逆推一下，当我们新插入9的时候，如果发现前一位的4比9小，那么是否说明比9小的数量就等于比4小的数量加1？然而这是错的，因为首位的6比9小，却比4大，因此截止数字的4时候，比4小的数量中并不包含6与9的对比。
+
+因此，我们还要跳到 6 的位置再去计算小于等于自己的元素。
+
+```javascript
+var StockSpanner = function() {
+ // 存储股票跨度
+ this.spanner = []
+ // 存储股票价格
+ this.stockPrice = []
+};
+
+/**
+ * @param {number} price
+ * @return {number}
+ */
+StockSpanner.prototype.next = function(price) {
+ // 对于第一天进行特殊判断
+ if(!this.spanner.length){
+ this.spanner.push(1)
+ this.stockPrice.push(price)
+ // 直接返回1
+ return 1
+ }
+ let cnt = 0
+ let idx = this.stockPrice.length-1
+ while(price >= this.stockPrice[idx] && idx>=0){
+ cnt += this.spanner[idx]
+ idx -= this.spanner[idx]
+ }
+ // 加上本身
+ cnt++
+ // 进行更新操作，将当前股票价格和跨度入栈
+ this.spanner.push(cnt)
+ this.stockPrice.push(price)
+ return cnt
+};
+
+/**
+ * Your StockSpanner object will be instantiated and called as such:
+ * var obj = new StockSpanner()
+ * var param_1 = obj.next(price)
+ */
+```
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
From e61784bda3cb7d39da5dd3794accecc4d28a7869 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sun, 13 Sep 2020 18:52:55 +0800
Subject: [PATCH 12/87] =?UTF-8?q?add=20LeetCode=20739.=20=E6=AF=8F?=
=?UTF-8?q?=E6=97=A5=E6=B8=A9=E5=BA=A6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...17\346\227\245\346\270\251\345\272\246.md" | 57 +++++++++++++++++++
1 file changed, 57 insertions(+)
create mode 100644 "\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 739. \346\257\217\346\227\245\346\270\251\345\272\246.md"
diff --git "a/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 739. \346\257\217\346\227\245\346\270\251\345\272\246.md" "b/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 739. \346\257\217\346\227\245\346\270\251\345\272\246.md"
new file mode 100644
index 0000000..4c74fe7
--- /dev/null
+++ "b/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 739. \346\257\217\346\227\245\346\270\251\345\272\246.md"
@@ -0,0 +1,57 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+请根据每日 气温 列表，重新生成一个列表。对应位置的输出为：要想观测到更高的气温，至少需要等待的天数。如果气温在这之后都不会升高，请在该位置用 0 来代替。
+
+例如，给定一个列表 `temperatures = [73, 74, 75, 71, 69, 72, 76, 73]`，你的输出应该是 `[1, 1, 4, 2, 1, 1, 0, 0]`。
+
+提示：气温 列表长度的范围是 `[1, 30000]`。每个气温的值的均为华氏度，都是在 `[30, 100]` 范围内的整数。
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/daily-temperatures
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+## 解题思路
+本题用到了单调栈的思路，将原本需要 O(n^2) 的时间复杂度降低到了 O(n)。
+
+我们只需要维护一个新栈，首先遍历整个数组，只要栈不为空，如果当前的数字大于栈顶元素，则必定是第一个大于它的元素，我们只需要求出相差距离，然后存入结果就好了。
+
+维护的新栈存放的是我们的元素下标，这样我们求距离时就很方便了，本题我觉得可以说是单调栈的一个模板题。专栏后续会有单调栈其它题目，可以查阅哈。
+
+```javascript
+/**
+ * @param {number[]} T
+ * @return {number[]}
+ */
+var dailyTemperatures = function(T) {
+ let stack = []
+ // 初始化气温列表，默认值为0
+ let res = new Array(T.length).fill(0)
+ for(let i=0;i T[stack[stack.length-1]] && stack.length){
+ let idx = stack.pop()
+ res[idx] = i-idx
+ }
+ stack.push(i)
+ }
+ return res
+};
+```
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
From b7b9e33531d35b15aac74de5a92f3708c7797716 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sun, 13 Sep 2020 18:54:01 +0800
Subject: [PATCH 13/87] =?UTF-8?q?add=20LeetCode=20907.=20=E5=AD=90?=
=?UTF-8?q?=E6=95=B0=E7=BB=84=E7=9A=84=E6=9C=80=E5=B0=8F=E5=80=BC=E4=B9=8B?=
=?UTF-8?q?=E5=92=8C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...17\345\200\274\344\271\213\345\222\214.md" | 111 ++++++++++++++++++
1 file changed, 111 insertions(+)
create mode 100644 "\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 907. \345\255\220\346\225\260\347\273\204\347\232\204\346\234\200\345\260\217\345\200\274\344\271\213\345\222\214.md"
diff --git "a/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 907. \345\255\220\346\225\260\347\273\204\347\232\204\346\234\200\345\260\217\345\200\274\344\271\213\345\222\214.md" "b/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 907. \345\255\220\346\225\260\347\273\204\347\232\204\346\234\200\345\260\217\345\200\274\344\271\213\345\222\214.md"
new file mode 100644
index 0000000..83e1daa
--- /dev/null
+++ "b/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 907. \345\255\220\346\225\260\347\273\204\347\232\204\346\234\200\345\260\217\345\200\274\344\271\213\345\222\214.md"
@@ -0,0 +1,111 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+给定一个整数数组 A，找到 `min(B)` 的总和，其中 B 的范围为 A 的每个（连续）子数组。
+
+由于答案可能很大，因此返回答案模 `10^9 + 7`。
+
+
+
+示例：
+
+```javascript
+输入：[3,1,2,4]
+输出：17
+解释：
+子数组为 [3]，[1]，[2]，[4]，[3,1]，[1,2]，[2,4]，[3,1,2]，[1,2,4]，[3,1,2,4]。
+最小值为 3，1，2，4，1，1，2，1，1，1，和为 17。
+```
+
+
+
+提示：
+
+```javascript
+1 <= A <= 30000
+1 <= A[i] <= 30000
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/sum-of-subarray-minimums
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+## 解题思路
+搬运 `jack-108`大佬的题解：
+
+既然是求子数组中最小值的和，就是求 以 A[i] 作为最小数能构成的数组有多少个。
+
+比如 `[2,4,1,2]` ,以`1` 为最小数。能构成的数组数为 `(2+1)*(1+1)` ，`2` 表示 `1 `左面有两个比它大的数，`1` 表示 `1` 右面有一个比它大的数。
+
+用单调栈求出 `A[i]` 对应的左右最近比 `A[i]` 小的数，记索引为 `prev,next，A[i] `为最小数能形成的数组为
+
+```javascript
+(i-prev[i])*(next[i]-i)
+```
+
+这里为什么没有加 `1` 了呢，因为 `prev[i]`已经是比 `A[i]` 小的数了，能和 `A[i]` 形成数组的都是比 `A[i]` 大的数。
+
+**我的解题方式：**
+
+注释已经足够详细，还是补充一下，我参考了大佬的解题代码，只不过我是直接求出来了以当前 `A[i]` 为最小值的子数组左右两边 大于或等于当前值的个数。这样后续求和直接相乘即可。（不过这里要**强调一下**，如果左边设置大于等于了，右边就只能是大于了，不然会重复计算相等的值）
+
+开始有点看不懂大佬为啥左边初始化为 `-1`，右边初始化为 `A.length` 。假如我们遇到了这种情况，左边都比当前 `A[i]` 要大，那我们维护的单调递减栈就会不断出栈，不断出栈，直到栈为空为止，此时左边个数应该为 `i+1`（从 0 开始计数嘛），那么这部分大佬设为 `-1` 就很巧妙了，问题也就自然明白啦，个人感觉自己写的还是比较好理解一点，不然直接弄一个 `-1` ，第一次用单调栈，还是不太熟...
+
+那么对于右边初始化为 `A.length` ，也是同理啦，当右边都比当前 `A[i]` 要大，那我们维护的单调递减栈就会不断出栈，不断出栈，直到栈为空为止，此时右边个数应该为 `A.length-i`（不用`+1`的原因是从0计数），那么这部分大佬设为 `A.length` 就很巧妙了，依旧清晰明了。
+
+
+```javascript
+/**
+ * @param {number[]} A
+ * @return {number}
+ */
+var sumSubarrayMins = function(A) {
+ let mod = 1e9+7
+ // 维护一个栈
+ let stack = []
+ // 求以A[i]为最小值的子数组左边大于或等于自己的个数
+ let prev = []
+ for(let i=0;i= A[i]) stack.pop()
+ // 如果栈为空，即左边都比自己大，则返回i+1，否则返回i-栈顶元素（即保存的下标值）
+ prev[i] = stack.length ? i - stack[stack.length-1] : i+1
+ stack.push(i)
+ }
+ stack = []
+ // 求以A[i]为最小值的子数组右边大于自己的个数（没有等号是因为不会重复计算相等的值）
+ let nextv = []
+ for(let i=A.length-1;i>=0;i--){
+ while(stack.length && A[stack[stack.length-1]] > A[i]) stack.pop()
+ // 如果栈为空，即右边都比自己大，则返回A.length-i，否则返回栈顶元素（即保存的下标值）-i
+ nextv[i] = stack.length? stack[stack.length-1] - i : A.length-i
+ stack.push(i)
+ }
+ let sum = 0
+ for(let i=0;i小狮子前端の笔记仓库
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
From ed47d78deb0931ef613096e7dd2e01f40d276e76 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sun, 13 Sep 2020 18:54:49 +0800
Subject: [PATCH 14/87] =?UTF-8?q?add=20LeetCode=201190.=20=E5=8F=8D?=
=?UTF-8?q?=E8=BD=AC=E6=AF=8F=E5=AF=B9=E6=8B=AC=E5=8F=B7=E9=97=B4=E7=9A=84?=
=?UTF-8?q?=E5=AD=90=E4=B8=B2?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...64\347\232\204\345\255\220\344\270\262.md" | 130 ++++++++++++++++++
1 file changed, 130 insertions(+)
create mode 100644 "\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 1190. \345\217\215\350\275\254\346\257\217\345\257\271\346\213\254\345\217\267\351\227\264\347\232\204\345\255\220\344\270\262.md"
diff --git "a/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 1190. \345\217\215\350\275\254\346\257\217\345\257\271\346\213\254\345\217\267\351\227\264\347\232\204\345\255\220\344\270\262.md" "b/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 1190. \345\217\215\350\275\254\346\257\217\345\257\271\346\213\254\345\217\267\351\227\264\347\232\204\345\255\220\344\270\262.md"
new file mode 100644
index 0000000..07d0327
--- /dev/null
+++ "b/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 1190. \345\217\215\350\275\254\346\257\217\345\257\271\346\213\254\345\217\267\351\227\264\347\232\204\345\255\220\344\270\262.md"
@@ -0,0 +1,130 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+给出一个字符串 `s`（仅含有小写英文字母和括号）。
+
+请你按照从括号内到外的顺序，逐层反转每对匹配括号中的字符串，并返回最终的结果。
+
+注意，您的结果中 不应 包含任何括号。
+
+
+
+示例 1：
+
+```javascript
+输入：s = "(abcd)"
+输出："dcba"
+```
+
+示例 2：
+
+```javascript
+输入：s = "(u(love)i)"
+输出："iloveu"
+```
+
+示例 3：
+
+```javascript
+输入：s = "(ed(et(oc))el)"
+输出："leetcode"
+```
+
+示例 4：
+
+```javascript
+输入：s = "a(bcdefghijkl(mno)p)q"
+输出："apmnolkjihgfedcbq"
+```
+
+
+
+提示：
+
+```javascript
+0 <= s.length <= 2000
+s 中只有小写英文字母和括号
+我们确保所有括号都是成对出现的
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/reverse-substrings-between-each-pair-of-parentheses
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+## 解题思路
+初始化栈，栈顶元素为 " "
+遇到` '('`: 向栈顶压入空字符串
+遇到` ')'`: 把栈顶的最后一个元素翻转 + 栈顶倒数第二个元素
+遇到 字符: 直接将栈顶最后一个元素与它拼上
+
+参考 tuotuoli 大佬解题思路
+
+样例栈数组操作示意：
+
+```javascript
+样例：a(bcdefghijkl(mno)p)q
+
+a ['a']
+( ['a', '']
+b ['a', 'b']
+c ['a', 'bc']
+d ['a', 'bcd']
+e ['a', 'bcde']
+f ['a', 'bcdef']
+g ['a', 'bcdefg']
+h ['a', 'bcdefgh']
+i ['a', 'bcdefghi']
+j ['a', 'bcdefghij']
+k ['a', 'bcdefghijk']
+l ['a', 'bcdefghijkl']
+( ['a', 'bcdefghijkl', '']
+m ['a', 'bcdefghijkl', 'm']
+n ['a', 'bcdefghijkl', 'mn']
+o ['a', 'bcdefghijkl', 'mno']
+) ['a', 'bcdefghijklonm']
+p ['a', 'bcdefghijklonmp']
+) ['apmnolkjihgfedcb']
+q ['apmnolkjihgfedcbq']
+```
+
+```javascript
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var reverseParentheses = function(s) {
+ let stack = ['']
+ for(let i=0;i小狮子前端の笔记仓库
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
From 1e1a533d438c5a2b7bbcd8511d9f90aa3e942c66 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sun, 13 Sep 2020 18:55:20 +0800
Subject: [PATCH 15/87] =?UTF-8?q?add=20LeetCode=201249.=20=E7=A7=BB?=
=?UTF-8?q?=E9=99=A4=E6=97=A0=E6=95=88=E7=9A=84=E6=8B=AC=E5=8F=B7?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...10\347\232\204\346\213\254\345\217\267.md" | 108 ++++++++++++++++++
1 file changed, 108 insertions(+)
create mode 100644 "\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 1249. \347\247\273\351\231\244\346\227\240\346\225\210\347\232\204\346\213\254\345\217\267.md"
diff --git "a/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 1249. \347\247\273\351\231\244\346\227\240\346\225\210\347\232\204\346\213\254\345\217\267.md" "b/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 1249. \347\247\273\351\231\244\346\227\240\346\225\210\347\232\204\346\213\254\345\217\267.md"
new file mode 100644
index 0000000..64db911
--- /dev/null
+++ "b/\346\240\210\345\222\214\351\230\237\345\210\227/LeetCode 1249. \347\247\273\351\231\244\346\227\240\346\225\210\347\232\204\346\213\254\345\217\267.md"
@@ -0,0 +1,108 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+给你一个由` '('`、`')'` 和小写字母组成的字符串 `s`。
+
+你需要从字符串中删除最少数目的 `'('` 或者 `')' `（可以删除任意位置的括号)，使得剩下的「括号字符串」有效。
+
+请返回任意一个合法字符串。
+
+有效「括号字符串」应当符合以下 任意一条 要求：
+
+空字符串或只包含小写字母的字符串
+可以被写作 `AB`（A 连接 B）的字符串，其中 `A` 和 `B` 都是有效「括号字符串」
+可以被写作 (A) 的字符串，其中 `A` 是一个有效的「括号字符串」
+
+
+示例 1：
+
+```javascript
+输入：s = "lee(t(c)o)de)"
+输出："lee(t(c)o)de"
+解释："lee(t(co)de)" , "lee(t(c)ode)" 也是一个可行答案。
+```
+
+示例 2：
+
+```javascript
+输入：s = "a)b(c)d"
+输出："ab(c)d"
+```
+
+示例 3：
+
+```javascript
+输入：s = "))(("
+输出：""
+解释：空字符串也是有效的
+```
+
+示例 4：
+
+```javascript
+输入：s = "(a(b(c)d)"
+输出："a(b(c)d)"
+```
+
+
+
+提示：
+
+```javascript
+1 <= s.length <= 10^5
+s[i] 可能是 '('、')' 或英文小写字母
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/minimum-remove-to-make-valid-parentheses
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+## 解题思路
+一开始我是想着只要对应括号匹配就好了，将多余的右括号删掉，但是这个样例 `))((` 不可能过的，因为左括号也可以不匹配呀。于是我想着将括号对应字符串索引存起来，起初我们可以将不匹配的右括号还是按原来方法删掉就好了，匹配一个就删掉一个对应左括号的索引值，最后多出来的索引值全删掉就好了，这样就不会出现左括号还余留的情况。
+
+这里提示一下：不要用 `splice`去删除指定下标的元素，`splice`会改变原数组长度，而你原本存的下标是基于原数组的。
+`delete`方法不会改变数组长度，但删除的那个位置会变成`'undefined'`，所以我们用`fliter`方法过滤一遍出有效值 `arr=arr.filter(item=>item)`
+
+最后通过 `res.join('')` 方法，将数组转换成我们最后要的字符串即可。
+
+```javascript
+var minRemoveToMakeValid = function(s) {
+ let res = [...s]
+ let stack = []
+ for(let i=-0;iitem)
+ return res.join('')
+};
+```
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
From bce9020219c5d2e21064c3b4b47626f7951a5e56 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sun, 13 Sep 2020 19:43:16 +0800
Subject: [PATCH 16/87] update
---
README.md | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
diff --git a/README.md b/README.md
index 322a541..3c97c45 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,9 @@
## :loudspeaker:公告
感谢访问本站，若喜欢请收藏，star支持一下 ✿✿ヽ(°▽°)ノ✿
->此处应该有一个思维导图，待更新，mark
+>思维导图还在建设完善中ing
+
+
## :snowman:笔记网站（更新）
From 1620a441b5c9f3e49c0eee248b9562133c19f442 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Tue, 15 Sep 2020 18:04:04 +0800
Subject: [PATCH 17/87] =?UTF-8?q?add=20LeetCode=20401.=20=E4=BA=8C?=
=?UTF-8?q?=E8=BF=9B=E5=88=B6=E6=89=8B=E8=A1=A8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...33\345\210\266\346\211\213\350\241\250.md" | 119 ++++++++++++++++++
1 file changed, 119 insertions(+)
create mode 100644 "\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 401. \344\272\214\350\277\233\345\210\266\346\211\213\350\241\250.md"
diff --git "a/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 401. \344\272\214\350\277\233\345\210\266\346\211\213\350\241\250.md" "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 401. \344\272\214\350\277\233\345\210\266\346\211\213\350\241\250.md"
new file mode 100644
index 0000000..343784d
--- /dev/null
+++ "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 401. \344\272\214\350\277\233\345\210\266\346\211\213\350\241\250.md"
@@ -0,0 +1,119 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+二进制手表顶部有 4 个 LED 代表 **小时（0-11）**，底部的 6 个 LED 代表 **分钟（0-59）**。
+
+每个 LED 代表一个 0 或 1，最低位在右侧。
+
+
+
+
+例如，上面的二进制手表读取 “3:25”。
+
+给定一个非负整数 n 代表当前 LED 亮着的数量，返回所有可能的时间。
+
+
+
+示例：
+
+```javascript
+输入: n = 1
+返回: ["1:00", "2:00", "4:00", "8:00", "0:01", "0:02", "0:04", "0:08", "0:16", "0:32"]
+
+```
+
+提示：
+
+```javascript
+输出的顺序没有要求。
+小时不会以零开头，比如 “01:00” 是不允许的，应为 “1:00”。
+分钟必须由两位数组成，可能会以零开头，比如 “10:2” 是无效的，应为 “10:02”。
+超过表示范围（小时 0-11，分钟 0-59）的数据将会被舍弃，也就是说不会出现 "13:00", "0:61" 等时间。
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/binary-watch
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+## 解题思路
+回溯算法，我的解法类似于全排列做法，将10个小灯泡进行排列组合，然后根据 `0` 和 `1` 来判断灯泡是否亮，如果亮了，加上对应二进制，然后将 `0-3`分给小时来计算，将 `4-9`分给分钟来计算，但是要考虑一下，就是可能会出现重复情况，于是用 `Set`数据结构维护一下就好了。
+```javascript
+var readBinaryWatch = function(num) {
+ let res = new Set();
+ let vis = new Array(10).fill(0)
+ let check = (hour,minutes) => {
+ if(hour>=0 && hour<=11 && minutes>=0 && minutes<=59) return true;
+ return false;
+ }
+ let dfs = (t,vis) => {
+ if(t==0){
+ let hour = vis[0]*1 + vis[1]*2 + vis[2]*4 + vis[3]*8;
+ let minutes = vis[4]*1 + vis[5]*2 + vis[6]*4 + vis[7]*8 + vis[8]*16 + vis[9]*32;
+ if(check(hour,minutes)){
+ let tmp = `${hour}:${minutes >= 10? minutes: '0'+minutes}`;
+ res.add(tmp);
+ }
+ }
+ for(let i=0;i<10;i++){
+ if(vis[i]) continue;
+ vis[i] = 1;
+ dfs(t-1,vis);
+ vis[i] = 0;
+ }
+ }
+ dfs(num,vis);
+ return [...res];
+};
+```
+
+补充，后面看到有大佬这样做，进行了去重操作，关键点在回溯 `for`循环那里。其实这个相当于全排列了。
+```javascript
+var readBinaryWatch = function(num) {
+ let res = [];
+ let vis = new Array(10).fill(0)
+ let check = (hour,minutes) => {
+ if(hour>=0 && hour<=11 && minutes>=0 && minutes<=59) return true;
+ return false;
+ }
+ let dfs = (t,cnt,vis) => {
+ if(t==0){
+ let hour = vis[0]*1 + vis[1]*2 + vis[2]*4 + vis[3]*8;
+ let minutes = vis[4]*1 + vis[5]*2 + vis[6]*4 + vis[7]*8 + vis[8]*16 + vis[9]*32;
+ if(check(hour,minutes)){
+ let tmp = `${hour}:${minutes >= 10? minutes: '0'+minutes}`;
+ res.push(tmp);
+ }
+ return;
+ }
+ for(let i=cnt;i<=10-t;i++){
+ if(vis[i]) continue;
+ vis[i] = 1;
+ dfs(t-1,i+1,vis);
+ vis[i] = 0;
+ }
+ }
+ dfs(num,0,vis);
+ return res;
+};
+```
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 585f2bbccbe61e02e6906f5b02bf01f40bd11d9a Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Fri, 18 Sep 2020 14:26:25 +0800
Subject: [PATCH 18/87] =?UTF-8?q?add=20LeetCode=2090.=20=E5=AD=90=E9=9B=86?=
=?UTF-8?q?=20II?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...etCode 90. \345\255\220\351\233\206 II.md" | 75 +++++++++++++++++++
1 file changed, 75 insertions(+)
create mode 100644 "\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 90. \345\255\220\351\233\206 II.md"
diff --git "a/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 90. \345\255\220\351\233\206 II.md" "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 90. \345\255\220\351\233\206 II.md"
new file mode 100644
index 0000000..694569a
--- /dev/null
+++ "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 90. \345\255\220\351\233\206 II.md"
@@ -0,0 +1,75 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+给定一个可能包含重复元素的整数数组 `nums`，返回该数组所有可能的子集（幂集）。
+
+说明：解集不能包含重复的子集。
+
+示例:
+
+```javascript
+输入: [1,2,2]
+输出:
+[
+ [2],
+ [1],
+ [1,2,2],
+ [2,2],
+ [1,2],
+ []
+]
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/subsets-ii
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+## 解题思路
+本题还是挺有意思的，我们要求的是子集，但是子集要进行去重操作，采用的做法是先对原数组进行排序，那么排序后的数组重复的元素必定是相邻的，然后在遍历解空间树的时候，要做一个去重的操作，当遇到重复出现，也就是和前面相邻元素相同的时候，直接跳过该节点，不让它向下递归。具体示意图如下：
+
+
+参考大佬题解
+
+`dfs`的话，一条路会一直走下去，然后回溯回来，在走之前，`start`是当前层第一个元素，只有当前元素下标大于 `start`才会有重复元素，而对于不同层的重复元素，我们不应该切断，应该继续走，不然就不会有 `[1,2,2]`这样的子集出现了。
+
+
+```javascript
+var subsetsWithDup = function(nums) {
+ let res = [];
+ nums.sort((a,b)=>a-b);
+ let dfs = (t,start) => {
+ res.push(t);
+ for(let i=start;istart && nums[i-1] == nums[i]) continue;
+ t.push(nums[i]);
+ dfs(t.slice(),i+1);
+ t.pop();
+ }
+ }
+ dfs([],0);
+ return res;
+};
+```
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
+
From c4bf821c23925e4f0a4c516613dc1c3af68524f3 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Fri, 18 Sep 2020 15:14:03 +0800
Subject: [PATCH 19/87] =?UTF-8?q?add=20LeetCode=2047.=20=E5=85=A8=E6=8E=92?=
=?UTF-8?q?=E5=88=97=20II?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...345\205\250\346\216\222\345\210\227 II.md" | 78 +++++++++++++++++++
1 file changed, 78 insertions(+)
create mode 100644 "\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 47. \345\205\250\346\216\222\345\210\227 II.md"
diff --git "a/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 47. \345\205\250\346\216\222\345\210\227 II.md" "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 47. \345\205\250\346\216\222\345\210\227 II.md"
new file mode 100644
index 0000000..ded9613
--- /dev/null
+++ "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 47. \345\205\250\346\216\222\345\210\227 II.md"
@@ -0,0 +1,78 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+给定一个可包含重复数字的序列，返回所有不重复的全排列。
+
+示例:
+
+```javascript
+输入: [1,1,2]
+输出:
+[
+ [1,1,2],
+ [1,2,1],
+ [2,1,1]
+]
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/permutations-ii
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+## 解题思路
+本题是求全排列，并且排列不能重复。我们用一个 `vis`数组维护一下，让每一条路线保证不重复选取元素，而对于每一层而言，需要判断相邻元素是否相同，相同的就没必要走了，例如下图中红色三角形部分。
+
+
+果当前的选项 `nums[i]` ，与同一层的上一个选项 `nums[i - 1]` 相同，且 `nums[i - 1]`有意义（即索引 `>= 0`），且没有被使用过，那就跳过该选项。
+
+因为 `nums[i - 1]`如果被使用过，它会被修剪掉，不是一个选项了，即便它和 `nums[i]`重复，`nums[i]`还是可以选的。
+
+
+
+
+参考xiao_ben_zhu大佬题解
+
+```javascript
+var permuteUnique = function(nums) {
+ let res = [];
+ nums.sort((a,b) => a-b);
+ let vis = {};
+ let dfs = (t) => {
+ if(t.length === nums.length){
+ res.push(t);
+ }
+ for(let i=0;i=0 && nums[i] == nums[i-1] && !vis[i-1]) continue;
+ if(vis[i]) continue;
+ vis[i] = true;
+ t.push(nums[i]);
+ dfs(t.slice(),i+1);
+ t.pop();
+ vis[i] = false;
+ }
+ }
+ dfs([],0);
+ return res;
+};
+```
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From c02e94e6335ebe5819ac9d355293b8eccf6bd09a Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Fri, 18 Sep 2020 15:48:54 +0800
Subject: [PATCH 20/87] =?UTF-8?q?add=20LeetCode=20216.=20=E7=BB=84?=
=?UTF-8?q?=E5=90=88=E6=80=BB=E5=92=8C=20III?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...45\220\210\346\200\273\345\222\214 III.md" | 74 +++++++++++++++++++
1 file changed, 74 insertions(+)
create mode 100644 "\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 216. \347\273\204\345\220\210\346\200\273\345\222\214 III.md"
diff --git "a/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 216. \347\273\204\345\220\210\346\200\273\345\222\214 III.md" "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 216. \347\273\204\345\220\210\346\200\273\345\222\214 III.md"
new file mode 100644
index 0000000..d524b57
--- /dev/null
+++ "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 216. \347\273\204\345\220\210\346\200\273\345\222\214 III.md"
@@ -0,0 +1,74 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+找出所有相加之和为 `n` 的 `k` 个数的组合。组合中只允许含有 `1 - 9` 的正整数，并且每种组合中不存在重复的数字。
+
+说明：
+
+所有数字都是正整数。
+解集不能包含重复的组合。
+示例 1:
+
+```javascript
+输入: k = 3, n = 7
+输出: [[1,2,4]]
+```
+
+示例 2:
+
+```javascript
+输入: k = 3, n = 9
+输出: [[1,2,6], [1,3,5], [2,3,4]]
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/combination-sum-iii
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+
+## 解题思路
+首先，还是搬运一下大佬的图解，然后我再来解释一番。
+
+参考xiao_ben_zhu大佬图解
+
+本题需要一层一层来，第一层我们可以有 `i`(1-9)个选择，而第二层的每一个值只有 `i+1`个选择了，因为不能重复。比如你第一次拿了 `2`，在下一次，你只能从 `3`开始拿了，如果还是 `1`的话就会有重复的组合了。这样我们也不用维护 `vis`数组来去重，因为每一层取的值是不一样的。
+
+```javascript
+var combinationSum3 = function (k, n) {
+ let res = [];
+ let dfs = (t, start, sum) => {
+ if (t.length === k && sum === n) {
+ res.push(t);
+ }
+ for (let i = start; i < 10; i++) {
+ t.push(i);
+ dfs(t.slice(), i + 1, sum + i);
+ t.pop();
+ }
+ }
+ dfs([], 1, 0);
+ return res;
+};
+```
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 77a5a0b57670ef496e5bdc6f2cc1c6decc3368d5 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Fri, 18 Sep 2020 16:37:41 +0800
Subject: [PATCH 21/87] =?UTF-8?q?add=20LeetCode=2040.=20=E7=BB=84=E5=90=88?=
=?UTF-8?q?=E6=80=BB=E5=92=8C=20II?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...345\220\210\346\200\273\345\222\214 II.md" | 95 +++++++++++++++++++
1 file changed, 95 insertions(+)
create mode 100644 "\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 40. \347\273\204\345\220\210\346\200\273\345\222\214 II.md"
diff --git "a/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 40. \347\273\204\345\220\210\346\200\273\345\222\214 II.md" "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 40. \347\273\204\345\220\210\346\200\273\345\222\214 II.md"
new file mode 100644
index 0000000..652f994
--- /dev/null
+++ "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 40. \347\273\204\345\220\210\346\200\273\345\222\214 II.md"
@@ -0,0 +1,95 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+给定一个数组 `candidates `和一个目标数 target ，找出` candidates` 中所有可以使数字和为` target `的组合。
+
+`candidates `中的每个数字在每个组合中只能使用一次。
+
+说明：
+
+所有数字（包括目标数）都是正整数。
+解集不能包含重复的组合。
+示例 1:
+
+```javascript
+输入: candidates = [10,1,2,7,6,1,5], target = 8,
+所求解集为:
+[
+ [1, 7],
+ [1, 2, 5],
+ [2, 6],
+ [1, 1, 6]
+]
+```
+
+示例 2:
+
+```javascript
+输入: candidates = [2,5,2,1,2], target = 5,
+所求解集为:
+[
+ [1,2,2],
+ [5]
+]
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/combination-sum-ii
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+## 解题思路
+
+这道题也是一道组合题，但是这道题数组里面是存在重复元素的，组合题的话，为了更好地去重，我们可以先对数组进行排序，然后对于每一层如果相邻元素相同，就剪掉该分支即可。
+
+参考xiao_ben_zhu大佬图解
+
+注意求和那里，如果只判断是否相等的话，可能会出现爆掉情况。
+
+
+```javascript
+var combinationSum2 = function (candidates, target) {
+ let res = [];
+ candidates.sort((a, b) => a - b);
+ let dfs = (t, start, sum) => {
+ if (sum >= target) { // 加这外层，超出范围了也终止，防爆栈
+ if (sum === target) {
+ res.push(t);
+ }
+ return;
+ }
+ // 组合
+ for (let i = start; i < candidates.length; i++) {
+ // 组合元素不能重复，去掉同一层重复的元素
+ if (i > start && candidates[i] == candidates[i - 1]) continue;
+ t.push(candidates[i]);
+ // 组合元素去重，即当前选择和下一层的不能重复
+ dfs(t.slice(), i + 1, sum + candidates[i]);
+ t.pop();
+ }
+ }
+ dfs([], 0, 0);
+ return res;
+};
+```
+
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 989365f2b7cdbafee3142fd29af62d27d6126034 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Fri, 18 Sep 2020 17:01:11 +0800
Subject: [PATCH 22/87] =?UTF-8?q?add=20LeetCode=2039.=20=E7=BB=84=E5=90=88?=
=?UTF-8?q?=E6=80=BB=E5=92=8C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...04\345\220\210\346\200\273\345\222\214.md" | 106 ++++++++++++++++++
1 file changed, 106 insertions(+)
create mode 100644 "\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 39. \347\273\204\345\220\210\346\200\273\345\222\214.md"
diff --git "a/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 39. \347\273\204\345\220\210\346\200\273\345\222\214.md" "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 39. \347\273\204\345\220\210\346\200\273\345\222\214.md"
new file mode 100644
index 0000000..0a625a4
--- /dev/null
+++ "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 39. \347\273\204\345\220\210\346\200\273\345\222\214.md"
@@ -0,0 +1,106 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+给定一个无重复元素的数组 `candidates` 和一个目标数 `target` ，找出 `candidates` 中所有可以使数字和为 `target` 的组合。
+
+`candidates` 中的数字可以无限制重复被选取。
+
+说明：
+
+```javascript
+所有数字（包括 target）都是正整数。
+解集不能包含重复的组合。
+```
+
+示例 1：
+
+```javascript
+输入：candidates = [2,3,6,7], target = 7,
+所求解集为：
+[
+ [7],
+ [2,2,3]
+]
+```
+
+示例 2：
+
+```javascript
+输入：candidates = [2,3,5], target = 8,
+所求解集为：
+[
+ [2,2,2,2],
+ [2,3,3],
+ [3,5]
+]
+```
+
+
+
+提示：
+
+```javascript
+1 <= candidates.length <= 30
+1 <= candidates[i] <= 200
+candidate 中的每个元素都是独一无二的。
+1 <= target <= 500
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/combination-sum
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+## 解题思路
+这道题是组合题，但是这道题有意思的是当前元素可以重复无限制选取，那么我们可以改一下另外一道组合题的思路，下一层也从 `i`开始即可，然后本题元素重复，那么我们不需要进行排序然后剪枝了。
+
+```javascript
+// 当前元素可以无限制选取，下一层也从i开始取
+dfs(t.slice(),i,sum+candidates[i]);
+```
+
+
+参考xiao_ben_zhu图解
+
+```javascript
+var combinationSum = function(candidates, target) {
+ let res = [];
+ let dfs = (t,start,sum) => {
+ if(sum >= target){ // 防止爆掉
+ if(sum === target){
+ res.push(t);
+ }
+ return;
+ }
+ for(let i=start;i小狮子前端の笔记仓库
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From e5ef29269ca1a418bf7aeed3aabc1f0d55027b97 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Fri, 18 Sep 2020 20:22:17 +0800
Subject: [PATCH 23/87] =?UTF-8?q?add=20LeetCode=2078.=20=E5=AD=90=E9=9B=86?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../LeetCode 78. \345\255\220\351\233\206.md" | 68 +++++++++++++++++++
1 file changed, 68 insertions(+)
create mode 100644 "\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 78. \345\255\220\351\233\206.md"
diff --git "a/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 78. \345\255\220\351\233\206.md" "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 78. \345\255\220\351\233\206.md"
new file mode 100644
index 0000000..c6a3b52
--- /dev/null
+++ "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 78. \345\255\220\351\233\206.md"
@@ -0,0 +1,68 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。
+
+说明：解集不能包含重复的子集。
+
+示例:
+
+```clike
+输入: nums = [1,2,3]
+输出:
+[
+ [3],
+ [1],
+ [2],
+ [1,2,3],
+ [1,3],
+ [2,3],
+ [1,2],
+ []
+]
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/subsets
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+## 解题思路
+一道组合相关的题目，采用回溯来做即可，题目说明不包含重复元素，于是我们也无需排序然后判断相邻元素是否相等来去重了。
+
+```javascript
+var subsets = function(nums) {
+ let res = [];
+ let dfs = (t,start) => {
+ res.push(t);
+ for(let i=start;i小狮子前端の笔记仓库
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 39ce780cb123bb1e19fa7446336ca3c8df834884 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Fri, 18 Sep 2020 20:29:17 +0800
Subject: [PATCH 24/87] =?UTF-8?q?add=20LeetCode=2077.=20=E7=BB=84=E5=90=88?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../LeetCode 77. \347\273\204\345\220\210.md" | 68 +++++++++++++++++++
1 file changed, 68 insertions(+)
create mode 100644 "\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 77. \347\273\204\345\220\210.md"
diff --git "a/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 77. \347\273\204\345\220\210.md" "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 77. \347\273\204\345\220\210.md"
new file mode 100644
index 0000000..d1ec638
--- /dev/null
+++ "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 77. \347\273\204\345\220\210.md"
@@ -0,0 +1,68 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+给定两个整数 n 和 k，返回 1 ... n 中所有可能的 k 个数的组合。
+
+示例:
+
+```javascript
+输入: n = 4, k = 2
+输出:
+[
+ [2,4],
+ [3,4],
+ [2,3],
+ [1,2],
+ [1,3],
+ [1,4],
+]
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/combinations
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+## 解题思路
+直接套用组合题解题模板即可
+
+```javascript
+var combine = function (n, k) {
+ let res = [];
+ let dfs = (t, start) => {
+ if (t.length === k) {
+ res.push(t);
+ return;
+ }
+ for (let i = start; i <= n; i++) {
+ t.push(i);
+ dfs(t.slice(), i + 1);
+ t.pop();
+ }
+ }
+ dfs([], 1);
+ return res;
+};
+```
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
+
From c50857310b7f7dc3a55fac6f7cae5564e517fe67 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Fri, 18 Sep 2020 20:35:03 +0800
Subject: [PATCH 25/87] =?UTF-8?q?add=20LeetCode=2046.=20=E5=85=A8=E6=8E=92?=
=?UTF-8?q?=E5=88=97?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.... \345\205\250\346\216\222\345\210\227.md" | 70 +++++++++++++++++++
1 file changed, 70 insertions(+)
create mode 100644 "\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 46. \345\205\250\346\216\222\345\210\227.md"
diff --git "a/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 46. \345\205\250\346\216\222\345\210\227.md" "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 46. \345\205\250\346\216\222\345\210\227.md"
new file mode 100644
index 0000000..cd9def4
--- /dev/null
+++ "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 46. \345\205\250\346\216\222\345\210\227.md"
@@ -0,0 +1,70 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+给定一个 没有重复 数字的序列，返回其所有可能的全排列。
+
+示例:
+
+```javascript
+输入: [1,2,3]
+输出:
+[
+ [1,2,3],
+ [1,3,2],
+ [2,1,3],
+ [2,3,1],
+ [3,1,2],
+ [3,2,1]
+]
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/permutations
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+## 解题思路
+序列不重复就很简单了，维护一个 `vis`数组，不重复取就好了。
+
+```javascript
+var permute = function (nums) {
+ let res = [];
+ let vis = {};
+ let dfs = (t) => {
+ if (t.length == nums.length) {
+ res.push(t);
+ }
+ for (let i = 0; i < nums.length; i++) {
+ if (vis[i]) continue;
+ vis[i] = true;
+ t.push(nums[i]);
+ dfs(t.slice());
+ t.pop();
+ vis[i] = false;
+ }
+ }
+ dfs([]);
+ return res;
+};
+```
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From e7db25cff287e6392f92176c6c4ba3803c418d5d Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Fri, 18 Sep 2020 21:43:28 +0800
Subject: [PATCH 26/87] =?UTF-8?q?add=20LeetCode=2037.=20=E8=A7=A3=E6=95=B0?=
=?UTF-8?q?=E7=8B=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.... \350\247\243\346\225\260\347\213\254.md" | 98 +++++++++++++++++++
1 file changed, 98 insertions(+)
create mode 100644 "\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 37. \350\247\243\346\225\260\347\213\254.md"
diff --git "a/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 37. \350\247\243\346\225\260\347\213\254.md" "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 37. \350\247\243\346\225\260\347\213\254.md"
new file mode 100644
index 0000000..c733f6e
--- /dev/null
+++ "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 37. \350\247\243\346\225\260\347\213\254.md"
@@ -0,0 +1,98 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+编写一个程序，通过填充空格来解决数独问题。
+
+一个数独的解法需**遵循如下规则**：
+
+数字 1-9 在每一行只能出现一次。
+数字 1-9 在每一列只能出现一次。
+数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。
+空白格用 ` '.'` 表示。
+
+
+一个数独。
+
+
+答案被标成红色。
+
+提示：
+
+```javascript
+给定的数独序列只包含数字 1-9 和字符 '.' 。
+你可以假设给定的数独只有唯一解。
+给定数独永远是 9x9 形式的。
+```
+
+
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/sudoku-solver
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+## 解题思路
+我们一行一行的放，如果能得到一个解，直接返回 `true`，然后剪枝条件如下述 `check`函数。
+
+参考xiao_ben_zhu大佬图解
+
+```javascript
+var solveSudoku = function (board) {
+ let check = (x, y, val) => {
+ // 一行或者一列有重复元素，剪掉
+ for (let i = 0; i < 9; i++) {
+ if (board[x][i] == val || board[i][y] == val) return true;
+ }
+ let xx = Math.floor(x / 3) * 3;
+ let yy = Math.floor(y / 3) * 3;
+ // 3x3宫格内重复的情况，剪掉
+ for (let i = 0; i < 3; i++) {
+ for (let j = 0; j < 3; j++) {
+ if (board[xx + i][yy + j] == val) return true;
+ }
+ }
+ return false; // 没有冲突情况
+ }
+ let dfs = (x, y) => {
+ if (y == 9) {
+ x++;
+ y = 0;
+ if (x == 9) return true; // 都填完了，直接返回 true
+ }
+ if (board[x][y] != '.') return dfs(x, y + 1);
+ for (let i = 1; i < 10; i++) {
+ if (check(x, y, String(i))) continue;
+ board[x][y] = String(i);
+ if (dfs(x, y + 1)) return true; // 如果往下走，能够解出数独，直接返回 true
+ board[x][y] = '.'; // 回溯，因为往下走得不到一个解
+ }
+ return false;
+ }
+ dfs(0, 0);
+ return board;
+};
+```
+
+
+
+
+
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 94b1259961e9b3e288e9508018878d15a292edda Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Fri, 18 Sep 2020 23:00:18 +0800
Subject: [PATCH 27/87] =?UTF-8?q?add=20LeetCode=2051.=20N=20=E7=9A=87?=
=?UTF-8?q?=E5=90=8E?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...eetCode 51. N \347\232\207\345\220\216.md" | 110 ++++++++++++++++++
1 file changed, 110 insertions(+)
create mode 100644 "\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 51. N \347\232\207\345\220\216.md"
diff --git "a/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 51. N \347\232\207\345\220\216.md" "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 51. N \347\232\207\345\220\216.md"
new file mode 100644
index 0000000..de7c6d5
--- /dev/null
+++ "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 51. N \347\232\207\345\220\216.md"
@@ -0,0 +1,110 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。
+
+
+上图为 8 皇后问题的一种解法。
+
+给定一个整数 n，返回所有不同的 n 皇后问题的解决方案。
+
+每一种解法包含一个明确的 n 皇后问题的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。
+
+
+
+示例：
+
+```javascript
+输入：4
+输出：[
+ [".Q..", // 解法 1
+ "...Q",
+ "Q...",
+ "..Q."],
+
+ ["..Q.", // 解法 2
+ "Q...",
+ "...Q",
+ ".Q.."]
+]
+解释: 4 皇后问题存在两个不同的解法。
+```
+
+
+
+提示：
+
+```javascript
+皇后彼此不能相互攻击，也就是说：任何两个皇后都不能处于同一条横行、纵行或斜线上。
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/n-queens
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+## 解题思路
+对于 n 皇后问题，经典的回溯算法，我们采用一行放一个，然后逐行来放，这样我们就不用在剪枝的时候判断是否同行了。只需要判断是否同列 或者 同一斜线就好了。
+
+参考xiao_ben_zhu大佬图解
+
+
+
+```javascript
+var solveNQueens = function(n) {
+ let res = [];
+ let grid = new Array(n); // 初始化一个地图
+ for(let i=0;i{
+ for(let i=0;i {
+ if(t === n ){
+ let ans = grid.slice(); // 拷贝一份，对输出做处理
+ for(let i=0;i小狮子前端の笔记仓库
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From d5f0ebde17bd9281d008ecfacac97e0b13602985 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Thu, 24 Sep 2020 14:28:11 +0800
Subject: [PATCH 28/87] =?UTF-8?q?add=20LeetCode=20131.=20=E5=88=86?=
=?UTF-8?q?=E5=89=B2=E5=9B=9E=E6=96=87=E4=B8=B2?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...62\345\233\236\346\226\207\344\270\262.md" | 98 +++++++++++++++++++
1 file changed, 98 insertions(+)
create mode 100644 "\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 131. \345\210\206\345\211\262\345\233\236\346\226\207\344\270\262.md"
diff --git "a/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 131. \345\210\206\345\211\262\345\233\236\346\226\207\344\270\262.md" "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 131. \345\210\206\345\211\262\345\233\236\346\226\207\344\270\262.md"
new file mode 100644
index 0000000..e19acfe
--- /dev/null
+++ "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 131. \345\210\206\345\211\262\345\233\236\346\226\207\344\270\262.md"
@@ -0,0 +1,98 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+给定一个字符串 `s`，将 `s` 分割成一些子串，使每个子串都是回文串。
+
+返回 s 所有可能的分割方案。
+
+示例:
+
+```javascript
+输入: "aab"
+输出:
+[
+ ["aa","b"],
+ ["a","a","b"]
+]
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/palindrome-partitioning
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+## 解题思路
+借鉴 zesong-wang-c 大佬的图解
+
+本题采用回溯思想，看上图基本已经明白，每次进行一次切割，直到切到最后一个元素，然后压入结果集合里，期间对于每次切割的字符串，我们判断一下是否是回文，如果不是，直接减掉即可。
+
+和组合的思想有点类似。
+
+```javascript
+// 判断是否是回文
+function isPal(str) {
+ let len = Math.floor(str.length / 2);
+ if (len === 0) {
+ return true;
+ }
+ let add = str.length % 2 === 0 ? 0 : 1;
+ let subStr = str.slice(0, len);
+ for (let i = 0; i < len; i++) {
+ if (subStr[len - i - 1] !== str[len + add + i]) {
+ return false;
+ }
+ }
+ return true;
+}
+var partition = function (s) {
+ let res = [];
+ let dfs = (cur, start) => {
+ // 当前已经到达了最后一个元素
+ if (start >= s.length) {
+ res.push(cur.slice());
+ return;
+ }
+ for (let i = start; i < s.length; i++) {
+ // 字符串切割
+ let str = s.slice(start, i + 1);
+ if (str && isPal(str) ) {
+ cur.push(str);
+ dfs(cur, i + 1);
+ // 回溯
+ cur.pop();
+ }
+ }
+ }
+ dfs([], 0);
+ return res;
+};
+```
+
+
+
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From e09fade5ae14c286313788fa15499468a6d9a5c4 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Thu, 24 Sep 2020 14:59:47 +0800
Subject: [PATCH 29/87] =?UTF-8?q?add=20LeetCode=2093.=20=E5=A4=8D=E5=8E=9F?=
=?UTF-8?q?IP=E5=9C=B0=E5=9D=80?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...\345\216\237IP\345\234\260\345\235\200.md" | 120 ++++++++++++++++++
1 file changed, 120 insertions(+)
create mode 100644 "\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 93. \345\244\215\345\216\237IP\345\234\260\345\235\200.md"
diff --git "a/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 93. \345\244\215\345\216\237IP\345\234\260\345\235\200.md" "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 93. \345\244\215\345\216\237IP\345\234\260\345\235\200.md"
new file mode 100644
index 0000000..9ff2351
--- /dev/null
+++ "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 93. \345\244\215\345\216\237IP\345\234\260\345\235\200.md"
@@ -0,0 +1,120 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。
+
+有效的 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。
+
+例如：`"0.1.2.201" 和 "192.168.1.1"` 是 有效的 IP 地址，但是 `"0.011.255.245"、"192.168.1.312" 和 "192.168@1.1" ` 是 无效的 IP 地址。
+
+
+
+示例 1：
+
+```javascript
+输入：s = "25525511135"
+输出：["255.255.11.135","255.255.111.35"]
+```
+
+示例 2：
+
+```javascript
+输入：s = "0000"
+输出：["0.0.0.0"]
+```
+
+示例 3：
+
+```javascript
+输入：s = "1111"
+输出：["1.1.1.1"]
+```
+
+示例 4：
+
+```javascript
+输入：s = "010010"
+输出：["0.10.0.10","0.100.1.0"]
+```
+
+示例 5：
+
+```javascript
+输入：s = "101023"
+输出：["1.0.10.23","1.0.102.3","10.1.0.23","10.10.2.3","101.0.2.3"]
+
+```
+
+提示：
+
+```javascript
+0 <= s.length <= 3000
+s 仅由数字组成
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/restore-ip-addresses
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+
+## 解题思路
+直接看图解，显然要用回溯来做，我的做法是对于当前位置，我们可以有三种选择，选一个，选两个，还有选三个。此时就需要判断一下是不是会出现选出边界的情况。
+
+然后对于我们选择的数字，要判断是否出现前导 0 ，同时也要看一下如果是三位数字的话，是不是会超过 255 。题目不能重复选择，于是用组合思想，免去 `vis` 数组。
+
+借助大佬 xiao_ben_zhu 图解
+
+```javascript
+var restoreIpAddresses = function (s) {
+ let res = [];
+ let dfs = (cur, start) => {
+ if (cur.length == 4 && start>=s.length) {
+ res.push(cur.join('.'));
+ return;
+ }
+ if(cur.length == 4 && start != s.length) return;
+ for(let k=1;k<=3;k++){
+ // 如果取的范围超过了字符串长度，直接剪掉
+ if(start+k-1>=s.length) return;
+ // 切割字符串
+ let str = s.substring(start,start+k);
+ if(str.length>=2 && str[0] == 0) return;
+ if(str.length>=3 && +str > 255) return;
+ cur.push(str);
+ dfs(cur.slice(),start+k);
+ // 回溯
+ cur.pop();
+ }
+ }
+ dfs([], 0);
+ return res;
+};
+```
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
+a
\ No newline at end of file
From 83113402ec7ecb661c445d516e492e17f93aca10 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Thu, 24 Sep 2020 15:21:47 +0800
Subject: [PATCH 30/87] =?UTF-8?q?add=20LeetCode=2017.=20=E7=94=B5=E8=AF=9D?=
=?UTF-8?q?=E5=8F=B7=E7=A0=81=E7=9A=84=E5=AD=97=E6=AF=8D=E7=BB=84=E5=90=88?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...27\346\257\215\347\273\204\345\220\210.md" | 102 ++++++++++++++++++
1 file changed, 102 insertions(+)
create mode 100644 "\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 17. \347\224\265\350\257\235\345\217\267\347\240\201\347\232\204\345\255\227\346\257\215\347\273\204\345\220\210.md"
diff --git "a/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 17. \347\224\265\350\257\235\345\217\267\347\240\201\347\232\204\345\255\227\346\257\215\347\273\204\345\220\210.md" "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 17. \347\224\265\350\257\235\345\217\267\347\240\201\347\232\204\345\255\227\346\257\215\347\273\204\345\220\210.md"
new file mode 100644
index 0000000..99b6479
--- /dev/null
+++ "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 17. \347\224\265\350\257\235\345\217\267\347\240\201\347\232\204\345\255\227\346\257\215\347\273\204\345\220\210.md"
@@ -0,0 +1,102 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。
+
+给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
+
+
+
+
+示例:
+
+```javascript
+输入："23"
+输出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].
+```
+
+说明:
+
+```javascript
+尽管上面的答案是按字典序排列的，但是你可以任意选择答案输出的顺序。
+```
+
+
+## 解题思路
+
+采用回溯做法，对于当前选项，我们可以重复选择，所以 `for` 循环那里从 0 开始，对于字母组合我们做一个 `map`映射即可。
+
+
+
+
+参考 xiao_ben_zhu 大佬的图解
+
+```javascript
+var letterCombinations = function (digits) {
+ if(!digits.length) return [];
+ // 直接映射
+ const map = { '2': 'abc', '3': 'def', '4': 'ghi', '5': 'jkl', '6': 'mno', '7': 'pqrs', '8': 'tuv', '9': 'wxyz' };
+ let res = [];
+ let dfs = (cur, start) => {
+ if (start >= digits.length) {
+ res.push(cur);
+ return;
+ }
+ // 取当前可选的字母组合
+ let str = map[digits[start]];
+ for (let i = 0; i < str.length; i++) {
+ dfs(cur + str[i], start + 1);
+ }
+ }
+ dfs('', 0);
+ return res;
+};
+```
+解法2
+
+这个是没用回溯之前写的一份代码，简单来说就是利用了**层次遍历**的特性，反正每次取字母都是可以重复的，直接遍历即可，然后进队列。
+
+```javascript
+var letterCombinations = function(digits) {
+ if(!digits.length) return []
+ const map = { '2': 'abc', '3': 'def', '4': 'ghi', '5': 'jkl', '6': 'mno', '7': 'pqrs', '8': 'tuv', '9': 'wxyz' };
+ let queue = []
+ queue.push('')
+ for(let i=0;i小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
+
From b09efc41a6412d8f62cc6bee1b2765bdde035eb1 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Thu, 24 Sep 2020 15:49:27 +0800
Subject: [PATCH 31/87] =?UTF-8?q?add=20LeetCode=2022.=20=E6=8B=AC=E5=8F=B7?=
=?UTF-8?q?=E7=94=9F=E6=88=90?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...54\345\217\267\347\224\237\346\210\220.md" | 79 +++++++++++++++++++
1 file changed, 79 insertions(+)
create mode 100644 "\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 22. \346\213\254\345\217\267\347\224\237\346\210\220.md"
diff --git "a/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 22. \346\213\254\345\217\267\347\224\237\346\210\220.md" "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 22. \346\213\254\345\217\267\347\224\237\346\210\220.md"
new file mode 100644
index 0000000..1ce4057
--- /dev/null
+++ "b/\351\200\222\345\275\222\344\270\216\345\233\236\346\272\257/LeetCode 22. \346\213\254\345\217\267\347\224\237\346\210\220.md"
@@ -0,0 +1,79 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
+
+
+
+示例：
+
+```javascript
+输入：n = 3
+输出：[
+ "((()))",
+ "(()())",
+ "(())()",
+ "()(())",
+ "()()()"
+ ]
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/generate-parentheses
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+
+## 解题思路
+
+这道题，看了大佬的题解，发现真是有意思，现在来解释一下。
+
+我们可以直接走可行的情况，对于不可行的情况，自然就剪掉了。
+
+关键在于左右括号如何选择，首先，对于左括号，起初我们必然是要选的，然后我们也可以全部选完，因此，只要有左括号我们必须选，而对于右括号而言，它的剩余数量必须大于剩余左括号数量，我们才能选右括号。
+
+举个反例，假如我们现在已经有了 `(())`，`n = 3`，然后左右括号都还剩一个，如果理解选 `)`，岂不是就 `(()))`了，显示不是有效的括号，应该被剪掉才是，因此，我们必须严格右括号剩余数量必须大于剩余左括号数量，我们才能选右括号。
+
+参考 笨猪爆破组 大佬图解
+
+```javascript
+var generateParenthesis = function (n) {
+ let res = [];
+ let dfs = (cur, left, right) => {
+ if (cur.length === 2 * n) {
+ res.push(cur);
+ return;
+ }
+ // 左括号还存在，就可以选左括号
+ if (left > 0) dfs(cur + '(', left - 1, right);
+ // 右括号数量要大于左括号，才可以选右括号
+ if (right > left) dfs(cur + ')', left, right - 1);
+ }
+ dfs('', n, n);
+ return res;
+};
+```
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 2041647b20840c4c6a68f53c9790c08102fc5d22 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Thu, 24 Sep 2020 15:56:34 +0800
Subject: [PATCH 32/87] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E6=80=9D=E7=BB=B4?=
=?UTF-8?q?=E5=AF=BC=E5=9B=BE?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
README.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/README.md b/README.md
index 3c97c45..0df652c 100644
--- a/README.md
+++ b/README.md
@@ -11,7 +11,7 @@
>思维导图还在建设完善中ing
-
+
## :snowman:笔记网站（更新）
From 49bb01d5546bb1aae25e1ac5c6c97111d42292fd Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Thu, 24 Sep 2020 18:55:29 +0800
Subject: [PATCH 33/87] =?UTF-8?q?add=20LeetCode=20236.=20=E4=BA=8C?=
=?UTF-8?q?=E5=8F=89=E6=A0=91=E7=9A=84=E6=9C=80=E8=BF=91=E5=85=AC=E5=85=B1?=
=?UTF-8?q?=E7=A5=96=E5=85=88?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...54\345\205\261\347\245\226\345\205\210.md" | 112 ++++++++++++++++++
1 file changed, 112 insertions(+)
create mode 100644 "\344\272\214\345\217\211\346\240\221/LeetCode 236. \344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.md"
diff --git "a/\344\272\214\345\217\211\346\240\221/LeetCode 236. \344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.md" "b/\344\272\214\345\217\211\346\240\221/LeetCode 236. \344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.md"
new file mode 100644
index 0000000..d5c3c9d
--- /dev/null
+++ "b/\344\272\214\345\217\211\346\240\221/LeetCode 236. \344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.md"
@@ -0,0 +1,112 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
+
+百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（**一个节点也可以是它自己的祖先**）。”
+
+例如，给定如下二叉树: `root = [3,5,1,6,2,0,8,null,null,7,4]`
+
+
+
+
+
+
+示例 1:
+
+```javascript
+输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
+输出: 3
+解释: 节点 5 和节点 1 的最近公共祖先是节点 3。
+```
+
+示例 2:
+
+```javascript
+输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
+输出: 5
+解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。
+```
+
+说明:
+
+```javascript
+所有节点的值都是唯一的。
+p、q 为不同节点且均存在于给定的二叉树中。
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+## 解题思路
+根据定义，我们知道，假设 `root` 为 `p、q` 的最近公共祖先，则只可能有如下几种情况：
+
+- p、q 在 root 的子树中，那么 p、q 分在 root 的左右子树中
+- 如果 p = root，那么 q 会在 p 的左右子树中，直接返回 p 即可
+- 如果 q = root，与上述类似
+
+然后我们采用 `后序遍历`的方式，先遍历左右子树，看能不能找到对应 `p` 和 `q` 节点。
+
+如果左右子树都能找到，那么代表p、q 分在 root 的左右子树中，直接返回 root 节点
+如果左子树找到，右子树没找到，那么就返回左子树的查找结果
+如果右子树找到，左子树没找到，那么就返回右子树的查找结果
+
+
+
+参考 Krahets 大佬图解
+
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ * this.val = val;
+ * this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} p
+ * @param {TreeNode} q
+ * @return {TreeNode}
+ */
+var lowestCommonAncestor = function (root, p, q) {
+ if (!root || root == p || root == q) return root;
+ let left = lowestCommonAncestor(root.left, p, q);
+ let right = lowestCommonAncestor(root.right, p, q);
+ // 如果当前root 在左右子树下可以找到 p q 那么这个root就是它们的最近公共祖先
+ if(left && right) return root;
+ // 如果当前root 只有左子树有节点，那么这个节点本身就是p、q的祖先
+ else if(left) return left;
+ // 如果当前root 只有右子树有节点，那么这个节点本身就是p、q的祖先
+ else if(right) return right;
+ // 如果左右子树都找不到p、q，那么这颗树不存在这两个点，直接返回 null 即可
+ //（但本题告知已存在，所以下面这一行代码可写可不写都能通过）
+ return null;
+};
+```
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 22c68f4ed5fe05062863c60c11a28c8c795e8844 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Thu, 24 Sep 2020 19:26:51 +0800
Subject: [PATCH 34/87] =?UTF-8?q?add=20LeetCode=20108.=20=E5=B0=86?=
=?UTF-8?q?=E6=9C=89=E5=BA=8F=E6=95=B0=E7=BB=84=E8=BD=AC=E6=8D=A2=E4=B8=BA?=
=?UTF-8?q?=E4=BA=8C=E5=8F=89=E6=90=9C=E7=B4=A2=E6=A0=91?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...11\346\220\234\347\264\242\346\240\221.md" | 87 +++++++++++++++++++
1 file changed, 87 insertions(+)
create mode 100644 "\344\272\214\345\217\211\346\240\221/LeetCode 108. \345\260\206\346\234\211\345\272\217\346\225\260\347\273\204\350\275\254\346\215\242\344\270\272\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.md"
diff --git "a/\344\272\214\345\217\211\346\240\221/LeetCode 108. \345\260\206\346\234\211\345\272\217\346\225\260\347\273\204\350\275\254\346\215\242\344\270\272\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.md" "b/\344\272\214\345\217\211\346\240\221/LeetCode 108. \345\260\206\346\234\211\345\272\217\346\225\260\347\273\204\350\275\254\346\215\242\344\270\272\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.md"
new file mode 100644
index 0000000..609c8e8
--- /dev/null
+++ "b/\344\272\214\345\217\211\346\240\221/LeetCode 108. \345\260\206\346\234\211\345\272\217\346\225\260\347\273\204\350\275\254\346\215\242\344\270\272\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.md"
@@ -0,0 +1,87 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。
+
+本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。
+
+示例:
+
+```javascript
+给定有序数组: [-10,-3,0,5,9],
+
+一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉搜索树：
+
+ 0
+ / \
+ -3 9
+ / /
+ -10 5
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/convert-sorted-array-to-binary-search-tree
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+## 解题思路
+题目要求高度平衡——构建 root 时，选数组的中间元素作为 root 节点值，即可保证平衡。
+
+类似分治算法一样，对中间位置确定根节点 root ，然后递归左子树和右子树，最终走完后就是我们的高度平衡的子树。
+
+
+参考 笨猪爆破组 大佬题解
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ * this.val = val;
+ * this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {number[]} nums
+ * @return {TreeNode}
+ */
+var sortedArrayToBST = function (nums) {
+ let buildBST = (nums, start, end) => {
+ if (start > end) return null;
+ // 找到中间位置
+ let mid = (start + end) >>> 1;
+ // 创建根节点
+ let root = new TreeNode(nums[mid]);
+ // 构建左子树
+ root.left = buildBST(nums, start, mid - 1);
+ // 构建右子树
+ root.right = buildBST(nums, mid + 1, end);
+ return root;
+ }
+ return buildBST(nums,0,nums.length-1);
+};
+```
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 448ccf43333493f0c5a59274ce4b701572cf4aa0 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Thu, 24 Sep 2020 23:14:23 +0800
Subject: [PATCH 35/87] =?UTF-8?q?add=20LeetCode=20450.=20=E5=88=A0?=
=?UTF-8?q?=E9=99=A4=E4=BA=8C=E5=8F=89=E6=90=9C=E7=B4=A2=E6=A0=91=E4=B8=AD?=
=?UTF-8?q?=E7=9A=84=E8=8A=82=E7=82=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...55\347\232\204\350\212\202\347\202\271.md" | 199 ++++++++++++++++++
1 file changed, 199 insertions(+)
create mode 100644 "\344\272\214\345\217\211\346\240\221/LeetCode 450. \345\210\240\351\231\244\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\350\212\202\347\202\271.md"
diff --git "a/\344\272\214\345\217\211\346\240\221/LeetCode 450. \345\210\240\351\231\244\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\350\212\202\347\202\271.md" "b/\344\272\214\345\217\211\346\240\221/LeetCode 450. \345\210\240\351\231\244\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\350\212\202\347\202\271.md"
new file mode 100644
index 0000000..63121f2
--- /dev/null
+++ "b/\344\272\214\345\217\211\346\240\221/LeetCode 450. \345\210\240\351\231\244\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\350\212\202\347\202\271.md"
@@ -0,0 +1,199 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+给定一个二叉搜索树的根节点 **root** 和一个值 **key**，删除二叉搜索树中的 **key** 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。
+
+一般来说，删除节点可分为两个步骤：
+
+首先找到需要删除的节点；
+如果找到了，删除它。
+说明： 要求算法时间复杂度为 O(h)，h 为树的高度。
+
+示例:
+
+```javascript
+root = [5,3,6,2,4,null,7]
+key = 3
+
+ 5
+ / \
+ 3 6
+ / \ \
+2 4 7
+
+给定需要删除的节点值是 3，所以我们首先找到 3 这个节点，然后删除它。
+
+一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。
+
+ 5
+ / \
+ 4 6
+ / \
+2 7
+
+另一个正确答案是 [5,2,6,null,4,null,7]。
+
+ 5
+ / \
+ 2 6
+ \ \
+ 4 7
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/delete-node-in-a-bst
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+
+## 解题思路
+对于这道题，我们必须先了解一下二叉搜索树（BST）的性质，如下：
+
+BST性质
+- 中序遍历是升序
+- left小于当前节点，right大于当前节点
+- 左子树、右子树也要是BST
+
+
+了解了性质之后，我们知道要查找对应 `key` 值，可以与根节点进行比较，如果小于根节点，直接去左子树找就好了，如果大于根节点，直接去右子树找就好了。
+
+而对于刚好等于根节点的话，我拿着大佬的图解来看看几种情况：
+
+
+第一种情况，如果删除节点仅有右孩子，直接指向右孩子
+
+第二种情况，如果删除节点仅有左孩子，直接指向左孩子
+
+第三种情况，如果删除节点左右孩子都有，那么我们按照题意可以有两种删除方法：
+
+① 找到要删除节点左子树的最右边的节点，即前驱的最大值（由BST性质得到）替换当前 root 节点，然后删除这个前驱
+
+② 找到要删除节点右子树的最左边的节点，即后继最小值（由BST性质得到）替换当前 root 节点，然后删除这个后继
+
+
+
+
+参考 lulu 大佬图解
+
+代码提供了两种解法，对于前两种情况处理是一样的，只是对于最后一种情况，可以删除前驱的最大值，或者删除后继的最小值。
+
+**删除前驱的最大值代码**
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ * this.val = (val===undefined ? 0 : val)
+ * this.left = (left===undefined ? null : left)
+ * this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} key
+ * @return {TreeNode}
+ */
+var deleteNode = function (root, key) {
+ if (!root) return null;
+ // 判断值是否小于root，小于走左子树，大于走右子树
+ if (key < root.val) {
+ root.left = deleteNode(root.left, key);
+ } else if (key > root.val) {
+ root.right = deleteNode(root.right, key);
+ } else {
+ // 1.如果删除节点没有左右子树，直接删除即可
+ if (!root.left && !root.right) {
+ root = null;
+ // 2.如果删除节点仅有左孩子，直接指向左孩子
+ } else if (root.left && !root.right) {
+ root = root.left;
+ // 3.如果删除节点仅有右孩子，直接指向右孩子
+ } else if (!root.left && root.right) {
+ root = root.right;
+ } else {
+ // 4.如果左右孩子都有，本代码采用方式是将前驱的最大值替换root的值
+ let last = root.left;
+ while (last.right) {
+ last = last.right;
+ }
+ root.val = last.val;
+ // 然后删除这个前驱最大值节点即可
+ root.left = deleteNode(root.left, last.val);
+ }
+ }
+ return root;
+};
+```
+
+
+**删除后继的最小值代码**
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ * this.val = (val===undefined ? 0 : val)
+ * this.left = (left===undefined ? null : left)
+ * this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} key
+ * @return {TreeNode}
+ */
+var deleteNode = function (root, key) {
+ if (!root) return null;
+ // 判断值是否小于root，小于走左子树，大于走右子树
+ if (key < root.val) {
+ root.left = deleteNode(root.left, key);
+ } else if (key > root.val) {
+ root.right = deleteNode(root.right, key);
+ } else {
+ // 1.如果删除节点没有左右子树，直接删除即可
+ if (!root.left && !root.right) {
+ root = null;
+ // 2.如果删除节点仅有左孩子，直接指向左孩子
+ } else if (root.left && !root.right) {
+ root = root.left;
+ // 3.如果删除节点仅有右孩子，直接指向右孩子
+ } else if (!root.left && root.right) {
+ root = root.right;
+ } else {
+ // 4.如果左右孩子都有，本代码采用方式是将后继的最小值替换root的值
+ let last = root.right;
+ while (last.left) {
+ last = last.left;
+ }
+ root.val = last.val;
+ // 然后删除这个后继最小值节点即可
+ root.right = deleteNode(root.right, last.val);
+ }
+ }
+ return root;
+};
+```
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From e474f160864e57fa40a545e7eebb571612eb0834 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Thu, 24 Sep 2020 23:52:51 +0800
Subject: [PATCH 36/87] =?UTF-8?q?add=20LeetCode=20501.=20=E4=BA=8C?=
=?UTF-8?q?=E5=8F=89=E6=90=9C=E7=B4=A2=E6=A0=91=E4=B8=AD=E7=9A=84=E4=BC=97?=
=?UTF-8?q?=E6=95=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...55\347\232\204\344\274\227\346\225\260.md" | 112 ++++++++++++++++++
1 file changed, 112 insertions(+)
create mode 100644 "\344\272\214\345\217\211\346\240\221/LeetCode 501. \344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\344\274\227\346\225\260.md"
diff --git "a/\344\272\214\345\217\211\346\240\221/LeetCode 501. \344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\344\274\227\346\225\260.md" "b/\344\272\214\345\217\211\346\240\221/LeetCode 501. \344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\344\274\227\346\225\260.md"
new file mode 100644
index 0000000..c238526
--- /dev/null
+++ "b/\344\272\214\345\217\211\346\240\221/LeetCode 501. \344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\344\274\227\346\225\260.md"
@@ -0,0 +1,112 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+给定一个有相同值的二叉搜索树（**BST**），找出 **BST** 中的所有众数（出现频率最高的元素）。
+
+假定 BST 有如下定义：
+
+- 结点左子树中所含结点的值小于等于当前结点的值
+- 结点右子树中所含结点的值大于等于当前结点的值
+- 左子树和右子树都是二叉搜索树
+
+例如：
+
+```javascript
+给定 BST [1,null,2,2],
+
+ 1
+ \
+ 2
+ /
+ 2
+返回[2].
+```
+
+提示：如果众数超过1个，不需考虑输出顺序
+
+进阶：你可以不使用额外的空间吗？（假设由递归产生的隐式调用栈的开销不被计算在内）
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/find-mode-in-binary-search-tree
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+
+## 解题思路
+
+由于 `BST`（二叉搜索树）的特殊性，我们采用递归来中序遍历，访问的节点值是有序的。然后重复节点，用计数器进行累加即可，如果有新值出现，则更新新值，然后计数器重置为 1。然后对于当前次数超过了最大值，则更新当前最大值，如果等于最大值，则代表出现了相同频率的数字，加入即可。
+
+如果次数小于最大值，不需要什么操作。
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ * this.val = val;
+ * this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[]}
+ */
+var findMode = function(root) {
+ let cnt = 0;
+ let pre = 0;
+ let res = [];
+ let maxCnt = 0;
+ let handle = (cur) => {
+ // 相同的数，累加
+ if(cur === pre){
+ cnt++;
+ }else{
+ // 有新数出现，重新置计数器为1，更新新数
+ pre = cur;
+ cnt = 1;
+ }
+ // 如果次数超过了最大值，更新当前最大值
+ if(cnt > maxCnt){
+ maxCnt = cnt;
+ res = [cur];
+ // 如果有相同频率的数字出现，直接加入
+ }else if(cnt === maxCnt){
+ res.push(cur);
+ }
+ }
+ // 二叉搜索树，递归中序遍历方式
+ let inOrder = (root) =>{
+ if(!root) return null;
+ inOrder(root.left);
+ handle(root.val);
+ inOrder(root.right);
+ }
+ inOrder(root);
+ return res;
+};
+```
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 7891d79e444c3b99d360ca89a66b10e95a0ddac1 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Fri, 25 Sep 2020 09:23:16 +0800
Subject: [PATCH 37/87] =?UTF-8?q?add=20LeetCode=20437.=20=E8=B7=AF?=
=?UTF-8?q?=E5=BE=84=E6=80=BB=E5=92=8C=20III?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...45\276\204\346\200\273\345\222\214 III.md" | 106 ++++++++++++++++++
1 file changed, 106 insertions(+)
create mode 100644 "\344\272\214\345\217\211\346\240\221/LeetCode 437. \350\267\257\345\276\204\346\200\273\345\222\214 III.md"
diff --git "a/\344\272\214\345\217\211\346\240\221/LeetCode 437. \350\267\257\345\276\204\346\200\273\345\222\214 III.md" "b/\344\272\214\345\217\211\346\240\221/LeetCode 437. \350\267\257\345\276\204\346\200\273\345\222\214 III.md"
new file mode 100644
index 0000000..029cf42
--- /dev/null
+++ "b/\344\272\214\345\217\211\346\240\221/LeetCode 437. \350\267\257\345\276\204\346\200\273\345\222\214 III.md"
@@ -0,0 +1,106 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+给定一个二叉树，它的每个结点都存放着一个整数值。
+
+找出路径和等于给定数值的路径总数。
+
+路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。
+
+二叉树不超过1000个节点，且节点数值范围是 [-1000000,1000000] 的整数。
+
+示例：
+
+```javascript
+root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8
+
+ 10
+ / \
+ 5 -3
+ / \ \
+ 3 2 11
+ / \ \
+3 -2 1
+
+返回 3。和等于 8 的路径有:
+
+1. 5 -> 3
+2. 5 -> 2 -> 1
+3. -3 -> 11
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/path-sum-iii
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+
+## 解题思路
+
+本题采用方式就是先序遍历，对于遍历到的每个节点，我们都进行一次 `dfs`，但是考虑本题的数字范围为负数，对于当前一条路我们得到了一条路径后，假如后面还有路可以走，那么我们还是继续走，因为后面可能出现正负抵消的情况。
+
+面试中如果遇到题例没有明确说明数字范围，建议和面试官沟通。
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ * this.val = (val===undefined ? 0 : val)
+ * this.left = (left===undefined ? null : left)
+ * this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} sum
+ * @return {number}
+ */
+var pathSum = function (root, sum) {
+ // 定义一个计时器
+ let cnt = 0;
+ // 先序遍历所有根节点
+ let preOrder = (root, sum) => {
+ if (root == null) return;
+ dfs(root, sum);
+ preOrder(root.left, sum);
+ preOrder(root.right, sum);
+ }
+ let dfs = (root, sum) => {
+ if (root == null) return;
+ sum -= root.val;
+ // 求和满足，累加
+ if (sum === 0) cnt++;
+ // 递归左右子树，如果当前和为0了，但是下面还是有路，还是继续走下去
+ // 因为本题数值范围存在负数，可能继续走下去还存在满足条件的路径
+ dfs(root.left, sum);
+ dfs(root.right, sum);
+ }
+ preOrder(root, sum);
+ return cnt;
+};
+```
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From d8967f18e6b37edfcd513e0e462afd5677b0a9e6 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Fri, 25 Sep 2020 09:55:43 +0800
Subject: [PATCH 38/87] =?UTF-8?q?add=20LeetCode=20129.=20=E6=B1=82?=
=?UTF-8?q?=E6=A0=B9=E5=88=B0=E5=8F=B6=E5=AD=90=E8=8A=82=E7=82=B9=E6=95=B0?=
=?UTF-8?q?=E5=AD=97=E4=B9=8B=E5=92=8C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...60\345\255\227\344\271\213\345\222\214.md" | 106 ++++++++++++++++++
1 file changed, 106 insertions(+)
create mode 100644 "\344\272\214\345\217\211\346\240\221/LeetCode 129. \346\261\202\346\240\271\345\210\260\345\217\266\345\255\220\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214.md"
diff --git "a/\344\272\214\345\217\211\346\240\221/LeetCode 129. \346\261\202\346\240\271\345\210\260\345\217\266\345\255\220\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214.md" "b/\344\272\214\345\217\211\346\240\221/LeetCode 129. \346\261\202\346\240\271\345\210\260\345\217\266\345\255\220\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214.md"
new file mode 100644
index 0000000..e02f024
--- /dev/null
+++ "b/\344\272\214\345\217\211\346\240\221/LeetCode 129. \346\261\202\346\240\271\345\210\260\345\217\266\345\255\220\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214.md"
@@ -0,0 +1,106 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+给定一个二叉树，它的每个结点都存放一个 `0-9` 的数字，每条从根到叶子节点的路径都代表一个数字。
+
+例如，从根到叶子节点路径 `1->2->3` 代表数字 `123`。
+
+计算从根到叶子节点生成的所有数字之和。
+
+说明: 叶子节点是指没有子节点的节点。
+
+示例 1:
+
+```javascript
+输入: [1,2,3]
+ 1
+ / \
+ 2 3
+输出: 25
+解释:
+从根到叶子节点路径 1->2 代表数字 12.
+从根到叶子节点路径 1->3 代表数字 13.
+因此，数字总和 = 12 + 13 = 25.
+```
+
+示例 2:
+
+```javascript
+输入: [4,9,0,5,1]
+ 4
+ / \
+ 9 0
+ / \
+5 1
+输出: 1026
+解释:
+从根到叶子节点路径 4->9->5 代表数字 495.
+从根到叶子节点路径 4->9->1 代表数字 491.
+从根到叶子节点路径 4->0 代表数字 40.
+因此，数字总和 = 495 + 491 + 40 = 1026.
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/sum-root-to-leaf-numbers
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+## 解题思路
+`dfs`，从根节点开始搜，一直搜到子节点（即没有左右孩子的节点），那么就返回路径值，如果没有到达叶子节点，那么就对当前节点的左右子树进行递归操作，求累计和。
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ * this.val = val;
+ * this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var sumNumbers = function (root) {
+ let sum = 0;
+ let dfs = (cur, root) => {
+ // 终止条件
+ if (root == null) return 0;
+ // 计算当前节点的值
+ cur = cur*10 + root.val;
+ // 找到一条路径，返回路径和
+ if (root.left == null && root.right == null) {
+ return cur;
+ }
+ // 对左右子树递归，求总和
+ return dfs(cur,root.left) + dfs(cur,root.right);
+ }
+ sum = dfs(0, root);
+ return sum;
+};
+```
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 3819e2a1b6de20eb6b2f058d3296ae399c3924d5 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Fri, 25 Sep 2020 10:25:02 +0800
Subject: [PATCH 39/87] =?UTF-8?q?add=20LeetCode=20257.=20=E4=BA=8C?=
=?UTF-8?q?=E5=8F=89=E6=A0=91=E7=9A=84=E6=89=80=E6=9C=89=E8=B7=AF=E5=BE=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...00\346\234\211\350\267\257\345\276\204.md" | 88 +++++++++++++++++++
1 file changed, 88 insertions(+)
create mode 100644 "\344\272\214\345\217\211\346\240\221/LeetCode 257. \344\272\214\345\217\211\346\240\221\347\232\204\346\211\200\346\234\211\350\267\257\345\276\204.md"
diff --git "a/\344\272\214\345\217\211\346\240\221/LeetCode 257. \344\272\214\345\217\211\346\240\221\347\232\204\346\211\200\346\234\211\350\267\257\345\276\204.md" "b/\344\272\214\345\217\211\346\240\221/LeetCode 257. \344\272\214\345\217\211\346\240\221\347\232\204\346\211\200\346\234\211\350\267\257\345\276\204.md"
new file mode 100644
index 0000000..aaf119a
--- /dev/null
+++ "b/\344\272\214\345\217\211\346\240\221/LeetCode 257. \344\272\214\345\217\211\346\240\221\347\232\204\346\211\200\346\234\211\350\267\257\345\276\204.md"
@@ -0,0 +1,88 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+给定一个二叉树，返回所有从根节点到叶子节点的路径。
+
+说明: 叶子节点是指没有子节点的节点。
+
+示例:
+
+```javascript
+输入:
+
+ 1
+ / \
+2 3
+ \
+ 5
+
+输出: ["1->2->5", "1->3"]
+
+解释: 所有根节点到叶子节点的路径为: 1->2->5, 1->3
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/binary-tree-paths
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+## 解题思路
+
+`dfs`，从根节点开始搜，对于非叶子节点，进行累计，如果找到了叶子节点，我们就将结果存起来。通过字符串拼接来存储路径。
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ * this.val = val;
+ * this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {string[]}
+ */
+var binaryTreePaths = function (root) {
+ if (root == null) return [];
+ let res = [];
+ let dfs = (cur, root) => {
+ // 叶子节点，存起来
+ if (root.left == null && root.right == null) {
+ cur += root.val;
+ res.push(cur);
+ return;
+ }
+ cur += root.val + '->'; // 处理非叶子节点
+ // 先遍历左子树，再遍历右子树
+ root.left && dfs(cur, root.left);
+ root.right && dfs(cur, root.right);
+ }
+ dfs('', root);
+ return res;
+};
+```
+
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From aa785e3074d0132949775b345e9f2d6d10d4b67a Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Fri, 25 Sep 2020 10:55:55 +0800
Subject: [PATCH 40/87] =?UTF-8?q?add=20LeetCode=20404.=20=E5=B7=A6?=
=?UTF-8?q?=E5=8F=B6=E5=AD=90=E4=B9=8B=E5=92=8C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...66\345\255\220\344\271\213\345\222\214.md" | 84 +++++++++++++++++++
1 file changed, 84 insertions(+)
create mode 100644 "\344\272\214\345\217\211\346\240\221/LeetCode 404. \345\267\246\345\217\266\345\255\220\344\271\213\345\222\214.md"
diff --git "a/\344\272\214\345\217\211\346\240\221/LeetCode 404. \345\267\246\345\217\266\345\255\220\344\271\213\345\222\214.md" "b/\344\272\214\345\217\211\346\240\221/LeetCode 404. \345\267\246\345\217\266\345\255\220\344\271\213\345\222\214.md"
new file mode 100644
index 0000000..bebce75
--- /dev/null
+++ "b/\344\272\214\345\217\211\346\240\221/LeetCode 404. \345\267\246\345\217\266\345\255\220\344\271\213\345\222\214.md"
@@ -0,0 +1,84 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+计算给定二叉树的所有左叶子之和。
+
+示例：
+
+```javascript
+ 3
+ / \
+ 9 20
+ / \
+ 15 7
+
+在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/sum-of-left-leaves
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+## 解题思路
+
+`dfs`，求左叶子之和，叶子结点我们比较好判断，而对于左孩子，我们设置一个标记就好了，例如左孩子标记 `1`，右孩子标记 `0`，那么当且仅当是叶子节点，并且标记为 `1`（即左孩子）时，我们进行累加求和。
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ * this.val = val;
+ * this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var sumOfLeftLeaves = function (root) {
+ if (!root) return 0;
+ let res = 0;
+ let dfs = (cur,root) => {
+ // 判断是叶子节点并且是左子树
+ if (!root.left && !root.right && cur) {
+ res += root.val;
+ return;
+ }
+ // 先遍历左子树在遍历右子树
+ // 设置cur为1代表是左子树，为0代表右子树
+ root.left && dfs(1,root.left);
+ root.right && dfs(0,root.right);
+ }
+ dfs(0,root);
+ return res;
+};
+```
+
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 9116dde68eca1d25159b5c8b86072bf1f38f7d46 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Fri, 25 Sep 2020 11:04:24 +0800
Subject: [PATCH 41/87] =?UTF-8?q?add=20LeetCode=20112.=20=E8=B7=AF?=
=?UTF-8?q?=E5=BE=84=E6=80=BB=E5=92=8C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...57\345\276\204\346\200\273\345\222\214.md" | 91 +++++++++++++++++++
1 file changed, 91 insertions(+)
create mode 100644 "\344\272\214\345\217\211\346\240\221/LeetCode 112. \350\267\257\345\276\204\346\200\273\345\222\214.md"
diff --git "a/\344\272\214\345\217\211\346\240\221/LeetCode 112. \350\267\257\345\276\204\346\200\273\345\222\214.md" "b/\344\272\214\345\217\211\346\240\221/LeetCode 112. \350\267\257\345\276\204\346\200\273\345\222\214.md"
new file mode 100644
index 0000000..16a3f16
--- /dev/null
+++ "b/\344\272\214\345\217\211\346\240\221/LeetCode 112. \350\267\257\345\276\204\346\200\273\345\222\214.md"
@@ -0,0 +1,91 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。
+
+说明: 叶子节点是指没有子节点的节点。
+
+示例:
+
+```javascript
+给定如下二叉树，以及目标和 sum = 22，
+
+ 5
+ / \
+ 4 8
+ / / \
+ 11 13 4
+ / \ \
+ 7 2 1
+返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2。
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/path-sum
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+## 解题思路
+
+`dfs`，对于非叶子节点，我们直接减去相应权值，到达了叶子节点，我们判断一下即可，如果满足条件，返回 `true`。
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ * this.val = val;
+ * this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} sum
+ * @return {boolean}
+ */
+var hasPathSum = function (root, sum) {
+ if(!root) return false;
+ let res = false;
+ let dfs = (sum, root) => {
+ // 非叶子节点，就减去权值
+ sum -= root.val;
+ // 到达叶子节点，进行判断
+ if (!root.left && !root.right) {
+ if (sum === 0) {
+ res = true;
+ return;
+ }
+ }
+ // 先遍历左子树，再遍历右子树
+ root.left && dfs(sum, root.left);
+ root.right && dfs(sum, root.right);
+ }
+ dfs(sum, root);
+ return res;
+};
+```
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
+
From 74c6ec9fcbbb8eb86f9e777b4d1d0da33b10f694 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Fri, 25 Sep 2020 11:26:36 +0800
Subject: [PATCH 42/87] =?UTF-8?q?add=20LeetCode=20110.=20=E5=B9=B3?=
=?UTF-8?q?=E8=A1=A1=E4=BA=8C=E5=8F=89=E6=A0=91?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...41\344\272\214\345\217\211\346\240\221.md" | 99 +++++++++++++++++++
1 file changed, 99 insertions(+)
create mode 100644 "\344\272\214\345\217\211\346\240\221/LeetCode 110. \345\271\263\350\241\241\344\272\214\345\217\211\346\240\221.md"
diff --git "a/\344\272\214\345\217\211\346\240\221/LeetCode 110. \345\271\263\350\241\241\344\272\214\345\217\211\346\240\221.md" "b/\344\272\214\345\217\211\346\240\221/LeetCode 110. \345\271\263\350\241\241\344\272\214\345\217\211\346\240\221.md"
new file mode 100644
index 0000000..0f89a97
--- /dev/null
+++ "b/\344\272\214\345\217\211\346\240\221/LeetCode 110. \345\271\263\350\241\241\344\272\214\345\217\211\346\240\221.md"
@@ -0,0 +1,99 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+给定一个二叉树，判断它是否是高度平衡的二叉树。
+
+本题中，一棵高度平衡二叉树定义为：
+
+一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。
+
+示例 1:
+
+```javascript
+给定二叉树 [3,9,20,null,null,15,7]
+
+ 3
+ / \
+ 9 20
+ / \
+ 15 7
+返回 true 。
+```
+
+示例 2:
+
+```javascript
+给定二叉树 [1,2,2,3,3,null,null,4,4]
+
+ 1
+ / \
+ 2 2
+ / \
+ 3 3
+ / \
+ 4 4
+返回 false 。
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/balanced-binary-tree
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+## 解题思路
+`dfs`，平衡二叉树就是每个节点 的左右两个子树的高度差的绝对值不超过1。那么，我们可以自底向上，即采用后序遍历的方式，只要左右高度超过1了，直接设置 `flase`即可。
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ * this.val = val;
+ * this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {boolean}
+ */
+var isBalanced = function (root) {
+ if(!root) return true;
+ let res = true;
+ let dfs = (root) => {
+ // 先遍历左子树，在遍历右子树
+ let left = root.left && dfs(root.left) + 1;
+ let right = root.right && dfs(root.right) + 1;
+ // 判断是否是平衡二叉树，就看高度差是否大于1
+ if (Math.abs(left - right) > 1) res = false;
+ // 返回左右子树深度的最大值
+ return Math.max(left, right);
+ }
+ dfs(root);
+ return res;
+};
+```
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 2ba59bbaf6e974a095ed541cd66f40c35806eccf Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Fri, 25 Sep 2020 14:16:06 +0800
Subject: [PATCH 43/87] =?UTF-8?q?add=20LeetCode=20101.=20=E5=AF=B9?=
=?UTF-8?q?=E7=A7=B0=E4=BA=8C=E5=8F=89=E6=A0=91?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...60\344\272\214\345\217\211\346\240\221.md" | 134 ++++++++++++++++++
1 file changed, 134 insertions(+)
create mode 100644 "\344\272\214\345\217\211\346\240\221/LeetCode 101. \345\257\271\347\247\260\344\272\214\345\217\211\346\240\221.md"
diff --git "a/\344\272\214\345\217\211\346\240\221/LeetCode 101. \345\257\271\347\247\260\344\272\214\345\217\211\346\240\221.md" "b/\344\272\214\345\217\211\346\240\221/LeetCode 101. \345\257\271\347\247\260\344\272\214\345\217\211\346\240\221.md"
new file mode 100644
index 0000000..9f29638
--- /dev/null
+++ "b/\344\272\214\345\217\211\346\240\221/LeetCode 101. \345\257\271\347\247\260\344\272\214\345\217\211\346\240\221.md"
@@ -0,0 +1,134 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+给定一个二叉树，检查它是否是镜像对称的。
+
+
+
+例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
+
+```javascript
+ 1
+ / \
+ 2 2
+ / \ / \
+3 4 4 3
+```
+
+
+
+但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
+
+```javascript
+ 1
+ / \
+ 2 2
+ \ \
+ 3 3
+
+```
+
+进阶：
+
+你可以运用递归和迭代两种方法解决这个问题吗？
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/symmetric-tree
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+## 解题思路
+`dfs`，逐层进行比较，即自顶向底找，注意判断几个条件：
+
+- 如果左右节点都为空，可以
+- 如果左右节点一个为空，不可以
+- 如果左右节点值不相等，不可以
+- 最后递归左右子树镜像
+
+
+参考 王尼玛 大佬图解
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ * this.val = val;
+ * this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {boolean}
+ */
+var isSymmetric = function (root) {
+ if (!root) return true;
+ let dfs = (left, right) => {
+ // 如果左右节点都为空，可以
+ if (left == null && right == null) return true;
+ // 如果左右节点一个为空，不可以
+ if(left == null || right == null) return false;
+ // 如果左右节点值不相等，不可以
+ if (left.val !== right.val) return false;
+ // 递归左右子树镜像
+ return dfs(left.left, right.right) && dfs(left.right, right.left);
+ }
+ return dfs(root.left, root.right);
+};
+```
+**解法二**
+
+通过队列逐步一层一层来比较，只要出现不对称的情况，直接返回 `false`。
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ * this.val = val;
+ * this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {boolean}
+ */
+var isSymmetric = function (root) {
+ if (!root) return true
+ let queue = [root.left, root.right]
+ while (queue.length) {
+ let node1 = queue.shift()
+ let node2 = queue.shift()
+ if (!node1 && !node2) continue
+ if (!node1 || !node2 || node1.val !== node2.val) return false
+ queue.push(node1.left)
+ queue.push(node2.right)
+ queue.push(node1.right)
+ queue.push(node2.left)
+ }
+ return true
+};
+```
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 261d11044743831b1a44a0549ee855b5a9b69d35 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Fri, 25 Sep 2020 14:33:15 +0800
Subject: [PATCH 44/87] =?UTF-8?q?add=20LeetCode=20111.=20=E4=BA=8C?=
=?UTF-8?q?=E5=8F=89=E6=A0=91=E7=9A=84=E6=9C=80=E5=B0=8F=E6=B7=B1=E5=BA=A6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...00\345\260\217\346\267\261\345\272\246.md" | 90 +++++++++++++++++++
1 file changed, 90 insertions(+)
create mode 100644 "\344\272\214\345\217\211\346\240\221/LeetCode 111. \344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246.md"
diff --git "a/\344\272\214\345\217\211\346\240\221/LeetCode 111. \344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246.md" "b/\344\272\214\345\217\211\346\240\221/LeetCode 111. \344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246.md"
new file mode 100644
index 0000000..10fc96a
--- /dev/null
+++ "b/\344\272\214\345\217\211\346\240\221/LeetCode 111. \344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246.md"
@@ -0,0 +1,90 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+给定一个二叉树，找出其最小深度。
+
+最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
+
+说明: 叶子节点是指没有子节点的节点。
+
+示例:
+
+```javascript
+给定二叉树 [3,9,20,null,null,15,7],
+
+ 3
+ / \
+ 9 20
+ / \
+ 15 7
+
+```
+返回它的最小深度 2.
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/minimum-depth-of-binary-tree
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+## 解题思路
+
+`dfs`，对于当前节点，判断一下是否有左右孩子，有的话就取左右孩子得到的最小深度，如果只有左孩子，递归左孩子，只有有孩子，则递归右孩子。到子节点时，直接返回 `1`。
+
+
+
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ * this.val = val;
+ * this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var minDepth = function(root) {
+ let dfs = (root) => {
+ if(root == null) return 0;
+ // 左右孩子都有，取左右孩子的最小值
+ if(root.left && root.right){
+ return 1 + Math.min(dfs(root.left),dfs(root.right));
+ }else if(root.left){
+ return 1 + dfs(root.left);
+ }else if(root.right){
+ return 1 + dfs(root.right);
+ }
+ return 1;
+ }
+ return dfs(root);
+};
+```
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From e7d8936fe5354699ab8732c838f216055bcd5634 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Fri, 25 Sep 2020 14:45:07 +0800
Subject: [PATCH 45/87] =?UTF-8?q?add=20LeetCode=20104.=20=E4=BA=8C?=
=?UTF-8?q?=E5=8F=89=E6=A0=91=E7=9A=84=E6=9C=80=E5=A4=A7=E6=B7=B1=E5=BA=A6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...00\345\244\247\346\267\261\345\272\246.md" | 120 ++++++++++++++++++
1 file changed, 120 insertions(+)
create mode 100644 "\344\272\214\345\217\211\346\240\221/LeetCode 104. \344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\244\247\346\267\261\345\272\246.md"
diff --git "a/\344\272\214\345\217\211\346\240\221/LeetCode 104. \344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\244\247\346\267\261\345\272\246.md" "b/\344\272\214\345\217\211\346\240\221/LeetCode 104. \344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\244\247\346\267\261\345\272\246.md"
new file mode 100644
index 0000000..bda8e1e
--- /dev/null
+++ "b/\344\272\214\345\217\211\346\240\221/LeetCode 104. \344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\244\247\346\267\261\345\272\246.md"
@@ -0,0 +1,120 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+给定一个二叉树，找出其最大深度。
+
+二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
+
+说明: 叶子节点是指没有子节点的节点。
+
+示例：
+
+```javascript
+给定二叉树 [3,9,20,null,null,15,7]，
+
+ 3
+ / \
+ 9 20
+ / \
+ 15 7
+```
+
+返回它的最大深度 3 。
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/maximum-depth-of-binary-tree
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+## 解题思路
+
+`dfs`，通过后续遍历求得，但是需要注意最后结果要加上根节点（即加1），并且需要判断一下树是不是为空，树为空的话直接返回 `0` 即可，不加 `1` 。
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ * this.val = val;
+ * this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var maxDepth = function (root) {
+ if(!root) return 0;
+ let dfs = (root) => {
+ if (root == null) return 0;
+ // 后续遍历
+ let left = root.left && dfs(root.left) + 1;
+ let right = root.right && dfs(root.right) + 1;
+
+ return Math.max(left, right);
+ }
+ // 后续遍历结果还要加上根节点（即加1）
+ return dfs(root) + 1;
+};
+```
+
+
+**解法二**
+
+`bfs`，一层一层访问，每加一层计数器就加1，这样到达最后一层了直接返回我们的计数器结果即可。
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ * this.val = val;
+ * this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var maxDepth = function(root) {
+ if(!root) return 0
+ let queue =[root]
+ let cnt = 0
+ while(queue.length){
+ let size = queue.length
+ while(size--){
+ let node = queue.shift()
+ if(node.left) queue.push(node.left)
+ if(node.right) queue.push(node.right)
+ }
+ ++cnt
+ }
+ return cnt
+};
+```
+
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 4786b6edcde63c80084238d4b1b92aa6026596a8 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Fri, 25 Sep 2020 17:46:57 +0800
Subject: [PATCH 46/87] =?UTF-8?q?add=20LeetCode=20199.=20=E4=BA=8C?=
=?UTF-8?q?=E5=8F=89=E6=A0=91=E7=9A=84=E5=8F=B3=E8=A7=86=E5=9B=BE?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...04\345\217\263\350\247\206\345\233\276.md" | 115 ++++++++++++++++++
1 file changed, 115 insertions(+)
create mode 100644 "\344\272\214\345\217\211\346\240\221/LeetCode 199. \344\272\214\345\217\211\346\240\221\347\232\204\345\217\263\350\247\206\345\233\276.md"
diff --git "a/\344\272\214\345\217\211\346\240\221/LeetCode 199. \344\272\214\345\217\211\346\240\221\347\232\204\345\217\263\350\247\206\345\233\276.md" "b/\344\272\214\345\217\211\346\240\221/LeetCode 199. \344\272\214\345\217\211\346\240\221\347\232\204\345\217\263\350\247\206\345\233\276.md"
new file mode 100644
index 0000000..bee5f2b
--- /dev/null
+++ "b/\344\272\214\345\217\211\346\240\221/LeetCode 199. \344\272\214\345\217\211\346\240\221\347\232\204\345\217\263\350\247\206\345\233\276.md"
@@ -0,0 +1,115 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
+
+示例:
+
+```javascript
+输入: [1,2,3,null,5,null,4]
+输出: [1, 3, 4]
+解释:
+
+ 1 <---
+ / \
+2 3 <---
+ \ \
+ 5 4 <---
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/binary-tree-right-side-view
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+## 解题思路
+`DFS`，每一层只能取一个元素，那么我们搜的时候优先考虑右孩子即可。
+
+参考 shetia 大佬图解
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ * this.val = val;
+ * this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[]}
+ */
+var rightSideView = function(root) {
+ if(!root) return [];
+ let res = [];
+ let dfs = (step,root) => {
+ if(res.length === step){
+ res.push(root.val);
+ }
+ // 优先遍历右孩子，再遍历左孩子
+ root.right && dfs(step+1,root.right);
+ root.left && dfs(step+1,root.left);
+ }
+ dfs(0,root);
+ return res;
+};
+```
+
+**解法二**
+
+`BFS`，对于每一层取队列中对首元素，然后放入队列的时候，如果有对应左右孩子的话，优先放右孩子，再放左孩子。
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ * this.val = val;
+ * this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[]}
+ */
+var rightSideView = function (root) {
+ if (!root) return [];
+ let queue = [root];
+ let res = [];
+ while (queue.length) {
+ let size = queue.length;
+ res.push(queue[0].val);
+ while (size--) {
+ let node = queue.shift();
+ // 优先放右孩子
+ node.right && queue.push(node.right);
+ node.left && queue.push(node.left);
+ }
+ }
+ return res;
+};
+```
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
+
From c7a03835772b30999945ceeb054d950acdf2767d Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Fri, 25 Sep 2020 18:00:19 +0800
Subject: [PATCH 47/87] =?UTF-8?q?add=20LeetCode=20144.=20=E4=BA=8C?=
=?UTF-8?q?=E5=8F=89=E6=A0=91=E7=9A=84=E5=89=8D=E5=BA=8F=E9=81=8D=E5=8E=86?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...15\345\272\217\351\201\215\345\216\206.md" | 111 ++++++++++++++++++
1 file changed, 111 insertions(+)
create mode 100644 "\344\272\214\345\217\211\346\240\221/LeetCode 144. \344\272\214\345\217\211\346\240\221\347\232\204\345\211\215\345\272\217\351\201\215\345\216\206.md"
diff --git "a/\344\272\214\345\217\211\346\240\221/LeetCode 144. \344\272\214\345\217\211\346\240\221\347\232\204\345\211\215\345\272\217\351\201\215\345\216\206.md" "b/\344\272\214\345\217\211\346\240\221/LeetCode 144. \344\272\214\345\217\211\346\240\221\347\232\204\345\211\215\345\272\217\351\201\215\345\216\206.md"
new file mode 100644
index 0000000..9231a39
--- /dev/null
+++ "b/\344\272\214\345\217\211\346\240\221/LeetCode 144. \344\272\214\345\217\211\346\240\221\347\232\204\345\211\215\345\272\217\351\201\215\345\216\206.md"
@@ -0,0 +1,111 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+给定一个二叉树，返回它的 前序 遍历。
+
+ 示例:
+
+```javascript
+输入: [1,null,2,3]
+ 1
+ \
+ 2
+ /
+ 3
+
+输出: [1,2,3]
+```
+
+进阶: 递归算法很简单，你可以通过迭代算法完成吗？
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/binary-tree-preorder-traversal
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+
+## 解题思路
+
+**递归解法**
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ * this.val = val;
+ * this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[]}
+ */
+var preorderTraversal = function (root) {
+ if (!root) return [];
+ let res = [];
+ let fun = (root) => {
+ if (root) res.push(root.val);
+ root.left && fun(root.left);
+ root.right && fun(root.right);
+ }
+ fun(root);
+ return res;
+};
+```
+
+**迭代做法**
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ * this.val = val;
+ * this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[]}
+ */
+var preorderTraversal = function (root) {
+ if (!root) return [];
+ let res = [];
+ let queue = [root];
+ while (queue.length) {
+ let size = queue.length;
+ while (size--) {
+ // 取左孩子
+ let node = queue.pop();
+ res.push(node.val);
+ // 优先放右孩子
+ node.right && queue.push(node.right);
+ node.left && queue.push(node.left);
+ }
+ }
+ return res;
+};
+```
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From d82861b99b5f23944c04fba7649838442bd06396 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Fri, 25 Sep 2020 18:22:14 +0800
Subject: [PATCH 48/87] =?UTF-8?q?add=20LeetCode=20102.=20=E4=BA=8C?=
=?UTF-8?q?=E5=8F=89=E6=A0=91=E7=9A=84=E5=B1=82=E5=BA=8F=E9=81=8D=E5=8E=86?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...02\345\272\217\351\201\215\345\216\206.md" | 94 +++++++++++++++++++
1 file changed, 94 insertions(+)
create mode 100644 "\344\272\214\345\217\211\346\240\221/LeetCode 102. \344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\345\272\217\351\201\215\345\216\206.md"
diff --git "a/\344\272\214\345\217\211\346\240\221/LeetCode 102. \344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\345\272\217\351\201\215\345\216\206.md" "b/\344\272\214\345\217\211\346\240\221/LeetCode 102. \344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\345\272\217\351\201\215\345\216\206.md"
new file mode 100644
index 0000000..c53d299
--- /dev/null
+++ "b/\344\272\214\345\217\211\346\240\221/LeetCode 102. \344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\345\272\217\351\201\215\345\216\206.md"
@@ -0,0 +1,94 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+给你一个二叉树，请你返回其按 **层序遍历** 得到的节点值。 （即逐层地，从左到右访问所有节点）。
+
+
+
+示例：
+
+```javascript
+二叉树：[3,9,20,null,null,15,7],
+
+ 3
+ / \
+ 9 20
+ / \
+ 15 7
+```
+
+返回其层次遍历结果：
+
+```javascript
+[
+ [3],
+ [9,20],
+ [15,7]
+]
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+## 解题思路
+直接用 `BFS`，对于每一层初始化空数组，然后存放每一层的节点值，然后迭代即可。
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ * this.val = val;
+ * this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[][]}
+ */
+var levelOrder = function (root) {
+ if(!root) return [];
+ let res = [];
+ let queue = [root];
+ let cnt = 0;
+ while (queue.length) {
+ let size = queue.length;
+ // 每一层初始化一个空数组
+ res.push([]);
+ while (size--) {
+ let node = queue.shift();
+ // 每一层的节点都存着
+ res[cnt].push(node.val);
+ node.left && queue.push(node.left);
+ node.right && queue.push(node.right);
+ }
+ // 迭代层次
+ ++cnt;
+ }
+ return res;
+};
+```
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From b52f6feca63526c800b484b2b8786711bdaac9d2 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sat, 26 Sep 2020 16:03:31 +0800
Subject: [PATCH 49/87] =?UTF-8?q?add=20LeetCode=20113.=20=E8=B7=AF?=
=?UTF-8?q?=E5=BE=84=E6=80=BB=E5=92=8C=20II?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...345\276\204\346\200\273\345\222\214 II.md" | 118 ++++++++++++++++++
1 file changed, 118 insertions(+)
create mode 100644 "\344\272\214\345\217\211\346\240\221/LeetCode 113. \350\267\257\345\276\204\346\200\273\345\222\214 II.md"
diff --git "a/\344\272\214\345\217\211\346\240\221/LeetCode 113. \350\267\257\345\276\204\346\200\273\345\222\214 II.md" "b/\344\272\214\345\217\211\346\240\221/LeetCode 113. \350\267\257\345\276\204\346\200\273\345\222\214 II.md"
new file mode 100644
index 0000000..1dac791
--- /dev/null
+++ "b/\344\272\214\345\217\211\346\240\221/LeetCode 113. \350\267\257\345\276\204\346\200\273\345\222\214 II.md"
@@ -0,0 +1,118 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。
+
+说明: 叶子节点是指没有子节点的节点。
+
+示例:
+
+```javascript
+给定如下二叉树，以及目标和 sum = 22，
+
+ 5
+ / \
+ 4 8
+ / / \
+ 11 13 4
+ / \ / \
+ 7 2 5 1
+```
+
+返回:
+
+```javascript
+[
+ [5,4,11,2],
+ [5,8,4,5]
+]
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/path-sum-ii
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+## 解题思路
+`dfs`，进行深度优先遍历，一直遍历到子节点为止，进行一次判断，如果当前 `sum`为 0 ，那么就是我们想要的结果，然后注意 `js` 语法中形参如果是数组，那么我们拿到的是引用值，可以拷贝一份。
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ * this.val = val;
+ * this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} sum
+ * @return {number[][]}
+ */
+var pathSum = function (root, sum) {
+ if(!root) return [];
+ let res = [];
+ let dfs = (cur, root, sum) => {
+ if (root == null) return 0;
+ // 拷贝一份
+ cur = [...cur,root.val];
+ sum -= root.val;
+ if (!root.left && !root.right && sum == 0) {
+ res.push(cur);
+ return;
+ }
+ // 优先遍历左子树
+ root.left && dfs(cur, root.left, sum);
+ root.right && dfs(cur, root.right, sum);
+ }
+ dfs([], root, sum);
+ return res;
+};
+```
+
+不太明白的小伙伴，这里给一个友好的提示，我们可以打印一下拷贝出来的`cur`，结合图示应该就好理解了，经典的 `dfs`实现的先序遍历。
+
+```javascript
+ 5
+ / \
+ 4 8
+ / / \
+ 11 13 4
+ / \ / \
+ 7 2 5 1
+```
+
+```javascript
+[ 5 ]
+[ 5, 4 ]
+[ 5, 4, 11 ]
+[ 5, 4, 11, 7 ]
+[ 5, 4, 11, 2 ]
+[ 5, 8 ]
+[ 5, 8, 13 ]
+[ 5, 8, 4 ]
+[ 5, 8, 4, 5 ]
+[ 5, 8, 4, 1 ]
+```
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From ab6ec2dfd15464c663892cc0fcd193126fb41304 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sat, 26 Sep 2020 16:27:32 +0800
Subject: [PATCH 50/87] =?UTF-8?q?add=20LeetCode=20100.=20=E7=9B=B8?=
=?UTF-8?q?=E5=90=8C=E7=9A=84=E6=A0=91?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...70\345\220\214\347\232\204\346\240\221.md" | 109 ++++++++++++++++++
1 file changed, 109 insertions(+)
create mode 100644 "\344\272\214\345\217\211\346\240\221/LeetCode 100. \347\233\270\345\220\214\347\232\204\346\240\221.md"
diff --git "a/\344\272\214\345\217\211\346\240\221/LeetCode 100. \347\233\270\345\220\214\347\232\204\346\240\221.md" "b/\344\272\214\345\217\211\346\240\221/LeetCode 100. \347\233\270\345\220\214\347\232\204\346\240\221.md"
new file mode 100644
index 0000000..ea7accb
--- /dev/null
+++ "b/\344\272\214\345\217\211\346\240\221/LeetCode 100. \347\233\270\345\220\214\347\232\204\346\240\221.md"
@@ -0,0 +1,109 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+给定两个二叉树，编写一个函数来检验它们是否相同。
+
+如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。
+
+示例 1:
+
+```javascript
+输入: 1 1
+ / \ / \
+ 2 3 2 3
+
+ [1,2,3], [1,2,3]
+
+输出: true
+```
+
+示例 2:
+
+```javascript
+输入: 1 1
+ / \
+ 2 2
+
+ [1,2], [1,null,2]
+
+输出: false
+```
+
+示例 3:
+
+```javascript
+输入: 1 1
+ / \ / \
+ 2 1 1 2
+
+ [1,2,1], [1,1,2]
+
+输出: false
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/same-tree
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+
+## 解题思路
+
+两颗树一起深搜
+
+- 如果两颗树对应的两个节点都为空，也是相同的。
+- 如果两颗树比较时其中一个节点为空，则不相同。
+- 如果两颗树比较时两个值都不相同，则不相同。
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ * this.val = (val===undefined ? 0 : val)
+ * this.left = (left===undefined ? null : left)
+ * this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} p
+ * @param {TreeNode} q
+ * @return {boolean}
+ */
+var isSameTree = function (p, q) {
+ let flag = true;
+ let dfs = (p, q) => {
+ // 当前节点都是空节点，也代表相同
+ if (p == null && q == null) return true;
+ // 两颗树其中一个节点为空
+ else if (p == null || q == null) return false;
+ // 值不相同
+ else if (p.val !== q.val) return false;
+ return dfs(p.left, q.left) && dfs(p.right, q.right);
+ }
+ return dfs(p, q);
+};
+```
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 366e43c3cccdce1a66f7de700eb8aa4b95358422 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sat, 26 Sep 2020 16:30:38 +0800
Subject: [PATCH 51/87] update
---
README.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/README.md b/README.md
index 0df652c..6d5c445 100644
--- a/README.md
+++ b/README.md
@@ -11,7 +11,7 @@
>思维导图还在建设完善中ing
-
+
## :snowman:笔记网站（更新）
From 534c064471b16004a6652b2cf6027064d07b5c9c Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Mon, 28 Sep 2020 14:57:34 +0800
Subject: [PATCH 52/87] =?UTF-8?q?add=20LeetCode=20543.=20=E4=BA=8C?=
=?UTF-8?q?=E5=8F=89=E6=A0=91=E7=9A=84=E7=9B=B4=E5=BE=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...21\347\232\204\347\233\264\345\276\204.md" | 85 +++++++++++++++++++
1 file changed, 85 insertions(+)
create mode 100644 "\344\272\214\345\217\211\346\240\221/LeetCode 543. \344\272\214\345\217\211\346\240\221\347\232\204\347\233\264\345\276\204.md"
diff --git "a/\344\272\214\345\217\211\346\240\221/LeetCode 543. \344\272\214\345\217\211\346\240\221\347\232\204\347\233\264\345\276\204.md" "b/\344\272\214\345\217\211\346\240\221/LeetCode 543. \344\272\214\345\217\211\346\240\221\347\232\204\347\233\264\345\276\204.md"
new file mode 100644
index 0000000..306fa9f
--- /dev/null
+++ "b/\344\272\214\345\217\211\346\240\221/LeetCode 543. \344\272\214\345\217\211\346\240\221\347\232\204\347\233\264\345\276\204.md"
@@ -0,0 +1,85 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过也可能不穿过根结点。
+
+示例 :
+
+```javascript
+给定二叉树
+
+ 1
+ / \
+ 2 3
+ / \
+ 4 5
+返回 3, 它的长度是路径 [4,2,1,3] 或者 [5,2,1,3]。
+```
+
+**注意**：两结点之间的路径长度是以它们之间边的数目表示。
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/diameter-of-binary-tree
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+## 解题思路
+
+通过**后序遍历**，每一次返回当前根节点下的左右孩子的深度最大值，然后每一次递归求一下左右孩子路径和的最大值即可。
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ * this.val = val;
+ * this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var diameterOfBinaryTree = function (root) {
+ if (!root) return 0;
+ let res = 0;
+ let dfs = (root) => {
+ if (!root) return 0;
+ // 后序遍历 先遍历左孩子
+ let left = root.left && dfs(root.left) + 1;
+ let right = root.right && dfs(root.right) + 1;
+ // 每次求直径，比较左右孩子路径和的最大值
+ res = Math.max(left + right, res);
+ // 递归时候返回左右孩子深度最长
+ return Math.max(left, right)
+ }
+ dfs(root);
+ return res;
+};
+```
+
+
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 63c11569563f6fcfa9a1316d2c56fc5db0958ee6 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Mon, 28 Sep 2020 20:22:43 +0800
Subject: [PATCH 53/87] =?UTF-8?q?add=20LeetCode=20124.=20=E4=BA=8C?=
=?UTF-8?q?=E5=8F=89=E6=A0=91=E4=B8=AD=E7=9A=84=E6=9C=80=E5=A4=A7=E8=B7=AF?=
=?UTF-8?q?=E5=BE=84=E5=92=8C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...47\350\267\257\345\276\204\345\222\214.md" | 95 +++++++++++++++++++
1 file changed, 95 insertions(+)
create mode 100644 "\344\272\214\345\217\211\346\240\221/LeetCode 124. \344\272\214\345\217\211\346\240\221\344\270\255\347\232\204\346\234\200\345\244\247\350\267\257\345\276\204\345\222\214.md"
diff --git "a/\344\272\214\345\217\211\346\240\221/LeetCode 124. \344\272\214\345\217\211\346\240\221\344\270\255\347\232\204\346\234\200\345\244\247\350\267\257\345\276\204\345\222\214.md" "b/\344\272\214\345\217\211\346\240\221/LeetCode 124. \344\272\214\345\217\211\346\240\221\344\270\255\347\232\204\346\234\200\345\244\247\350\267\257\345\276\204\345\222\214.md"
new file mode 100644
index 0000000..c44b0f6
--- /dev/null
+++ "b/\344\272\214\345\217\211\346\240\221/LeetCode 124. \344\272\214\345\217\211\346\240\221\344\270\255\347\232\204\346\234\200\345\244\247\350\267\257\345\276\204\345\222\214.md"
@@ -0,0 +1,95 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+给定一个非空二叉树，返回其最大路径和。
+
+本题中，路径被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。该路径至少包含一个节点，且不一定经过根节点。
+
+
+
+示例 1：
+
+```javascript
+输入：[1,2,3]
+
+ 1
+ / \
+ 2 3
+
+输出：6
+```
+
+示例 2：
+
+```javascript
+输入：[-10,9,20,null,null,15,7]
+
+ -10
+ / \
+ 9 20
+ / \
+ 15 7
+
+输出：42
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/binary-tree-maximum-path-sum
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+## 解题思路
+后序遍历，先遍历左孩子，对于孩子的累计和，我们判断一下，如果小于0（即为负数）就没必要加了，直接返回 0 即可，否则加上孩子累计和。然后我们对每一层求一下最大值即可。
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ * this.val = val;
+ * this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var maxPathSum = function (root) {
+ let res = Number.MIN_SAFE_INTEGER;
+ let dfs = (root) => {
+ if (!root) return 0;
+ // 后序遍历，先遍历左孩子
+ let left = root.left && dfs(root.left);
+ let right = root.right && dfs(root.right);
+ // 每一层求一下最大值
+ res = Math.max(res, left + right + root.val);
+ let sum = Math.max(left, right) + root.val;
+ // 判断一下如果孩子的累计和小于0，就没必要加了
+ return sum < 0 ? 0 : sum;
+ }
+ dfs(root);
+ return res;
+};
+```
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 0b7e89f314bc30680ade6eb9388bddf0aee006f4 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sun, 4 Oct 2020 14:43:15 +0800
Subject: [PATCH 54/87] =?UTF-8?q?add=20LeetCode=202.=20=E4=B8=A4=E6=95=B0?=
=?UTF-8?q?=E7=9B=B8=E5=8A=A0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...44\346\225\260\347\233\270\345\212\240.md" | 82 +++++++++++++++++++
1 file changed, 82 insertions(+)
create mode 100644 "\351\223\276\350\241\250/LeetCode 2. \344\270\244\346\225\260\347\233\270\345\212\240.md"
diff --git "a/\351\223\276\350\241\250/LeetCode 2. \344\270\244\346\225\260\347\233\270\345\212\240.md" "b/\351\223\276\350\241\250/LeetCode 2. \344\270\244\346\225\260\347\233\270\345\212\240.md"
new file mode 100644
index 0000000..626a7f6
--- /dev/null
+++ "b/\351\223\276\350\241\250/LeetCode 2. \344\270\244\346\225\260\347\233\270\345\212\240.md"
@@ -0,0 +1,82 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 **逆序** 的方式存储的，并且它们的每个节点只能存储 一位 数字。
+
+如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
+
+您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
+
+示例：
+
+```css
+输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
+输出：7 -> 0 -> 8
+原因：342 + 465 = 807
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/add-two-numbers
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+## 解题思路
+模拟相加，创建一个新的链表，注意一下进位，由于本题按照逆序来输出的，直接从头结点开始遍历就好了，两个链表其中一个为空节点，直接置为0即可。
+
+同时，要注意，最后一个进位的情况，要进行判断一下。
+
+
+```javascript
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ * this.val = (val===undefined ? 0 : val)
+ * this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ */
+var addTwoNumbers = function (l1, l2) {
+ let sum = 0;
+ let head = new ListNode('head'); // 头结点
+ let p = head;
+ let cnt = 0; // 进位
+ while (l1 || l2) {
+ let ans = (l1 ? l1.val : 0) + (l2 ? l2.val : 0) + cnt;
+ cnt = ans >= 10 ? 1 : 0;
+ p.next = new ListNode(ans % 10);
+ p = p.next;
+ l1 && (l1 = l1.next);
+ l2 && (l2 = l2.next);
+ }
+ cnt && (p.next = new ListNode(cnt));
+ return head.next;
+};
+```
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 61c6e585c4efa5856a8f4844b2fb88ca284db8f4 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sun, 4 Oct 2020 14:53:43 +0800
Subject: [PATCH 55/87] =?UTF-8?q?add=20LeetCode=20203.=20=E7=A7=BB?=
=?UTF-8?q?=E9=99=A4=E9=93=BE=E8=A1=A8=E5=85=83=E7=B4=A0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...76\350\241\250\345\205\203\347\264\240.md" | 58 +++++++++++++++++++
1 file changed, 58 insertions(+)
create mode 100644 "\351\223\276\350\241\250/LeetCode 203. \347\247\273\351\231\244\351\223\276\350\241\250\345\205\203\347\264\240.md"
diff --git "a/\351\223\276\350\241\250/LeetCode 203. \347\247\273\351\231\244\351\223\276\350\241\250\345\205\203\347\264\240.md" "b/\351\223\276\350\241\250/LeetCode 203. \347\247\273\351\231\244\351\223\276\350\241\250\345\205\203\347\264\240.md"
new file mode 100644
index 0000000..c0d7454
--- /dev/null
+++ "b/\351\223\276\350\241\250/LeetCode 203. \347\247\273\351\231\244\351\223\276\350\241\250\345\205\203\347\264\240.md"
@@ -0,0 +1,58 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+删除链表中等于给定值 val 的所有节点。
+
+示例:
+
+```javascript
+输入: 1->2->6->3->4->5->6, val = 6
+输出: 1->2->3->4->5
+```
+
+## 解题思路
+创建一个新链表，遇到相同值的情况，将当前节点的next指向下一个节点的next，否则继续遍历。
+
+```javascript
+var removeElements = function(head, val) {
+ let dummyHead = new ListNode(); // 哑结点
+ dummyHead.next = head;
+ let p = dummyHead;
+ while(p.next){
+ if(p.next.val === val){
+ p.next = p.next.next;
+ }else{
+ p = p.next;
+ }
+ }
+ return dummyHead.next;
+};
+```
+
+
+
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From e5e2754d0d868efe490b545f3a9f1930ef6ef9f4 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sun, 4 Oct 2020 15:13:21 +0800
Subject: [PATCH 56/87] =?UTF-8?q?add=20LeetCode=2024.=20=E4=B8=A4=E4=B8=A4?=
=?UTF-8?q?=E4=BA=A4=E6=8D=A2=E9=93=BE=E8=A1=A8=E4=B8=AD=E7=9A=84=E8=8A=82?=
=?UTF-8?q?=E7=82=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...55\347\232\204\350\212\202\347\202\271.md" | 101 ++++++++++++++++++
1 file changed, 101 insertions(+)
create mode 100644 "\351\223\276\350\241\250/LeetCode 24. \344\270\244\344\270\244\344\272\244\346\215\242\351\223\276\350\241\250\344\270\255\347\232\204\350\212\202\347\202\271.md"
diff --git "a/\351\223\276\350\241\250/LeetCode 24. \344\270\244\344\270\244\344\272\244\346\215\242\351\223\276\350\241\250\344\270\255\347\232\204\350\212\202\347\202\271.md" "b/\351\223\276\350\241\250/LeetCode 24. \344\270\244\344\270\244\344\272\244\346\215\242\351\223\276\350\241\250\344\270\255\347\232\204\350\212\202\347\202\271.md"
new file mode 100644
index 0000000..6a00c84
--- /dev/null
+++ "b/\351\223\276\350\241\250/LeetCode 24. \344\270\244\344\270\244\344\272\244\346\215\242\351\223\276\350\241\250\344\270\255\347\232\204\350\212\202\347\202\271.md"
@@ -0,0 +1,101 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
+
+你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
+
+
+
+示例:
+
+```javascript
+给定 1->2->3->4, 你应该返回 2->1->4->3.
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/swap-nodes-in-pairs
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+## 解题思路
+
+**非递归解法**
+
+```javascript
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ * this.val = val;
+ * this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+var swapPairs = function(head) {
+ if(head == null || head.next == null) return head;
+ let hummyHead = new ListNode(); // 虚拟节点
+ hummyHead.next = head;
+ let p = hummyHead;
+ let node1,node2; // 当前要交换的两个节点
+ while((node1 = p.next) && (node2 = p.next.next)){
+ // 进行交换操作
+ node1.next = node2.next;
+ node2.next = node1;
+ // 将链表串起来
+ p.next = node2;
+ p = node1;
+ }
+ return hummyHead.next;
+};
+```
+
+**递归解法**
+
+```javascript
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ * this.val = val;
+ * this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+var swapPairs = function (head) {
+ if (!head || !head.next) return head;
+ let node1 = head, node2 = head.next;
+ node1.next = swapPairs(node2.next);
+ node2.next = node1;
+ return node2;
+};
+```
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
+
From edbfe26a58eefe609465830ee5957fb66c062629 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sun, 4 Oct 2020 16:13:16 +0800
Subject: [PATCH 57/87] =?UTF-8?q?add=20LeetCode=2019.=20=E5=88=A0=E9=99=A4?=
=?UTF-8?q?=E9=93=BE=E8=A1=A8=E7=9A=84=E5=80=92=E6=95=B0=E7=AC=ACN?=
=?UTF-8?q?=E4=B8=AA=E8=8A=82=E7=82=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...4N\344\270\252\350\212\202\347\202\271.md" | 85 +++++++++++++++++++
1 file changed, 85 insertions(+)
create mode 100644 "\351\223\276\350\241\250/LeetCode 19. \345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\345\200\222\346\225\260\347\254\254N\344\270\252\350\212\202\347\202\271.md"
diff --git "a/\351\223\276\350\241\250/LeetCode 19. \345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\345\200\222\346\225\260\347\254\254N\344\270\252\350\212\202\347\202\271.md" "b/\351\223\276\350\241\250/LeetCode 19. \345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\345\200\222\346\225\260\347\254\254N\344\270\252\350\212\202\347\202\271.md"
new file mode 100644
index 0000000..c130def
--- /dev/null
+++ "b/\351\223\276\350\241\250/LeetCode 19. \345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\345\200\222\346\225\260\347\254\254N\344\270\252\350\212\202\347\202\271.md"
@@ -0,0 +1,85 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。
+
+示例：
+
+```cpp
+给定一个链表: 1->2->3->4->5, 和 n = 2.
+
+当删除了倒数第二个节点后，链表变为 1->2->3->5.
+```
+
+说明：
+
+给定的 n 保证是有效的。
+
+进阶：
+
+你能尝试使用一趟扫描实现吗？
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+## 解题思路
+
+双指针，先让一个指针q走n 步，然后另一个指针p一起走，当第一个指针q走到尾的时候，此时p指针就指向了我们要删除的节点，进行删除即可。
+
+```javascript
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ * this.val = val;
+ * this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {number} n
+ * @return {ListNode}
+ */
+var removeNthFromEnd = function(head, n) {
+ let dummyHead = new ListNode();
+ dummyHead.next = head;
+ let p = dummyHead;
+ let q = dummyHead;
+ let k = n;
+ while(k--) q = q.next; // 先让一个指针先走n步
+ while(q.next){ // 一起走
+ q = q.next;
+ p = p.next;
+ }
+ p.next = p.next.next; // 找到删除节点，进行删除
+ return dummyHead.next;
+};
+```
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 17fb14c926513e0718f4f0d1aa777ff20be6f3ce Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sun, 4 Oct 2020 16:37:24 +0800
Subject: [PATCH 58/87] =?UTF-8?q?add=20=E5=89=91=E6=8C=87=20Offer=2018.=20?=
=?UTF-8?q?=E5=88=A0=E9=99=A4=E9=93=BE=E8=A1=A8=E7=9A=84=E8=8A=82=E7=82=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...50\347\232\204\350\212\202\347\202\271.md" | 92 +++++++++++++++++++
1 file changed, 92 insertions(+)
create mode 100644 "\351\223\276\350\241\250/\345\211\221\346\214\207 Offer 18. \345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\350\212\202\347\202\271.md"
diff --git "a/\351\223\276\350\241\250/\345\211\221\346\214\207 Offer 18. \345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\350\212\202\347\202\271.md" "b/\351\223\276\350\241\250/\345\211\221\346\214\207 Offer 18. \345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\350\212\202\347\202\271.md"
new file mode 100644
index 0000000..9553176
--- /dev/null
+++ "b/\351\223\276\350\241\250/\345\211\221\346\214\207 Offer 18. \345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\350\212\202\347\202\271.md"
@@ -0,0 +1,92 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。
+
+返回删除后的链表的头节点。
+
+注意：此题对比原题有改动
+
+示例 1:
+
+```javascript
+输入: head = [4,5,1,9], val = 5
+输出: [4,1,9]
+解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.
+```
+
+示例 2:
+
+```javascript
+输入: head = [4,5,1,9], val = 1
+输出: [4,5,9]
+解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.
+
+```
+
+说明：
+
+题目保证链表中节点的值互不相同
+若使用 C 或 C++ 语言，你不需要 free 或 delete 被删除的节点
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/shan-chu-lian-biao-de-jie-dian-lcof
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+## 解题思路
+创建一个新链表，遇到相同值的情况，将当前节点的next指向下一个节点的next，否则继续遍历。
+
+```javascript
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ * this.val = val;
+ * this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {number} val
+ * @return {ListNode}
+ */
+var deleteNode = function(head, val) {
+ let dummyHead = new ListNode();
+ dummyHead.next = head;
+ let p = dummyHead;
+ while(p.next){
+ if(p.next.val === val){
+ p.next = p.next.next;
+ }else{
+ p = p.next;
+ }
+ }
+ return dummyHead.next;
+};
+```
+
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From e9c76d67b90c6279ca8972bff69342dc7d759a75 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sun, 4 Oct 2020 16:57:18 +0800
Subject: [PATCH 59/87] =?UTF-8?q?add=20LeetCode=20206.=20=E5=8F=8D?=
=?UTF-8?q?=E8=BD=AC=E9=93=BE=E8=A1=A8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...15\350\275\254\351\223\276\350\241\250.md" | 99 +++++++++++++++++++
1 file changed, 99 insertions(+)
create mode 100644 "\351\223\276\350\241\250/LeetCode 206. \345\217\215\350\275\254\351\223\276\350\241\250.md"
diff --git "a/\351\223\276\350\241\250/LeetCode 206. \345\217\215\350\275\254\351\223\276\350\241\250.md" "b/\351\223\276\350\241\250/LeetCode 206. \345\217\215\350\275\254\351\223\276\350\241\250.md"
new file mode 100644
index 0000000..479d4e9
--- /dev/null
+++ "b/\351\223\276\350\241\250/LeetCode 206. \345\217\215\350\275\254\351\223\276\350\241\250.md"
@@ -0,0 +1,99 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+反转一个单链表。
+
+示例:
+
+```javascript
+输入: 1->2->3->4->5->NULL
+输出: 5->4->3->2->1->NULL
+```
+
+进阶:
+你可以迭代或递归地反转链表。你能否用两种方法解决这道题？
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/reverse-linked-list
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+## 解题思路
+
+**非递归解法**
+
+```javascript
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ * this.val = val;
+ * this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+var reverseList = function(head) {
+ let pre = null;
+ let cur = head;
+ while(cur){
+ let tmp = cur.next;
+ cur.next = pre;
+ pre = cur;
+ cur = tmp;
+ }
+ return pre;
+};
+```
+
+**递归解法**
+
+```javascript
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ * this.val = val;
+ * this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+var reverseList = function (head) {
+ let reverse = (pre, cur) => {
+ if (!cur) return pre;
+ let tmp = cur.next;
+ cur.next = pre;
+ return reverse(cur, tmp);
+ }
+ return reverse(null, head);
+};
+```
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From d23d03c598f527424fc6ca2373c7aad0583a0e4b Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sun, 4 Oct 2020 17:16:13 +0800
Subject: [PATCH 60/87] =?UTF-8?q?add=20LeetCode=2092.=20=E5=8F=8D=E8=BD=AC?=
=?UTF-8?q?=E9=93=BE=E8=A1=A8=20II?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...350\275\254\351\223\276\350\241\250 II.md" | 144 ++++++++++++++++++
1 file changed, 144 insertions(+)
create mode 100644 "\351\223\276\350\241\250/LeetCode 92. \345\217\215\350\275\254\351\223\276\350\241\250 II.md"
diff --git "a/\351\223\276\350\241\250/LeetCode 92. \345\217\215\350\275\254\351\223\276\350\241\250 II.md" "b/\351\223\276\350\241\250/LeetCode 92. \345\217\215\350\275\254\351\223\276\350\241\250 II.md"
new file mode 100644
index 0000000..9233361
--- /dev/null
+++ "b/\351\223\276\350\241\250/LeetCode 92. \345\217\215\350\275\254\351\223\276\350\241\250 II.md"
@@ -0,0 +1,144 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。
+
+说明:
+1 ≤ m ≤ n ≤ 链表长度。
+
+示例:
+
+```javascript
+输入: 1->2->3->4->5->NULL, m = 2, n = 4
+输出: 1->4->3->2->5->NULL
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/reverse-linked-list-ii
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+## 解题思路
+
+**借助递归**
+
+```javascript
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ * this.val = val;
+ * this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {number} m
+ * @param {number} n
+ * @return {ListNode}
+ */
+var reverseBetween = function (head, m, n) {
+ let reverse = (pre, cur) => {
+ if (!cur) return pre;
+ let tmp = cur.next;
+ cur.next = pre;
+ return reverse(cur, tmp);
+ }
+ let dummyHead = new ListNode();
+ dummyHead.next = head;
+ let p = dummyHead;
+ let k = m - 1;
+ // 先找到需要反转链表部分的前驱节点
+ while (k--) {
+ p = p.next;
+ }
+ // 保存前驱节点
+ let front = p;
+ // 找到需要反转链表部分的头节点
+ let frontNode = front.next;
+ k = n - m + 1;
+ // 再找到需要反转链表部分的尾节点
+ while (k--) {
+ p = p.next;
+ }
+ // 找到需要反转链表部分的尾节点
+ let endNode = p;
+ // 保存后继节点
+ let end = endNode.next;
+ // 将后继值为空，开始反转链表
+ endNode.next = null;
+ front.next = reverse(null, frontNode);
+ // 原本的反转链表部分的头节点现在变成了尾节点，指向原本的后继节点
+ frontNode.next = end;
+ return dummyHead.next;
+};
+```
+
+**迭代解法**
+
+```javascript
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ * this.val = val;
+ * this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {number} m
+ * @param {number} n
+ * @return {ListNode}
+ */
+var reverseBetween = function(head, m, n) {
+ let dummyHead = new ListNode();
+ dummyHead.next = head;
+ let p = dummyHead;
+ let k = m-1;
+ // 先找到需要反转链表部分的前驱节点
+ while (k--) {
+ p = p.next;
+ }
+ // 保存前驱节点
+ let front = p;
+ let pre = frontNode = front.next;
+ let cur = pre.next;
+ k = n-m;
+ // 长度为3的链表需要反转2次，那么长度为n的链表需要反转n-1次
+ while(k--){
+ let tmp = cur.next;
+ cur.next = pre;
+ pre = cur;
+ cur = tmp;
+ }
+ // 将原本前驱节点的next指向当前反转后的链表
+ front.next = pre;
+ // 原本反转链表的头节点现在变成了尾结点，指向后继节点
+ frontNode.next = cur;
+ return dummyHead.next;
+};
+```
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
+
From 1adf2490c20a7129ac7951d022200d693c5520eb Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sun, 4 Oct 2020 17:19:24 +0800
Subject: [PATCH 61/87] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E6=80=9D=E7=BB=B4?=
=?UTF-8?q?=E5=AF=BC=E5=9B=BE?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
README.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/README.md b/README.md
index 6d5c445..1074c77 100644
--- a/README.md
+++ b/README.md
@@ -11,7 +11,7 @@
>思维导图还在建设完善中ing
-
+https://cdn.jsdelivr.net/gh/chocolate1999/cdn/img/20201004171839.png
## :snowman:笔记网站（更新）
From 4cce87891c785808290e2bf4d336aaa00212d3bc Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sun, 4 Oct 2020 17:20:13 +0800
Subject: [PATCH 62/87] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E6=80=9D=E7=BB=B4?=
=?UTF-8?q?=E5=AF=BC=E5=9B=BE?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
README.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/README.md b/README.md
index 1074c77..a636d45 100644
--- a/README.md
+++ b/README.md
@@ -11,7 +11,7 @@
>思维导图还在建设完善中ing
-https://cdn.jsdelivr.net/gh/chocolate1999/cdn/img/20201004171839.png
+
## :snowman:笔记网站（更新）
From d50e2306af9d0c8735925e07b62062e2be4cb04a Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Mon, 5 Oct 2020 11:47:35 +0800
Subject: [PATCH 63/87] update
---
README.md | 9 +++++++++
1 file changed, 9 insertions(+)
diff --git a/README.md b/README.md
index a636d45..ec3d703 100644
--- a/README.md
+++ b/README.md
@@ -3,6 +3,15 @@
+
+
+
+
+
+
+
+
+
## :seedling:仓库地址
传送门：https://github.com/Chocolate1999/leetcode-javascript
From 3172de6da51f71fdde019f914f6f9054cc8e0923 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Mon, 5 Oct 2020 11:49:59 +0800
Subject: [PATCH 64/87] update
---
README.md | 9 +--------
1 file changed, 1 insertion(+), 8 deletions(-)
diff --git a/README.md b/README.md
index ec3d703..0bc6d96 100644
--- a/README.md
+++ b/README.md
@@ -1,14 +1,7 @@
## :sunny:leetcode-javascript
-
-
-
-
-
-
-
-
+
From 0c1e8194062c65bf3ca716df31bb52bd38cec18f Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Tue, 6 Oct 2020 14:51:48 +0800
Subject: [PATCH 65/87] update
---
README.md | 2 ++
1 file changed, 2 insertions(+)
diff --git a/README.md b/README.md
index 0bc6d96..6528590 100644
--- a/README.md
+++ b/README.md
@@ -31,6 +31,8 @@ https://yangchaoyi.vip/iBook/ （基于vuepress搭建的前端学习笔记，目
感谢大佬的归纳总结，原本打算在大佬那里打卡学习，后面考虑不太友好，还是自己新建了一个仓库打卡学习。
+其次，本仓库解题代码大部分是自己的代码风格，题量也进行了拓展，将会持续更新下去，何不star收藏一下？
+
## :pushpin:仓库介绍
本仓库将全程使用的语言是 `JavaScript`，是一个纯前端刷题路线，对于前端刷题没有方向的小伙伴简直是福音。解题代码会记录在本仓库的 `Issues` 中，会按照 `label `进行分类。比如想查看 「递归与回溯」 分类下的问题，那么选择标签进行筛选即可。
From 7e846a426612c775b706b4f842ccaa521db87599 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Tue, 6 Oct 2020 14:57:30 +0800
Subject: [PATCH 66/87] =?UTF-8?q?add=20LeetCode=2070.=20=E7=88=AC=E6=A5=BC?=
=?UTF-8?q?=E6=A2=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.... \347\210\254\346\245\274\346\242\257.md" | 81 +++++++++++++++++++
1 file changed, 81 insertions(+)
create mode 100644 "DP/LeetCode 70. \347\210\254\346\245\274\346\242\257.md"
diff --git "a/DP/LeetCode 70. \347\210\254\346\245\274\346\242\257.md" "b/DP/LeetCode 70. \347\210\254\346\245\274\346\242\257.md"
new file mode 100644
index 0000000..73e40fc
--- /dev/null
+++ "b/DP/LeetCode 70. \347\210\254\346\245\274\346\242\257.md"
@@ -0,0 +1,81 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
+
+每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
+
+注意：给定 n 是一个正整数。
+
+示例 1：
+
+```javascript
+输入： 2
+输出： 2
+解释： 有两种方法可以爬到楼顶。
+1. 1 阶 + 1 阶
+2. 2 阶
+```
+
+示例 2：
+
+```javascript
+输入： 3
+输出： 3
+解释： 有三种方法可以爬到楼顶。
+1. 1 阶 + 1 阶 + 1 阶
+2. 1 阶 + 2 阶
+3. 2 阶 + 1 阶
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/climbing-stairs
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+## 解题思路
+
+到达第n阶楼梯有从n-1阶走一步和从第n-2阶走两步两种情况
+
+```javascript
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var climbStairs = function (n) {
+ let dp = new Array(n);
+ dp[1] = 1;
+ dp[2] = 2;
+ for (let i = 3; i <= n; i++) { // 到达第n阶楼梯有从n-1阶走一步和从第n-2阶走两步两种情况
+ dp[i] = dp[i - 1] + dp[i - 2];
+ }
+ return dp[n];
+};
+```
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From cdf41feb9d01ac2938b1cbfc7efbb586eac1afd1 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Tue, 6 Oct 2020 15:13:09 +0800
Subject: [PATCH 67/87] =?UTF-8?q?add=20LeetCode=20198.=20=E6=89=93?=
=?UTF-8?q?=E5=AE=B6=E5=8A=AB=E8=88=8D?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...23\345\256\266\345\212\253\350\210\215.md" | 88 +++++++++++++++++++
1 file changed, 88 insertions(+)
create mode 100644 "DP/LeetCode 198. \346\211\223\345\256\266\345\212\253\350\210\215.md"
diff --git "a/DP/LeetCode 198. \346\211\223\345\256\266\345\212\253\350\210\215.md" "b/DP/LeetCode 198. \346\211\223\345\256\266\345\212\253\350\210\215.md"
new file mode 100644
index 0000000..f2cb915
--- /dev/null
+++ "b/DP/LeetCode 198. \346\211\223\345\256\266\345\212\253\350\210\215.md"
@@ -0,0 +1,88 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
+
+给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
+
+
+
+示例 1：
+
+```javascript
+输入：[1,2,3,1]
+输出：4
+解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
+ 偷窃到的最高金额 = 1 + 3 = 4 。
+```
+
+示例 2：
+
+```javascript
+输入：[2,7,9,3,1]
+输出：12
+解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
+ 偷窃到的最高金额 = 2 + 9 + 1 = 12 。
+
+```
+
+提示：
+
+- 0 <= nums.length <= 100
+- 0 <= nums[i] <= 400
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/house-robber
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+## 解题思路
+
+判断当前房子的个数，如果当前个数为0，直接返回0，当前个数为1，返回当前金额值，当前个数为2，由于不能相邻一起偷，于是返回它们的最大值。
+
+当前个数超过了3个，当前能够偷的金额总和，就看前一家房子的金额加上当前金额，与相邻房间比较，最后就看最后两间房子金额总和的最大值。状态方程见下述代码：
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var rob = function (nums) {
+ let n = nums.length;
+ if (n === 0) return 0; // 长度为0 值为0
+ if (n === 1) return nums[0]; // 长度为1，默认最多就当前值
+ if (n === 2) return Math.max(nums[0], nums[1]); // 长度为2，由于不能相邻偷，就取最大
+ let dp = [];
+ dp[0] = nums[0];
+ dp[1] = Math.max(nums[0], nums[1]);
+ // 当前能够偷的金额总和，就看前一家房子的金额加上当前金额，与相邻房间比较
+ for (let i = 2; i < n; i++) {
+ dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
+ }
+ // 最后就看最后两间房子金额总和的最大值
+ return Math.max(dp[n - 1], dp[n - 2]);
+};
+```
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From e51ff89bd3cfc2f4505636b7641fddf447aba8c4 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Tue, 6 Oct 2020 15:33:40 +0800
Subject: [PATCH 68/87] =?UTF-8?q?add=20LeetCode=20213.=20=E6=89=93?=
=?UTF-8?q?=E5=AE=B6=E5=8A=AB=E8=88=8D=20II?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...345\256\266\345\212\253\350\210\215 II.md" | 90 +++++++++++++++++++
1 file changed, 90 insertions(+)
create mode 100644 "DP/LeetCode 213. \346\211\223\345\256\266\345\212\253\350\210\215 II.md"
diff --git "a/DP/LeetCode 213. \346\211\223\345\256\266\345\212\253\350\210\215 II.md" "b/DP/LeetCode 213. \346\211\223\345\256\266\345\212\253\350\210\215 II.md"
new file mode 100644
index 0000000..5a09a7f
--- /dev/null
+++ "b/DP/LeetCode 213. \346\211\223\345\256\266\345\212\253\350\210\215 II.md"
@@ -0,0 +1,90 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都围成一圈，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
+
+给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。
+
+示例 1:
+
+```javascript
+输入: [2,3,2]
+输出: 3
+解释: 你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。
+```
+
+示例 2:
+
+```javascript
+输入: [1,2,3,1]
+输出: 4
+解释: 你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。
+ 偷窃到的最高金额 = 1 + 3 = 4 。
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/house-robber-ii
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+## 解题思路
+
+这道题相比于198.打家劫舍 更有趣味一点，房子变成环状的了，那么我们就没办法同时取第一个房子和最后一个房子了，但是我们依然可以使用单向排列的代码，我们直接进行两次遍历不就好了吗，第一次遍历，我们不偷第一家房子，取得单向排列的最大值，第二次遍历，我们不偷最后一家房子，取得单向排列的最大值，那么最终结果就是这两个最大值中的最大值！
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var rob = function (nums) {
+ // 对于长度为 0 和 1进行特判一下
+ if (nums.length === 0) return 0;
+ if (nums.length === 1) return nums[0];
+ let arr1 = nums.slice();
+ arr1.shift();
+ let arr2 = nums.slice();
+ arr2.pop();
+ // 求不偷第一家房子和不偷最后一家房子的单向排列的最大值
+ return Math.max(oneRob(arr1), oneRob(arr2));
+}
+var oneRob = function (nums) {
+ let n = nums.length;
+ if (n === 0) return 0; // 长度为0 值为0
+ if (n === 1) return nums[0]; // 长度为1，默认最多就当前值
+ if (n === 2) return Math.max(nums[0], nums[1]); // 长度为2，由于不能相邻偷，就取最大
+ let dp = [];
+ dp[0] = nums[0];
+ dp[1] = Math.max(nums[0], nums[1]);
+ // 当前能够偷的金额总和，就看前一家房子的金额加上当前金额，与相邻房间比较
+ for (let i = 2; i < n; i++) {
+ dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
+ }
+ // 最后就看最后两间房子金额总和的最大值
+ return Math.max(dp[n - 1], dp[n - 2]);
+};
+```
+
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 6a5e30d160211eaac531c73ed7470406b03f0bf1 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Tue, 6 Oct 2020 15:55:07 +0800
Subject: [PATCH 69/87] =?UTF-8?q?add=20LeetCode=20221.=20=E6=9C=80?=
=?UTF-8?q?=E5=A4=A7=E6=AD=A3=E6=96=B9=E5=BD=A2?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...47\346\255\243\346\226\271\345\275\242.md" | 71 +++++++++++++++++++
1 file changed, 71 insertions(+)
create mode 100644 "DP/LeetCode 221. \346\234\200\345\244\247\346\255\243\346\226\271\345\275\242.md"
diff --git "a/DP/LeetCode 221. \346\234\200\345\244\247\346\255\243\346\226\271\345\275\242.md" "b/DP/LeetCode 221. \346\234\200\345\244\247\346\255\243\346\226\271\345\275\242.md"
new file mode 100644
index 0000000..053bbe2
--- /dev/null
+++ "b/DP/LeetCode 221. \346\234\200\345\244\247\346\255\243\346\226\271\345\275\242.md"
@@ -0,0 +1,71 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+在一个由 0 和 1 组成的二维矩阵内，找到只包含 1 的最大正方形，并返回其面积。
+
+示例:
+
+```javascript
+输入:
+
+1 0 1 0 0
+1 0 1 1 1
+1 1 1 1 1
+1 0 0 1 0
+
+输出: 4
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/maximal-square
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+## 解题思路
+要想求得最大正方形，通过找规律，我们不难发现，对于(i > 0 && j > 0)情况，当前位置边长长度等于左，左上，上三个方向边长长度的最小值，然后加1，于是我们遍历整个矩阵，对于当前值为1的情况，我们每次求一下它能拓展到的最大边长，然后每次迭代求出结果的最大边长，那么面积就是边长*边长返回即可。
+
+
+```javascript
+/**
+ * @param {character[][]} matrix
+ * @return {number}
+ */
+var maximalSquare = function (matrix) {
+ if (!matrix || !matrix.length) return 0;
+ let res = 0; // 设置最长边长变量
+ let n = matrix.length, m = matrix[0].length;
+ for (let i = 0; i < n; i++) {
+ for (let j = 0; j < m; j++) {
+ if (matrix[i][j] == 1) {
+ // 对于(i > 0 && j > 0)情况，当前位置边长长度等于左，左上，上三个方向边长长度的最小值，然后加1
+ (i > 0 && j > 0) && (matrix[i][j] = Math.min(matrix[i - 1][j], matrix[i - 1][j - 1], matrix[i][j - 1]) + 1);
+ }
+ res = Math.max(res, matrix[i][j]); // 迭代求最长边长
+ }
+ }
+ return res ** 2; // 返回边长*边长
+};
+```
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 9412314d3997aa2aa25fa2e55b8ebe79a17586a8 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Tue, 6 Oct 2020 16:11:42 +0800
Subject: [PATCH 70/87] =?UTF-8?q?add=20LeetCode=20322.=20=E9=9B=B6?=
=?UTF-8?q?=E9=92=B1=E5=85=91=E6=8D=A2?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...66\351\222\261\345\205\221\346\215\242.md" | 109 ++++++++++++++++++
1 file changed, 109 insertions(+)
create mode 100644 "DP/LeetCode 322. \351\233\266\351\222\261\345\205\221\346\215\242.md"
diff --git "a/DP/LeetCode 322. \351\233\266\351\222\261\345\205\221\346\215\242.md" "b/DP/LeetCode 322. \351\233\266\351\222\261\345\205\221\346\215\242.md"
new file mode 100644
index 0000000..e2d0d9d
--- /dev/null
+++ "b/DP/LeetCode 322. \351\233\266\351\222\261\345\205\221\346\215\242.md"
@@ -0,0 +1,109 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。
+
+你可以认为每种硬币的数量是无限的。
+
+
+
+示例 1：
+
+```javascript
+输入：coins = [1, 2, 5], amount = 11
+输出：3
+解释：11 = 5 + 5 + 1
+```
+
+示例 2：
+
+```javascript
+输入：coins = [2], amount = 3
+输出：-1
+```
+
+示例 3：
+
+```javascript
+输入：coins = [1], amount = 0
+输出：0
+```
+
+示例 4：
+
+```javascript
+输入：coins = [1], amount = 1
+输出：1
+```
+
+示例 5：
+
+```javascript
+输入：coins = [1], amount = 2
+输出：2
+
+```
+
+提示：
+
+- 1 <= coins.length <= 12
+- 1 <= coins[i] <= 231 - 1
+- 0 <= amount <= 231 - 1
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/coin-change
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+## 解题思路
+
+对于零钱兑换问题，本题不能用贪心来做，要用dp，状态方程如下代码。
+
+我们首先将数组都初始化为正无穷，对于 0 ，默认为0即可，不需要兑换硬币，然后从1迭代到 `amount` ，如果当前金额，可以减去当前硬币的价值，拿当前硬币，然后我们求最小的硬币数。
+
+最后，如果还是无穷大，那么就找不到对应的硬币组合，直接输出 -1 。
+
+```javascript
+/**
+ * @param {number[]} coins
+ * @param {number} amount
+ * @return {number}
+ */
+var coinChange = function (coins, amount) {
+ let dp = new Array(amount + 1).fill(Infinity); // 初始化都为无穷大
+ dp[0] = 0; // 没钱时不需要硬币
+ for (let i = 1; i <= amount; i++) {
+ for (let coin of coins) {
+ if (i - coin >= 0) // 如果当前金额，可以减去当前硬币的价值，拿当前硬币
+ dp[i] = Math.min(dp[i], dp[i - coin] + 1);
+ }
+ }
+ return dp[amount] == Infinity ? -1 : dp[amount]; // 如果还是无穷大，那么就找不到对应的硬币组合
+};
+```
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 1fceacd409286a3f7b0ba7715d994f9d883b9f62 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Tue, 6 Oct 2020 16:32:14 +0800
Subject: [PATCH 71/87] =?UTF-8?q?add=20LeetCode=2062.=20=E4=B8=8D=E5=90=8C?=
=?UTF-8?q?=E8=B7=AF=E5=BE=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...15\345\220\214\350\267\257\345\276\204.md" | 102 ++++++++++++++++++
1 file changed, 102 insertions(+)
create mode 100644 "DP/LeetCode 62. \344\270\215\345\220\214\350\267\257\345\276\204.md"
diff --git "a/DP/LeetCode 62. \344\270\215\345\220\214\350\267\257\345\276\204.md" "b/DP/LeetCode 62. \344\270\215\345\220\214\350\267\257\345\276\204.md"
new file mode 100644
index 0000000..313c9a3
--- /dev/null
+++ "b/DP/LeetCode 62. \344\270\215\345\220\214\350\267\257\345\276\204.md"
@@ -0,0 +1,102 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。
+
+机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。
+
+问总共有多少条不同的路径？
+
+
+
+
+例如，上图是一个7 x 3 的网格。有多少可能的路径？
+
+
+
+示例 1:
+
+```javascript
+输入: m = 3, n = 2
+输出: 3
+解释:
+从左上角开始，总共有 3 条路径可以到达右下角。
+1. 向右 -> 向右 -> 向下
+2. 向右 -> 向下 -> 向右
+3. 向下 -> 向右 -> 向右
+```
+
+示例 2:
+
+```javascript
+输入: m = 7, n = 3
+输出: 28
+
+```
+
+提示：
+
+1 <= m, n <= 100
+题目数据保证答案小于等于 2 * 10 ^ 9
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/unique-paths
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+## 解题思路
+
+机器人只能向右或向下移动一步，那么当前路径数等于左边路径数+上边路径数之和，不过初始化第0行和第0列路径数都为1。
+
+```javascript
+/**
+ * @param {number} m
+ * @param {number} n
+ * @return {number}
+ */
+var uniquePaths = function (m, n) {
+ let dp = new Array(m);
+ // 初始化 第0行和第0列路径数都为1
+ for (let i = 0; i < m; i++) {
+ dp[i] = new Array(n);
+ dp[i][0] = 1;
+ }
+ for (let i = 0; i < n; i++) {
+ dp[0][i] = 1;
+ }
+ // 当前路径数等于左边路径数+上边路径数之和
+ for (let i = 1; i < m; i++) {
+ for (let j = 1; j < n; j++) {
+ dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
+ }
+ }
+ return dp[m - 1][n - 1];
+};
+```
+
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
+
From bc23cdb5dc25e9f57edb7584102c95308fe2f94a Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Tue, 6 Oct 2020 16:58:10 +0800
Subject: [PATCH 72/87] =?UTF-8?q?add=20LeetCode=2063.=20=E4=B8=8D=E5=90=8C?=
=?UTF-8?q?=E8=B7=AF=E5=BE=84=20II?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...345\220\214\350\267\257\345\276\204 II.md" | 104 ++++++++++++++++++
1 file changed, 104 insertions(+)
create mode 100644 "DP/LeetCode 63. \344\270\215\345\220\214\350\267\257\345\276\204 II.md"
diff --git "a/DP/LeetCode 63. \344\270\215\345\220\214\350\267\257\345\276\204 II.md" "b/DP/LeetCode 63. \344\270\215\345\220\214\350\267\257\345\276\204 II.md"
new file mode 100644
index 0000000..c809e2c
--- /dev/null
+++ "b/DP/LeetCode 63. \344\270\215\345\220\214\350\267\257\345\276\204 II.md"
@@ -0,0 +1,104 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。
+
+机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。
+
+现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？
+
+
+
+
+网格中的障碍物和空位置分别用 1 和 0 来表示。
+
+说明：m 和 n 的值均不超过 100。
+
+示例 1:
+
+```javascript
+输入:
+[
+ [0,0,0],
+ [0,1,0],
+ [0,0,0]
+]
+输出: 2
+解释:
+3x3 网格的正中间有一个障碍物。
+从左上角到右下角一共有 2 条不同的路径：
+1. 向右 -> 向右 -> 向下 -> 向下
+2. 向下 -> 向下 -> 向右 -> 向右
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/unique-paths-ii
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+## 解题思路
+
+机器人每次只能向下或者向右移动一步。按照原本思路，我们图中某一个点的路径数等于左边点的路径数和上边点的路径数总和。
+
+现在有了障碍物，对于障碍物点，我们需要将路径数设置为0，因为它没办法给其它点提供路径数，走不通。
+
+此外，我们需要注意，当第0行和第0列有一个地方出现了障碍，那么当前这个点的路径数和后续的路径数都设置为0。
+
+其次，我们也需要考虑一下，如果起点就是一个障碍物点，那么路径数本就为0。
+
+
+```javascript
+/**
+ * @param {number[][]} obstacleGrid
+ * @return {number}
+ */
+var uniquePathsWithObstacles = function (obstacleGrid) {
+ if (obstacleGrid[0][0] == 1) return 0; // 出发点被堵住，直接返回0
+ let m = obstacleGrid.length, n = obstacleGrid[0].length;
+ let dp = new Array(m);
+ for (let i = 0; i < m; i++) {
+ dp[i] = new Array(n);
+ }
+ dp[0][0] = 1; // 起点路径数设置为1
+ for (let i = 1; i < m; i++) {
+ // 如果第0列有一个地方出现了障碍，那么当前这个点的路径数和后续的路径数都设置为0
+ dp[i][0] = obstacleGrid[i][0] == 1 || dp[i - 1][0] == 0 ? 0 : 1;
+ }
+ for (let i = 1; i < n; i++) {
+ // 如果第0行有一个地方出现了障碍，那么当前这个点的路径数和后续的路径数都设置为0
+ dp[0][i] = obstacleGrid[0][i] == 1 || dp[0][i - 1] == 0 ? 0 : 1;
+ }
+ for (let i = 1; i < m; i++) {
+ for (let j = 1; j < n; j++) {
+ // 如果当前这个点是障碍物，路径数为0，也不会给其它点提供相应的路径数
+ dp[i][j] = obstacleGrid[i][j] == 1 ? 0 : dp[i - 1][j] + dp[i][j - 1];
+ }
+ }
+ return dp[m - 1][n - 1];
+};
+```
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 307e8479b020866b3d3ca90a4e5fd90807da76dd Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Tue, 6 Oct 2020 21:06:15 +0800
Subject: [PATCH 73/87] =?UTF-8?q?add=20LeetCode=20121.=20=E4=B9=B0?=
=?UTF-8?q?=E5=8D=96=E8=82=A1=E7=A5=A8=E7=9A=84=E6=9C=80=E4=BD=B3=E6=97=B6?=
=?UTF-8?q?=E6=9C=BA?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...00\344\275\263\346\227\266\346\234\272.js" | 115 ++++++++++++++++++
1 file changed, 115 insertions(+)
create mode 100644 "DP/LeetCode 121. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.js"
diff --git "a/DP/LeetCode 121. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.js" "b/DP/LeetCode 121. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.js"
new file mode 100644
index 0000000..7d1cafa
--- /dev/null
+++ "b/DP/LeetCode 121. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.js"
@@ -0,0 +1,115 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
+
+如果你最多只允许完成一笔交易（即买入和卖出一支股票一次），设计一个算法来计算你所能获取的最大利润。
+
+注意：你不能在买入股票前卖出股票。
+
+
+
+示例 1:
+
+```javascript
+输入: [7,1,5,3,6,4]
+输出: 5
+解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
+ 注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
+```
+
+示例 2:
+
+```javascript
+输入: [7,6,4,3,1]
+输出: 0
+解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+## 解题思路
+这道题想了挺久，参考了大佬的题解，典型的二维 dp 问题。
+
+状态 `dp[i][j] `表示：在下标为 `i` 的这一天，用户手上持股状态为 `j` 所获得的最大利润。
+
+说明：
+
+- `j` 只有 2 个值：0 表示不持股（特指卖出股票以后的不持股状态），1 表示持股。
+- 「用户手上不持股」不代表用户一定在下标为 `i` 的这一天把股票抛售了；
+
+`dp[i][0] `怎样转移？
+
+对于当前这天，不持股份的话，当然可以是前一天也没有持股份，即 `dp[i-1][0]`
+还有可能就是昨天持股了，我今天把这股份卖了，那么就要加上今天卖的那份股份值，即 `dp[i-1][1] + prices[i]`
+
+综上，得到状态方程：
+
+```javascript
+dp[i][0] = Math.max(dp[i-1][0], dp[i-1][1] + prices[i]);
+```
+
+`dp[i][1]` 怎样转移？
+
+对于当前这天，如果持了股份的话，当天可以是前一天也持了股份，即 `dp[i-1][1]`
+还有可能就是我今天才持股，同时注意，我们不能加上 `dp[i-1][0]`，因为我们只能**交易一次**，即从当前这天持股，那么买入带来的收益即为 `-prices[i]`
+
+综上，得到状态方程：
+
+```javascript
+dp[i][1] = Math.max(dp[i-1][1], -prices[i]);
+```
+
+
+
+```javascript
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+var maxProfit = function(prices) {
+ let n = prices.length;
+ if(n<2) return 0; // 不足两天，肯定没收益
+ let dp = new Array(n);
+ for(let i=0;i小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 531ef33acf46c1c6e519834485d9282d520bf012 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Tue, 6 Oct 2020 21:06:32 +0800
Subject: [PATCH 74/87] =?UTF-8?q?update=20LeetCode=20121.=20=E4=B9=B0?=
=?UTF-8?q?=E5=8D=96=E8=82=A1=E7=A5=A8=E7=9A=84=E6=9C=80=E4=BD=B3=E6=97=B6?=
=?UTF-8?q?=E6=9C=BA?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...47\232\204\346\234\200\344\275\263\346\227\266\346\234\272.md" | 0
1 file changed, 0 insertions(+), 0 deletions(-)
rename "DP/LeetCode 121. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.js" => "DP/LeetCode 121. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.md" (100%)
diff --git "a/DP/LeetCode 121. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.js" "b/DP/LeetCode 121. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.md"
similarity index 100%
rename from "DP/LeetCode 121. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.js"
rename to "DP/LeetCode 121. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.md"
From 780e06cf107d40803a4d59a2d1508f947e6e4809 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Tue, 6 Oct 2020 21:20:27 +0800
Subject: [PATCH 75/87] =?UTF-8?q?add=20LeetCode=20122.=20=E4=B9=B0?=
=?UTF-8?q?=E5=8D=96=E8=82=A1=E7=A5=A8=E7=9A=84=E6=9C=80=E4=BD=B3=E6=97=B6?=
=?UTF-8?q?=E6=9C=BA=20II?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...344\275\263\346\227\266\346\234\272 II.md" | 147 ++++++++++++++++++
1 file changed, 147 insertions(+)
create mode 100644 "DP/LeetCode 122. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272 II.md"
diff --git "a/DP/LeetCode 122. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272 II.md" "b/DP/LeetCode 122. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272 II.md"
new file mode 100644
index 0000000..b1aa9f1
--- /dev/null
+++ "b/DP/LeetCode 122. \344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272 II.md"
@@ -0,0 +1,147 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
+
+设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
+
+注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
+
+
+
+示例 1:
+
+```javascript
+输入: [7,1,5,3,6,4]
+输出: 7
+解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
+ 随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。
+```
+
+示例 2:
+
+```javascript
+输入: [1,2,3,4,5]
+输出: 4
+解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
+ 注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
+ 因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
+```
+
+示例 3:
+
+```javascript
+输入: [7,6,4,3,1]
+输出: 0
+解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
+```
+
+
+提示：
+
+- 1 <= prices.length <= 3 * 10 ^ 4
+- 0 <= prices[i] <= 10 ^ 4
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+## 解题思路
+
+这道题想了挺久，参考了大佬的题解，典型的二维 dp 问题。
+
+状态 `dp[i][j] `表示：在下标为 `i` 的这一天，用户手上持股状态为 `j` 所获得的最大利润。
+
+说明：
+
+- `j` 只有 2 个值：0 表示不持股（特指卖出股票以后的不持股状态），1 表示持股。
+- 「用户手上不持股」不代表用户一定在下标为 `i` 的这一天把股票抛售了；
+
+`dp[i][0] `怎样转移？
+
+对于当前这天，不持股份的话，当然可以是前一天也没有持股份，即 `dp[i-1][0]`
+还有可能就是昨天持股了，我今天把这股份卖了，那么就要加上今天卖的那份股份值，即 `dp[i-1][1] + prices[i]`
+
+综上，得到状态方程：
+
+```javascript
+dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
+```
+
+`dp[i][1]` 怎样转移？
+
+对于当前这天，如果持了股份的话，当天可以是前一天也持了股份，即 `dp[i-1][1]`
+还有可能就是我今天才持股，同时注意，我们必须加上 `dp[i-1][0]`，因为我们可以**多笔交易**，即从当前这天持股，那么买入带来的收益即为 `dp[i-1][0]-prices[i]`
+
+综上，得到状态方程：
+
+```javascript
+dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
+```
+
+```javascript
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+var maxProfit = function (prices) {
+ let n = prices.length;
+ if (n < 2) return 0; // 不足两天，肯定没收益
+ let dp = new Array(n);
+ for (let i = 0; i < n; i++) {
+ dp[i] = new Array(2);
+ }
+ dp[0][0] = 0; // 第一天不持股
+ dp[0][1] = -prices[0]; // 第一天持股，即买入
+ for (let i = 1; i < n; i++) {
+ dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
+ dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
+ }
+ return dp[n - 1][0]; // 最大收益，最后一天卖出股票的结果
+};
+
+```
+
+同时，这道题也可以用贪心来做，由于可以进行**多次交易**，那么只要价格上涨，我就买，不买我就亏了一个亿！
+
+```javascript
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+var maxProfit = function (prices) {
+ let res = 0;
+ for (let i = 0; i < prices.length - 1; i++) {
+ // 只要股票价格上涨，我就买，不然就亏！
+ if (prices[i + 1] > prices[i]) {
+ res += prices[i + 1] - prices[i];
+ }
+ }
+ return res;
+};
+```
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 55cc3d7581d8a4cb480d0f38ea039e7be1bb0b1a Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Wed, 7 Oct 2020 12:00:15 +0800
Subject: [PATCH 76/87] =?UTF-8?q?add=20LeetCode=2015.=20=E4=B8=89=E6=95=B0?=
=?UTF-8?q?=E4=B9=8B=E5=92=8C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...11\346\225\260\344\271\213\345\222\214.md" | 100 ++++++++++++++++++
1 file changed, 100 insertions(+)
create mode 100644 "\345\217\214\346\214\207\351\222\210/LeetCode 15. \344\270\211\346\225\260\344\271\213\345\222\214.md"
diff --git "a/\345\217\214\346\214\207\351\222\210/LeetCode 15. \344\270\211\346\225\260\344\271\213\345\222\214.md" "b/\345\217\214\346\214\207\351\222\210/LeetCode 15. \344\270\211\346\225\260\344\271\213\345\222\214.md"
new file mode 100644
index 0000000..0bb2c62
--- /dev/null
+++ "b/\345\217\214\346\214\207\351\222\210/LeetCode 15. \344\270\211\346\225\260\344\271\213\345\222\214.md"
@@ -0,0 +1,100 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+给你一个包含 n 个整数的数组 `nums`，判断 `nums` 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
+
+注意：答案中不可以包含重复的三元组。
+
+
+示例：
+
+```javascript
+给定数组 nums = [-1, 0, 1, 2, -1, -4]，
+
+满足要求的三元组集合为：
+[
+ [-1, 0, 1],
+ [-1, -1, 2]
+]
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/3sum
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+## 解题思路
+因为不能有重复的解，为了简化操作，我们先对数组排序，于是判断一个元素是否重复，只需看它和它前面的元素是否相等即可
+
+
+双指针的移动时，避免出现重复解
+
+得到一个解后，需要左右指针向 “内” 收缩，为了避免指向重复的元素
+- 左指针要在 left < right 的前提下，一直右移，直到指向不重复的元素
+- 右指针要在 left < right 的前提下，一直左移，直到指向不重复的元素
+
+优化点，如果当前元素值大于0了，由于我们事先排好序了，不存在三个数相加为0了，此时直接break就好了。
+
+
+
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var threeSum = function (nums) {
+ let len = nums.length;
+ if (len < 2) return [];
+ let res = [];
+ nums.sort((a, b) => a - b); // 从小到大进行排序
+ for (let i = 0; i < len - 2; i++) {
+ if (nums[i] > 0) break;
+ if (i > 0 && nums[i] === nums[i - 1]) continue; // 去掉重复项
+ let L = i + 1;
+ let R = len - 1;
+ while (L < R) {
+ let sum = nums[i] + nums[L] + nums[R]; // 三数之和
+ if (sum === 0) {
+ res.push([nums[i], nums[L], nums[R]]);
+ while (L < R && nums[L] == nums[L + 1]) L++; // 去重，直到指向不一样的数
+ while (L < R && nums[R] == nums[R - 1]) R--;
+ L++;
+ R--;
+ } else if (sum < 0) {
+ L++; // 和小于0，就是左边值太小了，往右移
+ } else if (sum > 0) {
+ R--; // 和大于0，就是右边值太大了，往左移
+ }
+ }
+ }
+ return res;
+};
+```
+
+
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From a54a7706c9ff283a2be136d2b0d0cfdabd1e5d29 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Wed, 7 Oct 2020 20:19:06 +0800
Subject: [PATCH 77/87] =?UTF-8?q?add=20LeetCode=2016.=20=E6=9C=80=E6=8E=A5?=
=?UTF-8?q?=E8=BF=91=E7=9A=84=E4=B8=89=E6=95=B0=E4=B9=8B=E5=92=8C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...11\346\225\260\344\271\213\345\222\214.md" | 78 +++++++++++++++++++
1 file changed, 78 insertions(+)
create mode 100644 "\345\217\214\346\214\207\351\222\210/LeetCode 16. \346\234\200\346\216\245\350\277\221\347\232\204\344\270\211\346\225\260\344\271\213\345\222\214.md"
diff --git "a/\345\217\214\346\214\207\351\222\210/LeetCode 16. \346\234\200\346\216\245\350\277\221\347\232\204\344\270\211\346\225\260\344\271\213\345\222\214.md" "b/\345\217\214\346\214\207\351\222\210/LeetCode 16. \346\234\200\346\216\245\350\277\221\347\232\204\344\270\211\346\225\260\344\271\213\345\222\214.md"
new file mode 100644
index 0000000..d6cecdf
--- /dev/null
+++ "b/\345\217\214\346\214\207\351\222\210/LeetCode 16. \346\234\200\346\216\245\350\277\221\347\232\204\344\270\211\346\225\260\344\271\213\345\222\214.md"
@@ -0,0 +1,78 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。
+
+
+
+示例：
+
+```javascript
+输入：nums = [-1,2,1,-4], target = 1
+输出：2
+解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。
+```
+
+
+提示：
+
+- 3 <= nums.length <= 10^3
+- -10^3 <= nums[i] <= 10^3
+- -10^4 <= target <= 10^4
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/3sum-closest
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+## 解题思路
+
+这道题和15有一点区别，我们只要求最接近 `target` 的三树之和，那么我们就需要每次更新一下，最接近的和，简单来说就是比较一下，然后本题也没有去重操作，相对来说考虑情况会更少一点。
+```javascript
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+var threeSumClosest = function (nums, target) {
+ let len = nums.length;
+ nums.sort((a, b) => a - b); // 从小到大进行排序
+ let res = nums[0] + nums[1] + nums[len - 1]; // 初始化随机一个res
+ for (let i = 0; i < len - 2; i++) {
+ let L = i + 1;
+ let R = len - 1;
+ while (L < R) {
+ let sum = nums[i] + nums[L] + nums[R]; // 三数之和
+ sum > target ? R-- : L++; // 比目标值大，就往左内缩，小的话，就往右内缩
+ if (Math.abs(sum - target) < Math.abs(res - target)) {
+ res = sum; // 迭代更新res
+ }
+ }
+ }
+ return res;
+};
+```
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 4c4706292c7185fc40b143076e089b51bc5b8a2e Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Wed, 7 Oct 2020 20:43:25 +0800
Subject: [PATCH 78/87] =?UTF-8?q?add=20LeetCode=2075.=20=E9=A2=9C=E8=89=B2?=
=?UTF-8?q?=E5=88=86=E7=B1=BB?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...34\350\211\262\345\210\206\347\261\273.md" | 109 ++++++++++++++++++
1 file changed, 109 insertions(+)
create mode 100644 "\345\217\214\346\214\207\351\222\210/LeetCode 75. \351\242\234\350\211\262\345\210\206\347\261\273.md"
diff --git "a/\345\217\214\346\214\207\351\222\210/LeetCode 75. \351\242\234\350\211\262\345\210\206\347\261\273.md" "b/\345\217\214\346\214\207\351\222\210/LeetCode 75. \351\242\234\350\211\262\345\210\206\347\261\273.md"
new file mode 100644
index 0000000..1f0cea1
--- /dev/null
+++ "b/\345\217\214\346\214\207\351\222\210/LeetCode 75. \351\242\234\350\211\262\345\210\206\347\261\273.md"
@@ -0,0 +1,109 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。
+
+此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。
+
+注意:
+不能使用代码库中的排序函数来解决这道题。
+
+示例:
+
+```javascript
+输入: [2,0,2,1,1,0]
+输出: [0,0,1,1,2,2]
+```
+
+进阶：
+
+一个直观的解决方案是使用计数排序的两趟扫描算法。
+首先，迭代计算出0、1 和 2 元素的个数，然后按照0、1、2的排序，重写当前数组。
+你能想出一个仅使用常数空间的一趟扫描算法吗？
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/sort-colors
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+## 解题思路
+
+双指针，当前值为2，那么就和右边指针进行交换，反之当前值为0，那么就和左边指针进行交换，为1就不动。
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @return {void} Do not return anything, modify nums in-place instead.
+ */
+var sortColors = function (nums) {
+ let len = nums.length;
+ let L = 0;
+ let R = len - 1;
+ let i = 0;
+ while (i <= R) {
+ while (nums[i] == 2 && i < R) { // 当前值为2，那么就和右边指针进行交换
+ [nums[i], nums[R]] = [nums[R], nums[i]];
+ R--;
+ }
+ while (nums[i] == 0 && i > L) { // 当前值为0，那么就和左边指针进行交换
+ [nums[i], nums[L]] = [nums[L], nums[i]];
+ L++;
+ }
+ i++;
+ }
+ return nums;
+};
+```
+
+我想下面这份代码应该会更好理解一点：
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @return {void} Do not return anything, modify nums in-place instead.
+ */
+var sortColors = function (nums) {
+ let len = nums.length;
+ let L = 0;
+ let R = len - 1;
+ let i = 0;
+ while (i <= R) {
+ if (nums[i] == 0) { // 当前值为0，那么就和左边指针进行交换
+ [nums[i], nums[L]] = [nums[L], nums[i]];
+ L++;
+ i++;
+ } else if (nums[i] == 2) { // 当前值为2，那么就和右边指针进行交换
+ [nums[i], nums[R]] = [nums[R], nums[i]];
+ R--;
+ } else {
+ i++;
+ }
+ }
+ return nums;
+};
+```
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 0ea46b4476a9b4c1b963e5935882dd53cc971844 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Thu, 8 Oct 2020 10:07:48 +0800
Subject: [PATCH 79/87] =?UTF-8?q?add=20LeetCode=20344.=20=E5=8F=8D?=
=?UTF-8?q?=E8=BD=AC=E5=AD=97=E7=AC=A6=E4=B8=B2?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...54\345\255\227\347\254\246\344\270\262.md" | 84 +++++++++++++++++++
1 file changed, 84 insertions(+)
create mode 100644 "\345\217\214\346\214\207\351\222\210/LeetCode 344. \345\217\215\350\275\254\345\255\227\347\254\246\344\270\262.md"
diff --git "a/\345\217\214\346\214\207\351\222\210/LeetCode 344. \345\217\215\350\275\254\345\255\227\347\254\246\344\270\262.md" "b/\345\217\214\346\214\207\351\222\210/LeetCode 344. \345\217\215\350\275\254\345\255\227\347\254\246\344\270\262.md"
new file mode 100644
index 0000000..d045a8c
--- /dev/null
+++ "b/\345\217\214\346\214\207\351\222\210/LeetCode 344. \345\217\215\350\275\254\345\255\227\347\254\246\344\270\262.md"
@@ -0,0 +1,84 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 `char[]` 的形式给出。
+
+不要给另外的数组分配额外的空间，你必须**原地修改输入数组**、使用 O(1) 的额外空间解决这一问题。
+
+你可以假设数组中的所有字符都是 `ASCII` 码表中的可打印字符。
+
+
+
+示例 1：
+
+```javascript
+输入：["h","e","l","l","o"]
+输出：["o","l","l","e","h"]
+```
+
+示例 2：
+
+```javascript
+输入：["H","a","n","n","a","h"]
+输出：["h","a","n","n","a","H"]
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/reverse-string
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+## 解题思路
+
+方法一：利用JS原生api
+
+```javascript
+/**
+ * @param {character[]} s
+ * @return {void} Do not return anything, modify s in-place instead.
+ */
+var reverseString = function (s) {
+ return s.reverse();
+};
+```
+
+方法二：双指针，头尾交换
+
+```javascript
+/**
+ * @param {character[]} s
+ * @return {void} Do not return anything, modify s in-place instead.
+ */
+var reverseString = function (s) {
+ let i = 0, j = s.length - 1;
+ while (i < j) {
+ [s[i], s[j]] = [s[j], s[i]]; // 双指针，交换
+ i++ , j--;
+ }
+ return s;
+};
+```
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 33df3a13a6935b266a3b74dfbae9f1ab3081aad9 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Thu, 8 Oct 2020 10:30:06 +0800
Subject: [PATCH 80/87] =?UTF-8?q?add=20LeetCode=2011.=20=E7=9B=9B=E6=9C=80?=
=?UTF-8?q?=E5=A4=9A=E6=B0=B4=E7=9A=84=E5=AE=B9=E5=99=A8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...64\347\232\204\345\256\271\345\231\250.md" | 77 +++++++++++++++++++
1 file changed, 77 insertions(+)
create mode 100644 "\345\217\214\346\214\207\351\222\210/LeetCode 11. \347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250.md"
diff --git "a/\345\217\214\346\214\207\351\222\210/LeetCode 11. \347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250.md" "b/\345\217\214\346\214\207\351\222\210/LeetCode 11. \347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250.md"
new file mode 100644
index 0000000..ebb6299
--- /dev/null
+++ "b/\345\217\214\346\214\207\351\222\210/LeetCode 11. \347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250.md"
@@ -0,0 +1,77 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+给你 n 个非负整数 a1，a2，...，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
+
+**说明**：你不能倾斜容器，且 n 的值至少为 2。
+
+
+图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
+
+
+
+示例：
+
+```javascript
+输入：[1,8,6,2,5,4,8,3,7]
+输出：49
+```
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/container-with-most-water
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+## 解题思路
+
+双指针做法，我们需要枚举所有情况，有一点贪心的思想，每次我们得看短的板子让我们容纳的面积。每次都选择左右指针最短的那个板子，计算出当前容纳的最多的水，然后从短的板子指针出发向内缩，这样不断求，最终我们可以枚举所有情况，自然可以枚举出最大容器面积。
+
+```javascript
+/**
+ * @param {number[]} height
+ * @return {number}
+ */
+var maxArea = function (height) {
+ let len = height.length;
+ let L = 0;
+ let R = len - 1;
+ let res = 0;
+ while (L < R) {
+ if (height[L] < height[R]) { // 选择短板效应
+ let ans = height[L] * (R - L);
+ L++;
+ res = Math.max(res, ans); // 求当前容纳最多的水
+ } else {
+ let ans = height[R] * (R - L);
+ res = Math.max(res, ans);
+ R--;
+ }
+ }
+ return res;
+};
+```
+
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 04e753594168ff29bba5925cf05525649141f35a Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Thu, 8 Oct 2020 10:42:46 +0800
Subject: [PATCH 81/87] =?UTF-8?q?add=20LeetCode=2042.=20=E6=8E=A5=E9=9B=A8?=
=?UTF-8?q?=E6=B0=B4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.... \346\216\245\351\233\250\346\260\264.md" | 80 +++++++++++++++++++
1 file changed, 80 insertions(+)
create mode 100644 "\345\217\214\346\214\207\351\222\210/LeetCode 42. \346\216\245\351\233\250\346\260\264.md"
diff --git "a/\345\217\214\346\214\207\351\222\210/LeetCode 42. \346\216\245\351\233\250\346\260\264.md" "b/\345\217\214\346\214\207\351\222\210/LeetCode 42. \346\216\245\351\233\250\346\260\264.md"
new file mode 100644
index 0000000..0c45ae5
--- /dev/null
+++ "b/\345\217\214\346\214\207\351\222\210/LeetCode 42. \346\216\245\351\233\250\346\260\264.md"
@@ -0,0 +1,80 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
+
+
+上面是由数组 `[0,1,0,2,1,0,1,3,2,1,2,1] `表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。 感谢 Marcos 贡献此图。
+
+示例:
+
+```javascript
+输入: [0,1,0,2,1,0,1,3,2,1,2,1]
+输出: 6
+```
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/trapping-rain-water
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+## 解题思路
+
+这个存放水，我们就需要看左边两边指针的柱子看谁的高度小了，当前是看高度小的了。
+
+以左边为例：当前柱子存水量 = 最近最高柱子高度（只看左边到当前柱子） - 当前柱子高度
+
+右边同理。
+
+```javascript
+/**
+ * @param {number[]} height
+ * @return {number}
+ */
+var trap = function (height) {
+ let len = height.length;
+ let L = 0, R = len - 1;
+ let leftHeight = 0, rightHeight = 0;
+ let res = 0;
+ while (L < R) {
+ if (height[L] < height[R]) { // 左边高度小，当然看左边
+ leftHeight = Math.max(leftHeight, height[L]);
+ res += leftHeight - height[L]; // 当前柱子能存放的水
+ L++;
+ } else { // 右边高度小，看右边
+ rightHeight = Math.max(rightHeight, height[R]);
+ res += rightHeight - height[R]; // 当前柱子能存放的水
+ R--;
+ }
+ }
+ return res;
+};
+```
+
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 8b5980345cd8d876051da147cfc2cf17a5c378e6 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Thu, 8 Oct 2020 10:51:06 +0800
Subject: [PATCH 82/87] =?UTF-8?q?add=20LeetCode=20209.=20=E9=95=BF?=
=?UTF-8?q?=E5=BA=A6=E6=9C=80=E5=B0=8F=E7=9A=84=E5=AD=90=E6=95=B0=E7=BB=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...04\345\255\220\346\225\260\347\273\204.md" | 75 +++++++++++++++++++
1 file changed, 75 insertions(+)
create mode 100644 "\345\217\214\346\214\207\351\222\210/LeetCode 209. \351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md"
diff --git "a/\345\217\214\346\214\207\351\222\210/LeetCode 209. \351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md" "b/\345\217\214\346\214\207\351\222\210/LeetCode 209. \351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md"
new file mode 100644
index 0000000..32a0e34
--- /dev/null
+++ "b/\345\217\214\346\214\207\351\222\210/LeetCode 209. \351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md"
@@ -0,0 +1,75 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+
+给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。
+
+
+
+示例：
+
+```javascript
+输入：s = 7, nums = [2,3,1,2,4,3]
+输出：2
+解释：子数组 [4,3] 是该条件下的长度最小的子数组。
+```
+
+进阶：
+
+- 如果你已经完成了 O(n) 时间复杂度的解法, 请尝试 O(n log n) 时间复杂度的解法。
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/minimum-size-subarray-sum
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+## 解题思路
+
+滑动窗口，利用双指针实现，从左到右看，满足条件就把左指针左移，找到最小的长度，然后每次窗口右指针都往右滑动，直到数组末尾。
+
+```javascript
+/**
+ * @param {number} s
+ * @param {number[]} nums
+ * @return {number}
+ */
+var minSubArrayLen = function (s, nums) {
+ let len = nums.length;
+ let L = 0, R = 0;
+ let res = Infinity, sum = 0;
+ while (R < len) {
+ sum += nums[R];
+ while (sum >= s) { // 滑动窗口
+ res = Math.min(res, R - L + 1);
+ sum -= nums[L];
+ L++;
+ }
+ R++;
+ }
+ return res == Infinity ? 0 : res; // 判断合法性
+};
+```
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 411ef742cab38746ec99579d8d098e1f8349e1ec Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Sat, 10 Oct 2020 20:23:11 +0800
Subject: [PATCH 83/87] =?UTF-8?q?add=20LeetCode=20142.=20=E7=8E=AF?=
=?UTF-8?q?=E5=BD=A2=E9=93=BE=E8=A1=A8=20II?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...345\275\242\351\223\276\350\241\250 II.md" | 141 ++++++++++++++++++
1 file changed, 141 insertions(+)
create mode 100644 "\351\223\276\350\241\250/LeetCode 142. \347\216\257\345\275\242\351\223\276\350\241\250 II.md"
diff --git "a/\351\223\276\350\241\250/LeetCode 142. \347\216\257\345\275\242\351\223\276\350\241\250 II.md" "b/\351\223\276\350\241\250/LeetCode 142. \347\216\257\345\275\242\351\223\276\350\241\250 II.md"
new file mode 100644
index 0000000..996bd54
--- /dev/null
+++ "b/\351\223\276\350\241\250/LeetCode 142. \347\216\257\345\275\242\351\223\276\350\241\250 II.md"
@@ -0,0 +1,141 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
+
+为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。
+
+说明：不允许修改给定的链表。
+
+进阶：
+
+你是否可以不用额外空间解决此题？
+
+
+示例 1：
+
+
+
+
+```javascript
+输入：head = [3,2,0,-4], pos = 1
+输出：返回索引为 1 的链表节点
+解释：链表中有一个环，其尾部连接到第二个节点。
+```
+
+示例 2：
+
+
+
+
+```javascript
+输入：head = [1,2], pos = 0
+输出：返回索引为 0 的链表节点
+解释：链表中有一个环，其尾部连接到第一个节点。
+```
+
+示例 3：
+
+
+
+
+```javascript
+输入：head = [1], pos = -1
+输出：返回 null
+解释：链表中没有环。
+```
+
+
+
+提示：
+
+- 链表中节点的数目范围在范围 `[0, 104]` 内
+- `-10^5 <= Node.val <= 10^5`
+- pos 的值为 -1 或者链表中的一个有效索引
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/linked-list-cycle-ii
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+## 解题思路
+
+两个快慢指针，从头节点出发，如果链表有环，快指针肯定可以在环内和慢指针相遇。没有环就不可能再相遇，相遇必在环内。
+
+
+
+
+相遇时，慢指针走的距离：`D+S1D+S1`
+
+假设相遇时快指针已经绕环 n 次，它走的距离：`D+n(S1+S2)+S1D+n(S1+S2)+S1`
+
+因为快指针的速度是 2 倍，所以相同时间走的距离也是 2 倍：
+
+D+n(S1+S2)+S1 = 2(D+S1)
+
+求解得到：**(n-1)S1+ nS2=D**
+
+
+我们不关心在相遇时快指针已经绕了几次环，我们取 n = 1 ，消掉了 S1：
+
+**D=S2**
+
+那么，当快慢指针第一次相遇时，将快指针放回到头节点，由于 `D=s2`，那么我们快慢指针一起走，都走1步，它们必定会走到入环点，然后相遇，此时就可返回对应指针下标。
+
+```javascript
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ * this.val = val;
+ * this.next = null;
+ * }
+ */
+
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+var detectCycle = function(head) {
+ let fast = head, low = head; // 首先，都从头节点出现
+ while(fast){ // 确保存在环
+ if(fast.next == null) return null; // fast.next 为null表示无环
+ low = low.next; // 慢指针走一步
+ fast = fast.next.next; // 快指针走两步
+ if(low == fast){ // 初次相遇
+ fast = head; // 快指针回到头节点
+ while(true){
+ if(fast == low){
+ return low;
+ }
+ fast = fast.next; // 快慢指针一起走
+ low = low.next;
+ }
+ }
+
+ }
+ return null;
+};
+```
+参考 笨猪爆破组 图解
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From c897f178c31a9228b8c24da55810bf2ecd4c8ce0 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Wed, 21 Oct 2020 16:08:04 +0800
Subject: [PATCH 84/87] =?UTF-8?q?LeetCode=20925.=20=E9=95=BF=E6=8C=89?=
=?UTF-8?q?=E9=94=AE=E5=85=A5?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...77\346\214\211\351\224\256\345\205\245.md" | 119 ++++++++++++++++++
1 file changed, 119 insertions(+)
create mode 100644 "\345\217\214\346\214\207\351\222\210/LeetCode 925. \351\225\277\346\214\211\351\224\256\345\205\245.md"
diff --git "a/\345\217\214\346\214\207\351\222\210/LeetCode 925. \351\225\277\346\214\211\351\224\256\345\205\245.md" "b/\345\217\214\346\214\207\351\222\210/LeetCode 925. \351\225\277\346\214\211\351\224\256\345\205\245.md"
new file mode 100644
index 0000000..1bbf920
--- /dev/null
+++ "b/\345\217\214\346\214\207\351\222\210/LeetCode 925. \351\225\277\346\214\211\351\224\256\345\205\245.md"
@@ -0,0 +1,119 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+你的朋友正在使用键盘输入他的名字 `name`。偶尔，在键入字符 `c` 时，按键可能会被长按，而字符可能被输入 1 次或多次。
+
+你将会检查键盘输入的字符 `typed`。如果它对应的可能是你的朋友的名字（其中一些字符可能被长按），那么就返回 `True`。
+
+
+
+示例 1：
+
+```javascript
+输入：name = "alex", typed = "aaleex"
+输出：true
+解释：'alex' 中的 'a' 和 'e' 被长按。
+```
+
+示例 2：
+
+```javascript
+输入：name = "saeed", typed = "ssaaedd"
+输出：false
+解释：'e' 一定需要被键入两次，但在 typed 的输出中不是这样。
+```
+
+示例 3：
+
+```javascript
+输入：name = "leelee", typed = "lleeelee"
+输出：true
+```
+
+示例 4：
+
+```javascript
+输入：name = "laiden", typed = "laiden"
+输出：true
+解释：长按名字中的字符并不是必要的。
+```
+
+
+
+提示：
+
+- `name.length` <= 1000
+- `typed.length` <= 1000
+- `name` 和 `typed` 的字符都是小写字母。
+
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/long-pressed-name
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+
+
+## 解题思路
+显而易见，采用双指针做法，通过 `cnt` 计数统计字符匹配成功个数，然后通过双指针进行比较匹配，其中有几个地方注意一下：
+
+- 如果 `typed` 和 `name` 的当前索引前一位都不相等的话，那么名字就不对应，直接跳出去，这里算是小小的优化了一下。
+- 当 `typed` 走完才能跳出去，如果是 `i == n` 就跳出去的话，这种情况：name：abc | typed：abcd 就会判断出错
+
+
+```javascript
+/**
+ * @param {string} name
+ * @param {string} typed
+ * @return {boolean}
+ */
+var isLongPressedName = function (name, typed) {
+ let n = name.length; // 求出字符串长度
+ let m = typed.length;
+ let cnt = 0; // 统计匹配成功个数
+ let i = 0, j = 0; // 双指针
+ let flag = false; // 判断是否中途遇到不匹配阶段
+ while (1) {
+ if (name[i] == typed[j]) { // 匹配成功
+ i++ , cnt++ , j++;
+ } else {
+ if (typed[j] == name[i - 1]) {
+ j++;
+ } else {
+ // 如果 typed 和 name 当前索引前一位都不相等的话，那么名字就不对应，直接跳出去
+ flag = true;
+ }
+ }
+ if (flag) break;
+ if (j == m) break; // 当 typed走完才能跳出去，如果是 i == n 就跳出去的话，这种情况：abc | abcd 就会判断出错
+ }
+ if (cnt === n && j === m) return true;
+ else return false;
+};
+```
+
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 31514b34dc2216faa9eb1d919e5db6e37860e4ec Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Wed, 21 Oct 2020 16:11:11 +0800
Subject: [PATCH 85/87] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E6=80=9D=E7=BB=B4?=
=?UTF-8?q?=E5=AF=BC=E5=9B=BE?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
README.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/README.md b/README.md
index 6528590..6cb3778 100644
--- a/README.md
+++ b/README.md
@@ -13,7 +13,7 @@
>思维导图还在建设完善中ing
-
+
## :snowman:笔记网站（更新）
From fee04d34abbb6f6f1c68be4f48e15edc01df09a8 Mon Sep 17 00:00:00 2001
From: Chocolate1999 <2816778271@qq.com>
Date: Thu, 22 Oct 2020 10:49:46 +0800
Subject: [PATCH 86/87] =?UTF-8?q?LeetCode=20763.=20=E5=88=92=E5=88=86?=
=?UTF-8?q?=E5=AD=97=E6=AF=8D=E5=8C=BA=E9=97=B4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...27\346\257\215\345\214\272\351\227\264.md" | 92 +++++++++++++++++++
1 file changed, 92 insertions(+)
create mode 100644 "\345\217\214\346\214\207\351\222\210/LeetCode 763. \345\210\222\345\210\206\345\255\227\346\257\215\345\214\272\351\227\264.md"
diff --git "a/\345\217\214\346\214\207\351\222\210/LeetCode 763. \345\210\222\345\210\206\345\255\227\346\257\215\345\214\272\351\227\264.md" "b/\345\217\214\346\214\207\351\222\210/LeetCode 763. \345\210\222\345\210\206\345\255\227\346\257\215\345\214\272\351\227\264.md"
new file mode 100644
index 0000000..c323d79
--- /dev/null
+++ "b/\345\217\214\346\214\207\351\222\210/LeetCode 763. \345\210\222\345\210\206\345\255\227\346\257\215\345\214\272\351\227\264.md"
@@ -0,0 +1,92 @@
+
+>仰望星空的人，不应该被嘲笑
+
+## 题目描述
+字符串 `S` 由小写字母组成。我们要把这个字符串划分为尽可能多的片段，同一个字母只会出现在其中的一个片段。返回一个表示每个字符串片段的长度的列表。
+
+
+示例 1：
+
+```javascript
+输入：S = "ababcbacadefegdehijhklij"
+输出：[9,7,8]
+解释：
+划分结果为 "ababcbaca", "defegde", "hijhklij"。
+每个字母最多出现在一个片段中。
+像 "ababcbacadefegde", "hijhklij" 的划分是错误的，因为划分的片段数较少。
+```
+
+提示：
+
+- `S` 的长度在 `[1, 500]` 之间。
+- `S` 只包含小写字母 `'a'` 到 `'z'` 。
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/partition-labels
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+
+## 解题思路
+此题是一个挺有意思的题，既有**贪心**的味道，又有**双指针**的味道，下面说一下解题思路：
+
+首先维护一个 `map`，它用来统计字当前字母的位置，而我们通过遍历就可以记录得到每个字母的最远位置。
+
+然后，再次遍历字符串时，我们既可以得到当前字母的最远位置，根据贪心思想，为了让同一个字母只会出现在其中的一个片段，那么对于这个字母一定要是最远位置，我们就可以得到一个**范围区间**，即 `maxLen `。
+
+得到了 `maxLen `后，我们还需要让 `i` 指针，即**尾指针**走到这个地方才算我们可以切分的片段。
+
+（想想，如果不走到 `maxLen `的话，这个范围区间内的字母可能会有更远的位置，那么就无法满足让同一个字母只会出现在其中的一个片段这个条件了）
+
+
+
+参考 笨猪爆破组 大佬图解。
+
+```javascript
+/**
+ * @param {string} S
+ * @return {number[]}
+ */
+var partitionLabels = function (S) {
+ let map = {}; // 用来统计当前字母最远位置
+ for (let i = 0; i < S.length; i++) {
+ map[S[i]] = i; // 存储当前字母当前位置
+ }
+ let start = 0; // 头指针
+ let res = [];
+ let maxLen = 0;
+ for (let i = 0; i < S.length; i++) {
+ let curMaxLen = map[S[i]];
+ maxLen = Math.max(maxLen, curMaxLen); // 计算出当前区间范围是否还可以继续扩大区间
+ if (i === maxLen) {
+ let tmp = i - start + 1;
+ start = i + 1;
+ res.push(tmp); // 划分片段
+ }
+ }
+ return res;
+};
+```
+
+
+
+## 最后
+文章产出不易，还望各位小伙伴们支持一波！
+
+往期精选：
+
+小狮子前端の笔记仓库
+
+leetcode-javascript：LeetCode 力扣的 JavaScript 解题仓库，前端刷题路线（思维导图）
+
+小伙伴们可以在Issues中提交自己的解题代码，🤝 欢迎Contributing，可打卡刷题，Give a ⭐️ if this project helped you!
+
+
+访问超逸の博客，方便小伙伴阅读玩耍~
+
+
+
+```javascript
+学如逆水行舟，不进则退
+```
+
+
From 7b97206103ac2e733b93a89b8dc87ad927be722f Mon Sep 17 00:00:00 2001
From: yangchaoyi <61035508+Chocolate1999@users.noreply.github.com>
Date: Thu, 19 Aug 2021 09:33:54 +0800
Subject: [PATCH 87/87] Update README.md
---
README.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/README.md b/README.md
index 6cb3778..b32147b 100644
--- a/README.md
+++ b/README.md
@@ -67,7 +67,7 @@ https://yangchaoyi.vip/iBook/ （基于vuepress搭建的前端学习笔记，目
## :trophy:结尾
-欢迎关注微信公众号：小狮子前端Vue
+欢迎关注微信公众号：小狮子前端
谢谢您的支持！✿✿ヽ(°▽°)ノ✿
