Merge branch 'master' into ChenjieXu-72-python

动态规划系列/动态规划之KMP字符匹配算法.md

@@ -428,5 +428,7 @@ KMP 算法也就是动态规划那点事，我们的公众号文章目录有一
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

动态规划系列/动态规划之博弈问题.md

@@ -22,7 +22,7 @@
 
 上一篇文章 [几道智力题](https://labuladong.gitbook.io/algo) 中讨论到一个有趣的「石头游戏」，通过题目的限制条件，这个游戏是先手必胜的。但是智力题终究是智力题，真正的算法问题肯定不会是投机取巧能搞定的。所以，本文就借石头游戏来讲讲「假设两个人都足够聪明，最后谁会获胜」这一类问题该如何用动态规划算法解决。
 
-博弈类问题的套路都差不多，下文举例讲解，其核心思路是在二维 dp 的基础上使用元组分别存储两个人的博弈结果。掌握了这个技巧以后，别人再问你什么俩海盗分宝石，俩人拿硬币的问题，你就告诉别人：我懒得想，直接给你写个算法算一下得了。
+博弈类问题的套路都差不多，下文参考 [这个 YouTube 视频](https://www.youtube.com/watch?v=WxpIHvsu1RI) 的思路讲解，其核心思路是在二维 dp 的基础上使用元组分别存储两个人的博弈结果。掌握了这个技巧以后，别人再问你什么俩海盗分宝石，俩人拿硬币的问题，你就告诉别人：我懒得想，直接给你写个算法算一下得了。
 
 我们「石头游戏」改的更具有一般性：
 
@@ -212,5 +212,78 @@ int stoneGame(int[] piles) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
+
+
+
+
+
+python3版本
+
+由[SCUHZS](https://github.com/brucecat)提供
+
+这里采取的是三维的做法
+
+```python
+class Solution:
+    def stoneGame(self, piles: List[int]) -> bool:
+        n = len(piles)
+
+        # 初始化一个n*n的矩阵 dp数组
+        dp = [[None] * n for i in range(0, n)]
+
+        # 在三角区域填充
+        for i in range(n):
+            for j in range(i, n):
+                dp[i][j] = [0, 0]
+
+        # 填入base case
+        for i in range(0, n):
+            dp[i][i][0] = piles[i]
+            dp[i][i][1] = 0
+
+        # 斜着遍历数组
+        for l in range(2, n + 1):
+            for i in range(0, n-l+1):
+                j = l + i - 1
+
+
+                # 先手选择最左边或最右边的分数
+                left = piles[i] + dp[i + 1][j][1]
+                right = piles[j] + dp[i][j - 1][1]
+
+                # 套用状态转移方程
+                if left > right:
+                    dp[i][j][0] = left
+                    dp[i][j][1] = dp[i + 1][j][0]
+                else:
+                    dp[i][j][0] = right
+                    dp[i][j][1] = dp[i][j - 1][0]
+
+        res = dp[0][n - 1]
+
+        return res[0] - res[1] > 0
+
+```
+
+
+
+压缩成一维数组，以减小空间复杂度，做法如下。
+
+```python
+class Solution:
+    def stoneGame(self, piles: List[int]) -> bool:
+        dp = piles.copy()
+
+        for i in range(len(piles) - 1, -1, -1):  # 从下往上遍历
+            for j in range(i, len(piles)):       # 从前往后遍历
+                dp[j] = max(piles[i] - dp[j], piles[j] - dp[j - 1])  # 计算之后覆盖一维数组的对应位置
+
+        return dp[len(piles) - 1] > 0
+        
+
+```
+

动态规划系列/动态规划之四键键盘.md

@@ -197,5 +197,7 @@ def dp(n, a_num, copy):
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

动态规划系列/动态规划之正则表达.md

@@ -292,6 +292,7 @@ bool dp(string& s, int i, string& p, int j) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
 
+======其他语言代码======

动态规划系列/动态规划设计：最长递增子序列.md

@@ -10,8 +10,8 @@
 ![](../pictures/souyisou.png)
 
 相关推荐：
-  * [动态规划设计：最大子数组](../动态规划系列/最大子数组.md)
-  * [一文学会递归解题](../投稿/一文学会递归解题.md)
+  * [动态规划设计：最大子数组](https://labuladong.gitbook.io/algo)
+  * [一文学会递归解题](https://labuladong.gitbook.io/algo)
 
 读完本文，你不仅学会了算法套路，还可以顺便去 LeetCode 上拿下如下题目：
 
@@ -19,7 +19,7 @@
 
 **-----------**
 
-也许有读者看了前文 [动态规划详解](../动态规划系列/动态规划详解进阶.md)，学会了动态规划的套路：找到了问题的「状态」，明确了 `dp` 数组/函数的含义，定义了 base case；但是不知道如何确定「选择」，也就是不到状态转移的关系，依然写不出动态规划解法，怎么办？
+也许有读者看了前文 [动态规划详解](https://labuladong.gitbook.io/algo)，学会了动态规划的套路：找到了问题的「状态」，明确了 `dp` 数组/函数的含义，定义了 base case；但是不知道如何确定「选择」，也就是不到状态转移的关系，依然写不出动态规划解法，怎么办？
 
 不要担心，动态规划的难点本来就在于寻找正确的状态转移方程，本文就借助经典的「最长递增子序列问题」来讲一讲设计动态规划的通用技巧：**数学归纳思想**。
 
@@ -43,7 +43,7 @@
 
 **我们的定义是这样的：`dp[i]` 表示以 `nums[i]` 这个数结尾的最长递增子序列的长度。**
 
-PS：为什么这样定义呢？这是解决子序列问题的一个套路，后文[动态规划之子序列问题解题模板](../动态规划系列/子序列问题模板.md) 总结了几种常见套路。你读完本章所有的动态规划问题，就会发现 `dp` 数组的定义方法也就那几种。
+PS：为什么这样定义呢？这是解决子序列问题的一个套路，后文[动态规划之子序列问题解题模板](https://labuladong.gitbook.io/algo) 总结了几种常见套路。你读完本章所有的动态规划问题，就会发现 `dp` 数组的定义方法也就那几种。
 
 根据这个定义，我们就可以推出 base case：`dp[i]` 初始值为 1，因为以 `nums[i]` 结尾的最长递增子序列起码要包含它自己。
 
@@ -164,7 +164,7 @@ public int lengthOfLIS(int[] nums) {
 
 我们只要把处理扑克牌的过程编程写出来即可。每次处理一张扑克牌不是要找一个合适的牌堆顶来放吗，牌堆顶的牌不是**有序**吗，这就能用到二分查找了：用二分查找来搜索当前牌应放置的位置。
 
-PS：旧文[二分查找算法详解](../算法思维系列/二分查找详解.md)详细介绍了二分查找的细节及变体，这里就完美应用上了，如果没读过强烈建议阅读。
+PS：旧文[二分查找算法详解](https://labuladong.gitbook.io/algo)详细介绍了二分查找的细节及变体，这里就完美应用上了，如果没读过强烈建议阅读。
 
 ```java
 public int lengthOfLIS(int[] nums) {
@@ -212,5 +212,48 @@ public int lengthOfLIS(int[] nums) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
+
+[Kian](https://github.com/KianKw/) 提供 C++ 代码
+
+```c++
+class Solution {
+public:
+    int lengthOfLIS(vector<int>& nums) {
+        /* len 为牌的数量 */
+        int len = nums.size();
+        vector<int> top(len, 0);
+        /* 牌堆数初始化为0 */
+        int piles = 0;
+        for (int i = 0; i < len; i++) {
+            /* nums[i] 为要处理的扑克牌 */
+            int poker = nums[i];
+
+            /***** 搜索左侧边界的二分查找 *****/
+            int left = 0, right = piles;
+            while (left < right) {
+                int mid = left + (right - left) / 2;
+                if (top[mid] > poker) {
+                    right = mid;
+                } else if (top[mid] < poker) {
+                    left = mid + 1;
+                } else if (top[mid] == poker) {
+                    right = mid;
+                }
+            }
+            /*********************************/
+
+            /* 没找到合适的牌堆，新建一堆 */
+            if (left == piles)
+                piles++;
+            /* 把这张牌放到牌堆顶 */
+            top[left] = poker;
+        }
+        /* 牌堆数就是 LIS 长度 */
+        return piles;
+    }
+};
+```

动态规划系列/动态规划详解进阶.md

@@ -363,5 +363,7 @@ PS：为啥 `dp` 数组初始化为 `amount + 1` 呢，因为凑成 `amount` 金
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

动态规划系列/团灭股票问题.md

@@ -16,7 +16,7 @@
 
 读完本文，你不仅学会了算法套路，还可以顺便去 LeetCode 上拿下如下题目：
 
-[买卖股票的最佳时机](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock/solution/)
+[买卖股票的最佳时机](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock)
 
 [买卖股票的最佳时机 II](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii/)
 
@@ -32,7 +32,7 @@
 
 很多读者抱怨 LeetCode 的股票系列问题奇技淫巧太多，如果面试真的遇到这类问题，基本不会想到那些巧妙的办法，怎么办？**所以本文拒绝奇技淫巧，而是稳扎稳打，只用一种通用方法解决所用问题，以不变应万变**。
 
-这篇文章用状态机的技巧来解决，可以全部提交通过。不要觉得这个名词高大上，文学词汇而已，实际上就是 DP table，看一眼就明白了。
+这篇文章参考 [英文版高赞题解](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/discuss/108870/Most-consistent-ways-of-dealing-with-the-series-of-stock-problems) 的思路，用状态机的技巧来解决，可以全部提交通过。不要觉得这个名词高大上，文学词汇而已，实际上就是 DP table，看一眼就明白了。
 
 先随便抽出一道题，看看别人的解法：
 
@@ -425,5 +425,7 @@ int maxProfit_k_any(int max_k, int[] prices) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

动态规划系列/子序列问题模板.md

 # 动态规划之子序列问题解题模板
 
-**学好算法全靠套路，认准 labuladong 就够了**。
+
 
 <p align='center'>
 <a href="https://github.com/labuladong/fucking-algorithm" target="view_window"><img alt="GitHub" src="https://img.shields.io/github/stars/labuladong/fucking-algorithm?label=Stars&style=flat-square&logo=GitHub"></a>
@@ -171,5 +171,7 @@ int longestPalindromeSubseq(string s) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，labuladong 带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

动态规划系列/抢房子.md

 # 团灭 LeetCode 打家劫舍问题
 
-**学好算法全靠套路，认准 labuladong 就够了**。
-
 <p align='center'>
 <a href="https://github.com/labuladong/fucking-algorithm" target="view_window"><img alt="GitHub" src="https://img.shields.io/github/stars/labuladong/fucking-algorithm?label=Stars&style=flat-square&logo=GitHub"></a>
 <a href="https://www.zhihu.com/people/labuladong"><img src="https://img.shields.io/badge/%E7%9F%A5%E4%B9%8E-@labuladong-000000.svg?style=flat-square&logo=Zhihu"></a>
@@ -257,5 +255,69 @@ int[] dp(TreeNode root) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
+[Shantom](https://github.com/Shantom) 提供 198. House Robber I Python3 解法代码：
+
+```Python
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        # 当前，上一间，上上间
+        cur, pre1, pre2 = 0, 0, 0  
+
+        for num in nums:
+            # 当前 = max(上上间+（抢当前），上间（放弃当前）)
+            cur = max(pre2 + num, pre1)
+            pre2 = pre1
+            pre1 = cur
+
+        return cur
+```
+[Shantom](https://github.com/Shantom) 提供 213. House Robber II Python3 解法代码：
+
+```Python
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        # 只有一间时不成环
+        if len(nums) == 1:
+            return nums[0]
+
+        # 该函数同198题
+        def subRob(nums: List[int]) -> int:
+            # 当前，上一间，上上间
+            cur, pre1, pre2 = 0, 0, 0  
+            for num in nums:
+                # 当前 = max(上上间+（抢当前），上间（放弃当前）)
+                cur = max(pre2 + num, pre1)
+                pre2 = pre1
+                pre1 = cur
+            return cur
+        
+        # 不考虑第一间或者不考虑最后一间
+        return max(subRob(nums[:-1]), subRob(nums[1:]))
+```
+[Shantom](https://github.com/Shantom) 提供 337. House Robber III Python3 解法代码：
+
+```Python
+class Solution:
+    def rob(self, root: TreeNode) -> int:
+        # 返回值0项为不抢该节点，1项为抢该节点
+        def dp(root):
+            if not root:
+                return 0, 0
+
+            left = dp(root.left)
+            right = dp(root.right)
+            
+            # 抢当前，则两个下家不抢
+            do = root.val + left[0] + right[0]
+            # 不抢当前，则下家随意
+            do_not = max(left) + max(right)
+
+            return do_not, do
+        
+        return max(dp(root))
+```
+

动态规划系列/最优子结构.md

 # 动态规划答疑篇
 
-**学好算法全靠套路，认准 labuladong 就够了**。
+
 
 <p align='center'>
 <a href="https://github.com/labuladong/fucking-algorithm" target="view_window"><img alt="GitHub" src="https://img.shields.io/github/stars/labuladong/fucking-algorithm?label=Stars&style=flat-square&logo=GitHub"></a>
@@ -54,7 +54,7 @@ return result;
 
 当然，上面这个例子太简单了，不过请读者回顾一下，我们做动态规划问题，是不是一直在求各种最值，本质跟我们举的例子没啥区别，无非需要处理一下重叠子问题。
 
-前文不[同定义不同解法](../动态规划系列/动态规划之四键键盘.md) 和 [高楼扔鸡蛋进阶](../动态规划系列/高楼扔鸡蛋问题.md) 就展示了如何改造问题，不同的最优子结构，可能导致不同的解法和效率。
+前文不[同定义不同解法](https://labuladong.gitbook.io/algo) 和 [高楼扔鸡蛋进阶](https://labuladong.gitbook.io/algo) 就展示了如何改造问题，不同的最优子结构，可能导致不同的解法和效率。
 
 再举个常见但也十分简单的例子，求一棵二叉树的最大值，不难吧（简单起见，假设节点中的值都是非负数）：
 
@@ -154,5 +154,7 @@ for (int i = 1; i < m; i++)
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

动态规划系列/最长公共子序列.md

@@ -144,5 +144,32 @@ else:
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
+
+[Shawn](https://github.com/Shawn-Hx) 提供 Java 代码：
+
+```java
+public int longestCommonSubsequence(String text1, String text2) {
+	// 字符串转为char数组以加快访问速度
+	char[] str1 = text1.toCharArray();
+	char[] str2 = text2.toCharArray();
+
+	int m = str1.length, n = str2.length;
+	// 构建dp table，初始值默认为0
+	int[][] dp = new int[m + 1][n + 1];
+	// 状态转移
+	for (int i = 1; i <= m; i++)
+		for (int j = 1; j <= n; j++)
+			if (str1[i - 1] == str2[j - 1])
+				// 找到LCS中的字符
+				dp[i][j] = dp[i-1][j-1] + 1;
+			else
+				dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);
+	
+	return dp[m][n];
+}
+```
+

动态规划系列/编辑距离.md

@@ -288,9 +288,10 @@ class Node {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
 
+======其他语言代码======
 [ChenjieXu](https://github.com/ChenjieXu) 提供Python版本代码：  
 
 ```python3
@@ -317,4 +318,4 @@ def minDistance(word1, word2):
                                dp[i - 1][j - 1] + 1)
     # 储存着整个 word1 和 word2 的最小编辑距离
     return dp[m][n]
-````
+````
\ No newline at end of file

动态规划系列/贪心算法之区间调度问题.md

@@ -155,5 +155,7 @@ int findMinArrowShots(int[][] intvs) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

动态规划系列/高楼扔鸡蛋进阶.md

@@ -292,5 +292,7 @@ while (lo < hi) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

动态规划系列/高楼扔鸡蛋问题.md

 # 经典动态规划问题：高楼扔鸡蛋
 
-**学好算法全靠套路，认准 labuladong 就够了**。
+
 
 <p align='center'>
 <a href="https://github.com/labuladong/fucking-algorithm" target="view_window"><img alt="GitHub" src="https://img.shields.io/github/stars/labuladong/fucking-algorithm?label=Stars&style=flat-square&logo=GitHub"></a>
@@ -243,7 +243,7 @@ def superEggDrop(self, K: int, N: int) -> int:
     return dp(K, N)
 ```
 
-这里就不展开其他解法了，留在下一篇文章 [高楼扔鸡蛋进阶](../动态规划系列/高楼扔鸡蛋进阶.md)
+这里就不展开其他解法了，留在下一篇文章 [高楼扔鸡蛋进阶](https://labuladong.gitbook.io/algo)
 
 我觉得吧，我们这种解法就够了：找状态，做选择，足够清晰易懂，可流程化，可举一反三。掌握这套框架学有余力的话，再去考虑那些奇技淫巧也不迟。
 
@@ -258,5 +258,7 @@ def superEggDrop(self, K: int, N: int) -> int:
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

技术/linuxshell.md

@@ -154,5 +154,7 @@ $ sudo /home/fdl/bin/connect.sh
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

技术/linux进程.md

@@ -138,5 +138,7 @@ $ cmd1 | cmd2 | cmd3
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

技术/redis入侵.md

@@ -103,5 +103,7 @@ Redis 监听的默认端口是 6379，我们设置它接收网卡 127.0.0.1 的
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
-</p>
\ No newline at end of file
+<img src="../pictures/qrcode.jpg" width=200 >
+</p>
+
+======其他语言代码======
\ No newline at end of file

技术/session和cookie.md

@@ -152,5 +152,7 @@ https://github.com/astaxie/build-web-application-with-golang
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
-</p>
\ No newline at end of file
+<img src="../pictures/qrcode.jpg" width=200 >
+</p>
+
+======其他语言代码======
\ No newline at end of file

技术/在线练习平台.md

@@ -116,5 +116,7 @@ https://sqlzoo.net/
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
-</p>
\ No newline at end of file
+<img src="../pictures/qrcode.jpg" width=200 >
+</p>
+
+======其他语言代码======
\ No newline at end of file

技术/密码技术.md

@@ -199,7 +199,8 @@ HTTPS 协议中的 SSL/TLS 安全层会组合使用以上几种加密方式，**
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
 
+======其他语言代码======
 [test ad](https://labuladong.gitbook.io/algo)
\ No newline at end of file

数据结构系列/二叉堆详解实现优先级队列.md

@@ -236,5 +236,7 @@ public Key delMax() {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

数据结构系列/二叉搜索树操作集锦.md

@@ -307,5 +307,39 @@ void BST(TreeNode root, int target) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======  
+[dekunma](https://www.linkedin.com/in/dekun-ma-036a9b198/)提供第98题C++代码：  
+```C++
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    bool isValidBST(TreeNode* root) {
+        // 用helper method求解
+        return isValidBST(root, nullptr, nullptr);
+    }
+
+    bool isValidBST(TreeNode* root, TreeNode* min, TreeNode* max) {
+        // base case, root为nullptr
+        if (!root) return true;
+
+        // 不符合BST的条件
+        if (min && root->val <= min->val) return false;
+        if (max && root->val >= max->val) return false;
+
+        // 向左右子树分别递归求解
+        return isValidBST(root->left, min, root) 
+            && isValidBST(root->right, root, max);
+    }
+};
+```

数据结构系列/单调栈.md

@@ -178,5 +178,7 @@ vector<int> nextGreaterElements(vector<int>& nums) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
-</p>
\ No newline at end of file
+<img src="../pictures/qrcode.jpg" width=200 >
+</p>
+
+======其他语言代码======
\ No newline at end of file

数据结构系列/单调队列.md

@@ -207,5 +207,7 @@ vector<int> maxSlidingWindow(vector<int>& nums, int k) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

数据结构系列/实现计算器.md

 # 拆解复杂问题：实现计算器
 
-**学好算法全靠套路，认准 labuladong 就够了**。
+
 
 <p align='center'>
 <a href="https://github.com/labuladong/fucking-algorithm" target="view_window"><img alt="GitHub" src="https://img.shields.io/github/stars/labuladong/fucking-algorithm?label=Stars&style=flat-square&logo=GitHub"></a>
@@ -303,5 +303,7 @@ def calculate(s: str) -> int:
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

数据结构系列/设计Twitter.md

@@ -299,5 +299,7 @@ PS：本文前两张图片和 GIF 是我第一次尝试用平板的绘图软件
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

数据结构系列/递归反转链表的一部分.md

@@ -215,5 +215,7 @@ ListNode reverseBetween(ListNode head, int m, int n) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

数据结构系列/队列实现栈栈实现队列.md

@@ -227,5 +227,7 @@ public boolean empty() {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

算法思维系列/FloodFill算法详解及应用.md

@@ -236,5 +236,7 @@ int fill(int[][] image, int x, int y,
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

算法思维系列/UnionFind算法应用.md

@@ -247,5 +247,7 @@ boolean equationsPossible(String[] equations) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

算法思维系列/UnionFind算法详解.md

@@ -314,5 +314,7 @@ Union-Find 算法的复杂度可以这样分析：构造函数初始化数据结
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

算法思维系列/twoSum问题的核心思想.md

@@ -182,5 +182,7 @@ int[] twoSum(int[] nums, int target) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

算法思维系列/为什么推荐算法4.md

@@ -98,5 +98,7 @@
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

算法思维系列/二分查找详解.md

@@ -505,5 +505,7 @@ int right_bound(int[] nums, int target) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

算法思维系列/信封嵌套问题.md

@@ -132,5 +132,7 @@ public int lengthOfLIS(int[] nums) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

算法思维系列/几个反直觉的概率问题.md

@@ -138,5 +138,7 @@
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

算法思维系列/前缀和技巧.md

@@ -156,5 +156,7 @@ for (int i = 1; i < count.length; i++)
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

算法思维系列/区间交集问题.md

@@ -130,5 +130,7 @@ def intervalIntersection(A, B):
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

算法思维系列/区间调度问题之区间合并.md

@@ -88,5 +88,7 @@ def merge(intervals):
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

算法思维系列/双指针技巧.md

@@ -227,5 +227,28 @@ void reverse(int[] nums) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
+
+[ryandeng32](https://github.com/ryandeng32/) 提供 Python 代码
+```python
+class Solution:
+    def hasCycle(self, head: ListNode) -> bool:
+        # 检查链表头是否为None，是的话则不可能为环形
+        if head is None: 
+            return False 
+        # 快慢指针初始化
+        slow = fast = head 
+        # 若链表非环形则快指针终究会遇到None，然后退出循环
+        while fast.next and fast.next.next: 
+            # 更新快慢指针
+            slow = slow.next
+            fast = fast.next.next
+            # 快指针追上慢指针则链表为环形
+            if slow == fast: 
+                return True 
+        # 退出循环，则链表有结束，不可能为环形
+        return False 
+```

算法思维系列/回溯算法详解修订版.md

@@ -306,5 +306,7 @@ def backtrack(...):
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

算法思维系列/字符串乘法.md

@@ -98,5 +98,7 @@ string multiply(string num1, string num2) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
-</p>
\ No newline at end of file
+<img src="../pictures/qrcode.jpg" width=200 >
+</p>
+
+======其他语言代码======
\ No newline at end of file

算法思维系列/学习数据结构和算法的高效方法.md

@@ -306,5 +306,7 @@ N 叉树的遍历框架，找出来了把～你说，树这种结构重不重要
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

算法思维系列/常用的位操作.md

@@ -169,5 +169,7 @@ http://graphics.stanford.edu/~seander/bithacks.html#ReverseParallel
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

算法思维系列/洗牌算法.md

@@ -208,5 +208,7 @@ for (int feq : count)
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

算法思维系列/滑动窗口技巧.md

-# 滑动窗口技巧
+# 滑动窗口算法框架
+
+<p align='center'>
+<a href="https://github.com/labuladong/fucking-algorithm" target="view_window"><img alt="GitHub" src="https://img.shields.io/github/stars/labuladong/fucking-algorithm?label=Stars&style=flat-square&logo=GitHub"></a>
+<a href="https://www.zhihu.com/people/labuladong"><img src="https://img.shields.io/badge/%E7%9F%A5%E4%B9%8E-@labuladong-000000.svg?style=flat-square&logo=Zhihu"></a>
+<a href="https://i.loli.net/2020/10/10/MhRTyUKfXZOlQYN.jpg"><img src="https://img.shields.io/badge/公众号-@labuladong-000000.svg?style=flat-square&logo=WeChat"></a>
+<a href="https://space.bilibili.com/14089380"><img src="https://img.shields.io/badge/B站-@labuladong-000000.svg?style=flat-square&logo=Bilibili"></a>
+</p>
+
+![](../pictures/souyisou.png)
+
+**最新消息：关注公众号参与活动，有机会成为 [70k star 算法仓库](https://github.com/labuladong/fucking-algorithm) 的贡献者，机不可失时不再来**！
+
+相关推荐：
+* [东哥吃葡萄时竟然吃出一道算法题！](https://labuladong.gitbook.io/algo)
+* [如何寻找缺失的元素](https://labuladong.gitbook.io/algo)
+
+读完本文，你不仅学会了算法套路，还可以顺便去 LeetCode 上拿下如下题目：
+
+[76.最小覆盖子串](https://leetcode-cn.com/problems/minimum-window-substring)
+
+[567.字符串的排列](https://leetcode-cn.com/problems/permutation-in-string)
+
+[438.找到字符串中所有字母异位词](https://leetcode-cn.com/problems/find-all-anagrams-in-a-string)
+
+[3.无重复字符的最长子串](https://leetcode-cn.com/problems/longest-substring-without-repeating-characters)
+
+**-----------**
 
 本文详解「滑动窗口」这种高级双指针技巧的算法框架，带你秒杀几道高难度的子字符串匹配问题。
 
@@ -334,8 +361,14 @@ class Solution:
         return s[start:start+min_len] if min_len != float("Inf") else ""
 ```
 
-[上一篇：二分查找解题框架](https://labuladong.gitbook.io/algo)
+**＿＿＿＿＿＿＿＿＿＿＿＿＿**
+
+**刷算法，学套路，认准 labuladong，公众号和 [在线电子书](https://labuladong.gitbook.io/algo) 持续更新最新文章**。
+
+**本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
-[下一篇：双指针技巧解题框架](https://labuladong.gitbook.io/algo)
+<p align='center'>
+<img src="../pictures/qrcode.jpg" width=200 >
+</p>
 
-[目录](https://labuladong.gitbook.io/algo#目录)
+======其他语言代码======
\ No newline at end of file

算法思维系列/烧饼排序.md

@@ -146,5 +146,7 @@ void reverse(int[] arr, int i, int j) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

算法思维系列/算法学习之路.md

@@ -101,5 +101,7 @@ PS：**如果有的英文题目实在看不懂，有个小技巧**，你在题
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

算法思维系列/递归详解.md

@@ -272,5 +272,7 @@ https://leetcode.com/tag/divide-and-conquer/
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

高频面试系列/LRU算法.md

@@ -343,5 +343,37 @@ class LRUCache {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
+```python3
+"""
+所谓LRU缓存，根本的难点在于记录最久被使用的键值对，这就设计到排序的问题，
+在python中，天生具备排序功能的字典就是OrderDict。
+注意到，记录最久未被使用的键值对的充要条件是将每一次put/get的键值对都定义为
+最近访问，那么最久未被使用的键值对自然就会排到最后。
+如果你深入python OrderDict的底层实现，就会知道它的本质是个双向链表+字典。
+它内置支持了
+1. move_to_end来重排链表顺序，它可以让我们将最近访问的键值对放到最后面
+2. popitem来弹出键值对，它既可以弹出最近的，也可以弹出最远的，弹出最远的就是我们要的操作。
+"""
+from collections import OrderedDict
+class LRUCache:
+    def __init__(self, capacity: int):
+        self.capacity = capacity  # cache的容量
+        self.visited = OrderedDict()  # python内置的OrderDict具备排序的功能
+    def get(self, key: int) -> int:
+        if key not in self.visited:
+             return -1
+        self.visited.move_to_end(key)  # 最近访问的放到链表最后，维护好顺序
+        return self.visited[key]
+    def put(self, key: int, value: int) -> None:
+        if key not in self.visited and len(self.visited) == self.capacity:
+              # last=False时，按照FIFO顺序弹出键值对
+              # 因为我们将最近访问的放到最后，所以最远访问的就是最前的，也就是最first的，故要用FIFO顺序
+            self.visited.popitem(last=False)
+        self.visited[key]=value
+        self.visited.move_to_end(key)    # 最近访问的放到链表最后，维护好顺序
+
+```

高频面试系列/koko偷香蕉.md

@@ -166,5 +166,7 @@ for (int i = 0; i < n; i++)
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

高频面试系列/k个一组反转链表.md

@@ -153,5 +153,7 @@ ListNode reverseKGroup(ListNode head, int k) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

高频面试系列/一行代码解决的智力题.md

@@ -146,5 +146,7 @@ int bulbSwitch(int n) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

高频面试系列/二分查找判定子序列.md

@@ -165,5 +165,7 @@ boolean isSubsequence(String s, String t) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

高频面试系列/判断回文链表.md

@@ -234,5 +234,7 @@ p.next = reverse(q);
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

高频面试系列/合法括号判定.md

@@ -109,5 +109,31 @@ char leftOf(char c) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
+
+```java
+//基本思想：每次遇到左括号时都将相对应的右括号'）'，']'或'}'推入堆栈
+//如果在字符串中出现右括号，则需要检查堆栈是否为空，以及顶部元素是否与该右括号相同。如果不是，则该字符串无效。
+//最后，我们还需要检查堆栈是否为空
+public boolean isValid(String s) {
+  Deque<Character> stack = new ArrayDeque<>();
+  for(char c : s.toCharArray()){
+    //是左括号就将相对应的右括号入栈
+    if(c=='(') {
+      stack.offerLast(')');
+    }else if(c=='{'){
+      stack.offerLast('}');
+    }else if(c=='['){
+      stack.offerLast(']');   
+    }else if(stack.isEmpty() || stack.pollLast()!=c){//出现右括号，检查堆栈是否为空，以及顶部元素是否与该右括号相同
+      return false;
+    }
+  }
+  return stack.isEmpty();
+}
+
+```
+

高频面试系列/如何去除有序数组的重复元素.md

@@ -108,8 +108,14 @@ def deleteDuplicates(self, head: ListNode) -> ListNode:
     return head
 ```
 
-[上一篇：如何高效解决接雨水问题](https://labuladong.gitbook.io/algo)
+**＿＿＿＿＿＿＿＿＿＿＿＿＿**
 
-[下一篇：如何寻找最长回文子串](https://labuladong.gitbook.io/algo)
+**刷算法，学套路，认准 labuladong，公众号和 [在线电子书](https://labuladong.gitbook.io/algo) 持续更新最新文章**。
 
-[目录](https://labuladong.gitbook.io/algo#目录)
+**本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
+
+<p align='center'>
+<img src="../pictures/qrcode.jpg" width=200 >
+</p>
+
+======其他语言代码======
\ No newline at end of file

高频面试系列/子集排列组合.md

 # 回溯算法团灭子集、排列、组合问题
 
-**学好算法全靠套路，认准 labuladong 就够了**。
+
 
 <p align='center'>
 <a href="https://github.com/labuladong/fucking-algorithm" target="view_window"><img alt="GitHub" src="https://img.shields.io/github/stars/labuladong/fucking-algorithm?label=Stars&style=flat-square&logo=GitHub"></a>
@@ -281,5 +281,7 @@ void backtrack(int[] nums, LinkedList<Integer> track) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

高频面试系列/座位调度.md

@@ -230,5 +230,7 @@ private int distance(int[] intv) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

高频面试系列/打印素数.md

@@ -175,5 +175,44 @@ int countPrimes(int n) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
+
+C++解法：
+采用的算法是埃拉托斯特尼筛法
+埃拉托斯特尼筛法的具体内容就是：**要得到自然数n以内的全部素数，必须把不大于根号n的所有素数的倍数剔除，剩下的就是素数。**
+同时考虑到大于2的偶数都不是素数，所以可以进一步优化成：**要得到自然数n以内的全部素数，必须把不大于根号n的所有素数的奇数倍剔除，剩下的奇数就是素数。**
+此算法其实就是上面的Java解法所采用的。
+
+这里提供C++的代码：
+```C++
+class Solution {
+public:
+    int countPrimes(int n) {
+    int res = 0;
+    bool prime[n+1];
+    for(int i = 0; i < n; ++i)
+        prime[i] = true;
+
+    for(int i = 2; i <= sqrt(n); ++i)   //计数过程 
+    {                                   //外循环优化，因为判断一个数是否为质数只需要整除到sqrt(n)，反推亦然
+        if(prime[i])
+        {
+            for(int j = i * i; j < n; j += i)   //内循环优化，i*i之前的比如i*2，i*3等，在之前的循环中已经验证了
+            {
+                prime[j] = false;
+            }
+        }      
+    }
+    for (int i = 2; i < n; ++i)
+        if (prime[i])  res++;     //最后遍历统计一遍，存入res
+
+    return res;    
+    }
+};
+```
+
+
+

高频面试系列/接雨水.md

@@ -208,5 +208,7 @@ if (l_max < r_max) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

高频面试系列/最长回文子串.md

 # 如何寻找最长回文子串
 
-**学好算法全靠套路，认准 labuladong 就够了**。
+
 
 <p align='center'>
 <a href="https://github.com/labuladong/fucking-algorithm" target="view_window"><img alt="GitHub" src="https://img.shields.io/github/stars/labuladong/fucking-algorithm?label=Stars&style=flat-square&logo=GitHub"></a>
@@ -128,5 +128,7 @@ string longestPalindrome(string s) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

高频面试系列/水塘抽样.md

@@ -145,5 +145,7 @@ $$ -->
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

高频面试系列/消失的元素.md

@@ -129,5 +129,7 @@ public int missingNumber(int[] nums) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file

高频面试系列/缺失和重复的元素.md

@@ -136,5 +136,7 @@ vector<int> findErrorNums(vector<int>& nums) {
 **本小抄即将出版，微信扫码关注公众号，后台回复「小抄」限时免费获取，回复「进群」可进刷题群一起刷题，带你搞定 LeetCode**。
 
 <p align='center'>
-<img src="../pictures/table_qr2.jpg" width=500 >
+<img src="../pictures/qrcode.jpg" width=200 >
 </p>
+
+======其他语言代码======
\ No newline at end of file