Update

nowsoar · Aug 14, 2022 · 5ec1375 · 5ec1375
1 parent 41e677c
commit 5ec1375
Show file tree

Hide file tree

Showing 36 changed files with 88 additions and 128 deletions.
diff --git a/problems/0018.四数之和.md b/problems/0018.四数之和.md
@@ -74,7 +74,7 @@ public:
         sort(nums.begin(), nums.end());
         for (int k = 0; k < nums.size(); k++) {
             // 剪枝处理
-            if (nums[k] > target && nums[k] >= 0 && target >= 0) {
+            if (nums[k] > target && nums[k] >= 0) {
             	break; // 这里使用break，统一通过最后的return返回
             }
             // 对nums[k]去重
@@ -83,7 +83,7 @@ public:
             }
             for (int i = k + 1; i < nums.size(); i++) {
                 // 2级剪枝处理
-                if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0 && target >= 0) {
+                if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) {
                     break;
                 }
 

diff --git a/problems/0019.删除链表的倒数第N个节点.md b/problems/0019.删除链表的倒数第N个节点.md
@@ -33,6 +33,9 @@
 
 ## 思路
 
+《代码随想录》算法公开课：[链表遍历学清楚！ | LeetCode：19.删除链表倒数第N个节点](https://www.bilibili.com/video/BV1vW4y1U7Gf)，相信结合视频在看本篇题解，更有助于大家对链表的理解。
+
+
 双指针的经典应用，如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了。
 
 思路是这样的，但要注意一些细节。

diff --git a/problems/0020.有效的括号.md b/problems/0020.有效的括号.md
@@ -41,6 +41,9 @@
 
 # 思路
 
+《代码随想录》算法视频公开课：[栈的拿手好戏！| LeetCode：20. 有效的括号](https://www.bilibili.com/video/BV1AF411w78g)，相信结合视频在看本篇题解，更有助于大家对链表的理解。
+
+
 ## 题外话
 
 **括号匹配是使用栈解决的经典问题。**
@@ -79,8 +82,10 @@ cd a/b/c/../../
 
 1. 第一种情况，字符串里左方向的括号多余了 ，所以不匹配。
 ![括号匹配1](https://img-blog.csdnimg.cn/2020080915505387.png)
+
 2. 第二种情况，括号没有多余，但是 括号的类型没有匹配上。
 ![括号匹配2](https://img-blog.csdnimg.cn/20200809155107397.png)
+
 3. 第三种情况，字符串里右方向的括号多余了，所以不匹配。
 ![括号匹配3](https://img-blog.csdnimg.cn/20200809155115779.png)
 
@@ -110,7 +115,8 @@ cd a/b/c/../../
 class Solution {
 public:
     bool isValid(string s) {
-        stack<int> st;
+        if (s.size() % 2 != 0) return false; // 如果s的长度为奇数，一定不符合要求
+        stack<char> st;
         for (int i = 0; i < s.size(); i++) {
             if (s[i] == '(') st.push(')');
             else if (s[i] == '{') st.push('}');
@@ -124,6 +130,7 @@ public:
         return st.empty();
     }
 };
+
 ```
 技巧性的东西没有固定的学习方法，还是要多看多练，自己灵活运用了。
 

diff --git a/problems/0024.两两交换链表中的节点.md b/problems/0024.两两交换链表中的节点.md
@@ -18,7 +18,8 @@
 
 ## 思路
 
-针对本题重点难点，我录制了B站讲解视频，[帮你把链表细节学清楚！ | LeetCode：24. 两两交换链表中的节点](https://www.bilibili.com/video/BV1YT411g7br)，相信结合视频在看本篇题解，更有助于大家对链表的理解。
+《代码随想录》算法公开课：[帮你把链表细节学清楚！ | LeetCode：24. 两两交换链表中的节点](https://www.bilibili.com/video/BV1YT411g7br)，相信结合视频在看本篇题解，更有助于大家对链表的理解。
+
 
 这道题目正常模拟就可以了。
 

diff --git a/problems/0053.最大子序和（动态规划）.md b/problems/0053.最大子序和（动态规划）.md
@@ -4,7 +4,7 @@
 </a>
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
-## 53. 最大子序和
+# 53. 最大子序和
 
 [力扣题目链接](https://leetcode.cn/problems/maximum-subarray/)
 

diff --git a/problems/0054.螺旋矩阵.md b/problems/0054.螺旋矩阵.md
@@ -132,69 +132,6 @@ public:
 * [剑指Offer 29.顺时针打印矩阵](https://leetcode.cn/problems/shun-shi-zhen-da-yin-ju-zhen-lcof/)
 
 ## 其他语言版本
-Python:
-```python
-class Solution:
-    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
-        m, n = len(matrix), len(matrix[0])
-        left, right, up, down = 0, n - 1, 0, m - 1 # 定位四个方向的边界，闭区间
-        res = []
-
-        while True:
-            for i in range(left, right + 1): # 上边，从左到右
-                res.append(matrix[up][i])
-            up += 1 # 上边界下移
-
-            if len(res) >= m * n: # 判断是否已经遍历完
-                break
-
-            for i in range(up, down + 1): # 右边，从上到下
-                res.append(matrix[i][right])
-            right -= 1 # 右边界左移
-
-            if len(res) >= m * n:
-                break
-
-            for i in range(right, left - 1, -1): # 下边，从右到左
-                res.append(matrix[down][i])
-            down -= 1 # 下边界上移
-
-            if len(res) >= m * n:
-                break
-
-            for i in range(down, up - 1, -1): # 左边，从下到上
-                res.append(matrix[i][left])
-            left += 1 # 左边界右移
-
-            if len(res) >= m * n:
-                break
-
-        return res
-```
-```python3
-class Solution:
-    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
-        r=len(matrix)
-        if r == 0 or len(matrix[0])==0: 
-            return []
-        c=len(matrix[0])
-        res=matrix[0]
-
-        if r>1: 
-            for i in range (1,r):
-                res.append(matrix[i][c-1])
-            for j in range(c-2, -1, -1):
-                res.append(matrix[r-1][j])
-            if c>1:    
-                for i in range(r-2, 0, -1):    
-                    res.append(matrix[i][0])
-
-        M=[]
-        for k in range(1, r-1):
-            e=matrix[k][1:-1]
-            M.append(e)
-
-        return res+self.spiralOrder(M) 
-```        
+
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>
diff --git a/problems/0072.编辑距离.md b/problems/0072.编辑距离.md
@@ -4,7 +4,7 @@
 </a>
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
-## 72. 编辑距离
+# 72. 编辑距离
 
 [力扣题目链接](https://leetcode.cn/problems/edit-distance/)
 

diff --git a/problems/0115.不同的子序列.md b/problems/0115.不同的子序列.md
@@ -4,7 +4,7 @@
 </a>
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
-## 115.不同的子序列
+# 115.不同的子序列
 
 [力扣题目链接](https://leetcode.cn/problems/distinct-subsequences/)
 

diff --git a/problems/0121.买卖股票的最佳时机.md b/problems/0121.买卖股票的最佳时机.md
@@ -4,7 +4,7 @@
 </a>
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
-## 121. 买卖股票的最佳时机
+# 121. 买卖股票的最佳时机
 
 [力扣题目链接](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock/)
 

diff --git a/problems/0122.买卖股票的最佳时机II（动态规划）.md b/problems/0122.买卖股票的最佳时机II（动态规划）.md
@@ -4,7 +4,7 @@
 </a>
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
-## 122.买卖股票的最佳时机II 
+# 122.买卖股票的最佳时机II 
 
 [力扣题目链接](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii/)
 

diff --git a/problems/0123.买卖股票的最佳时机III.md b/problems/0123.买卖股票的最佳时机III.md
@@ -4,7 +4,7 @@
 </a>
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
-## 123.买卖股票的最佳时机III
+# 123.买卖股票的最佳时机III
 
 [力扣题目链接](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iii/)
 

diff --git a/problems/0142.环形链表II.md b/problems/0142.环形链表II.md
@@ -24,7 +24,8 @@
 
 ## 思路
 
-为了易于大家理解，我录制讲解视频：[B站：把环形链表讲清楚！ ](https://www.bilibili.com/video/BV1if4y1d7ob)。结合视频在看本篇题解，事半功倍。
+《代码随想录》算法公开课：[把环形链表讲清楚！| LeetCode:142.环形链表II](https://www.bilibili.com/video/BV1if4y1d7ob)，相信结合视频在看本篇题解，更有助于大家对链表的理解。
+
 
 这道题目，不仅考察对链表的操作，而且还需要一些数学运算。
 

diff --git a/problems/0188.买卖股票的最佳时机IV.md b/problems/0188.买卖股票的最佳时机IV.md
@@ -4,7 +4,7 @@
 </a>
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
-## 188.买卖股票的最佳时机IV
+# 188.买卖股票的最佳时机IV
 
 [力扣题目链接](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iv/)
 

diff --git a/problems/0198.打家劫舍.md b/problems/0198.打家劫舍.md
@@ -4,7 +4,7 @@
 </a>
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
-## 198.打家劫舍
+# 198.打家劫舍
 
 [力扣题目链接](https://leetcode.cn/problems/house-robber/)
 

diff --git a/problems/0213.打家劫舍II.md b/problems/0213.打家劫舍II.md
@@ -4,7 +4,7 @@
 </a>
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
-## 213.打家劫舍II
+# 213.打家劫舍II
 
 [力扣题目链接](https://leetcode.cn/problems/house-robber-ii/)
 

diff --git a/problems/0225.用队列实现栈.md b/problems/0225.用队列实现栈.md
@@ -28,6 +28,10 @@
 
 # 思路
 
+
+《代码随想录》算法公开课：[队列的基本操作！ | LeetCode：225. 用队列实现栈](https://www.bilibili.com/video/BV1Fd4y1K7sm)，相信结合视频在看本篇题解，更有助于大家对链表的理解。
+
+
 （这里要强调是单向队列）
 
 有的同学可能疑惑这种题目有什么实际工程意义，**其实很多算法题目主要是对知识点的考察和教学意义远大于其工程实践的意义，所以面试题也是这样！**

diff --git a/problems/0232.用栈实现队列.md b/problems/0232.用栈实现队列.md
@@ -38,6 +38,9 @@ queue.empty(); // 返回 false
 
 ## 思路
 
+《代码随想录》算法公开课：[栈的基本操作！ | LeetCode：232.用栈实现队列](https://www.bilibili.com/video/BV1nY4y1w7VC)，相信结合视频在看本篇题解，更有助于大家对链表的理解。
+
+
 这是一道模拟题，不涉及到具体算法，考察的就是对栈和队列的掌握程度。
 
 使用栈来模式队列的行为，如果仅仅用一个栈，是一定不行的，所以需要两个栈**一个输入栈，一个输出栈**，这里要注意输入栈和输出栈的关系。
@@ -170,14 +173,6 @@ class MyQueue {
     }
 }
 
-/**
- * Your MyQueue object will be instantiated and called as such:
- * MyQueue obj = new MyQueue();
- * obj.push(x);
- * int param_2 = obj.pop();
- * int param_3 = obj.peek();
- * boolean param_4 = obj.empty();
- */
 ```
 
 

diff --git a/problems/0239.滑动窗口最大值.md b/problems/0239.滑动窗口最大值.md
@@ -36,7 +36,7 @@
 
 难点是如何求一个区间里的最大值呢？ （这好像是废话），暴力一下不就得了。
 
-暴力方法，遍历一遍的过程中每次从窗口中在找到最大的数值，这样很明显是$O(n × k)$的算法。
+暴力方法，遍历一遍的过程中每次从窗口中在找到最大的数值，这样很明显是O(n × k)的算法。
 
 有的同学可能会想用一个大顶堆（优先级队列）来存放这个窗口里的k个数字，这样就可以知道最大的最大值是多少了， **但是问题是这个窗口是移动的，而大顶堆每次只能弹出最大值，我们无法移除其他数值，这样就造成大顶堆维护的不是滑动窗口里面的数值了。所以不能用大顶堆。**
 
@@ -183,13 +183,13 @@ public:
 };
 ```
 
-在来看一下时间复杂度，使用单调队列的时间复杂度是 $O(n)$。
+在来看一下时间复杂度，使用单调队列的时间复杂度是 O(n)。
 
-有的同学可能想了，在队列中 push元素的过程中，还有pop操作呢，感觉不是纯粹的$O(n)$。
+有的同学可能想了，在队列中 push元素的过程中，还有pop操作呢，感觉不是纯粹的O(n)。
 
-其实，大家可以自己观察一下单调队列的实现，nums 中的每个元素最多也就被 push_back 和 pop_back 各一次，没有任何多余操作，所以整体的复杂度还是 $O(n)$。
+其实，大家可以自己观察一下单调队列的实现，nums 中的每个元素最多也就被 push_back 和 pop_back 各一次，没有任何多余操作，所以整体的复杂度还是 O(n)。
 
-空间复杂度因为我们定义一个辅助队列，所以是$O(k)$。
+空间复杂度因为我们定义一个辅助队列，所以是O(k)。
 
 # 扩展
 

diff --git a/problems/0300.最长上升子序列.md b/problems/0300.最长上升子序列.md
@@ -4,7 +4,7 @@
 </a>
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
-## 300.最长递增子序列
+# 300.最长递增子序列
 
 [力扣题目链接](https://leetcode.cn/problems/longest-increasing-subsequence/)
 

diff --git a/problems/0309.最佳买卖股票时机含冷冻期.md b/problems/0309.最佳买卖股票时机含冷冻期.md
@@ -4,7 +4,7 @@
 </a>
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
-## 309.最佳买卖股票时机含冷冻期
+# 309.最佳买卖股票时机含冷冻期
 
 [力扣题目链接](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-cooldown/)
 

diff --git a/problems/0337.打家劫舍III.md b/problems/0337.打家劫舍III.md
@@ -5,7 +5,7 @@
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
 
-## 337.打家劫舍 III
+# 337.打家劫舍 III
 
 [力扣题目链接](https://leetcode.cn/problems/house-robber-iii/)
 

diff --git a/problems/0392.判断子序列.md b/problems/0392.判断子序列.md
@@ -5,7 +5,7 @@
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
 
-## 392.判断子序列
+# 392.判断子序列
 
 [力扣题目链接](https://leetcode.cn/problems/is-subsequence/)
 

diff --git a/problems/0459.重复的子字符串.md b/problems/0459.重复的子字符串.md
@@ -31,13 +31,16 @@
 
 # 思路
 
+针对本题，我录制了视频讲解：[字符串这么玩，可有点难度！ | LeetCode：459.重复的子字符串](https://www.bilibili.com/video/BV1cg41127fw)，结合本题解一起看，事半功倍！
+
+
 暴力的解法， 就是一个for循环获取 子串的终止位置， 然后判断子串是否能重复构成字符串，又嵌套一个for循环，所以是O(n^2)的时间复杂度。
 
 有的同学可以想，怎么一个for循环就可以获取子串吗？ 至少得一个for获取子串起始位置，一个for获取子串结束位置吧。 
 
 其实我们只需要判断，以第一个字母为开始的子串就可以，所以一个for循环获取子串的终止位置就行了。 而且遍历的时候 都不用遍历结束，只需要遍历到中间位置，因为子串结束位置大于中间位置的话，一定不能重复组成字符串。 
 
-暴力的解法，这里就不讲了。 
+暴力的解法，这里就不详细讲解了。
 
 主要讲一讲移动匹配 和 KMP两种方法。 
 

diff --git a/problems/0516.最长回文子序列.md b/problems/0516.最长回文子序列.md
@@ -4,7 +4,8 @@
 </a>
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
-## 516.最长回文子序列
+# 516.最长回文子序列 
+
 [力扣题目链接](https://leetcode.cn/problems/longest-palindromic-subsequence/)
 
 给定一个字符串 s ，找到其中最长的回文子序列，并返回该序列的长度。可以假设 s 的最大长度为 1000 。

diff --git a/problems/0583.两个字符串的删除操作.md b/problems/0583.两个字符串的删除操作.md
@@ -4,7 +4,7 @@
 </a>
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
-## 583. 两个字符串的删除操作 
+# 583. 两个字符串的删除操作 
 
 [力扣题目链接](https://leetcode.cn/problems/delete-operation-for-two-strings/)
 

diff --git a/problems/0647.回文子串.md b/problems/0647.回文子串.md
@@ -4,7 +4,7 @@
 </a>
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
-## 647. 回文子串
+# 647. 回文子串
 
 [力扣题目链接](https://leetcode.cn/problems/palindromic-substrings/)
 

diff --git a/problems/0674.最长连续递增序列.md b/problems/0674.最长连续递增序列.md
@@ -4,7 +4,7 @@
 </a>
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
-## 674. 最长连续递增序列
+# 674. 最长连续递增序列
 
 [力扣题目链接](https://leetcode.cn/problems/longest-continuous-increasing-subsequence/)