+
-
+
+
+好消息，《labuladong 的算法小抄》纸质书出版啦！关注公众号查看详情👆
+
-======其他语言代码======
\ No newline at end of file
+======其他语言代码======
+[MoguCloud](https://github.com/MoguCloud) 提供 实现 strStr() 的 Python 完整代码：
+```py
+class Solution:
+ def strStr(self, haystack: str, needle: str) -> int:
+ # 边界条件判断
+ if not needle:
+ return 0
+ pat = needle
+ txt = haystack
+
+ M = len(pat)
+ # dp[状态][字符] = 下个状态
+ dp = [[0 for _ in range(256)] for _ in pat]
+ # base case
+ dp[0][ord(pat[0])] = 1
+ # 影子状态 X 初始化为 0
+ X = 0
+ for j in range(1, M):
+ for c in range(256):
+ dp[j][c] = dp[X][c]
+ dp[j][ord(pat[j])] = j + 1
+ # 更新影子状态
+ X = dp[X][ord(pat[j])]
+
+ N = len(txt)
+ # pat 初始状态为 0
+ j = 0
+ for i in range(N):
+ # 计算 pat 的下一个状态
+ j = dp[j][ord(txt[i])]
+ # 到达终止态，返回结果
+ if j == M:
+ return i - M + 1
+ # 没到达终止态，匹配失败
+ return -1
+```
diff --git "a/\345\212\250\346\200\201\350\247\204\345\210\222\347\263\273\345\210\227/\345\212\250\346\200\201\350\247\204\345\210\222\344\271\213\345\215\232\345\274\210\351\227\256\351\242\230.md" "b/\345\212\250\346\200\201\350\247\204\345\210\222\347\263\273\345\210\227/\345\212\250\346\200\201\350\247\204\345\210\222\344\271\213\345\215\232\345\274\210\351\227\256\351\242\230.md"
index 9f52fa49297363b9cb579eef2bf1ed9847b8fcd1..f9082d8def88e8632697704931409c8ab0f0659a 100644
--- "a/\345\212\250\346\200\201\350\247\204\345\210\222\347\263\273\345\210\227/\345\212\250\346\200\201\350\247\204\345\210\222\344\271\213\345\215\232\345\274\210\351\227\256\351\242\230.md"
+++ "b/\345\212\250\346\200\201\350\247\204\345\210\222\347\263\273\345\210\227/\345\212\250\346\200\201\350\247\204\345\210\222\344\271\213\345\215\232\345\274\210\351\227\256\351\242\230.md"
@@ -22,7 +22,7 @@
上一篇文章 [几道智力题](https://labuladong.gitbook.io/algo) 中讨论到一个有趣的「石头游戏」，通过题目的限制条件，这个游戏是先手必胜的。但是智力题终究是智力题，真正的算法问题肯定不会是投机取巧能搞定的。所以，本文就借石头游戏来讲讲「假设两个人都足够聪明，最后谁会获胜」这一类问题该如何用动态规划算法解决。
-博弈类问题的套路都差不多，下文举例讲解，其核心思路是在二维 dp 的基础上使用元组分别存储两个人的博弈结果。掌握了这个技巧以后，别人再问你什么俩海盗分宝石，俩人拿硬币的问题，你就告诉别人：我懒得想，直接给你写个算法算一下得了。
+博弈类问题的套路都差不多，下文参考 [这个 YouTube 视频](https://www.youtube.com/watch?v=WxpIHvsu1RI) 的思路讲解，其核心思路是在二维 dp 的基础上使用元组分别存储两个人的博弈结果。掌握了这个技巧以后，别人再问你什么俩海盗分宝石，俩人拿硬币的问题，你就告诉别人：我懒得想，直接给你写个算法算一下得了。
我们「石头游戏」改的更具有一般性：
@@ -215,4 +215,116 @@ int stoneGame(int[] piles) {
-======其他语言代码======
\ No newline at end of file
+======其他语言代码======
+
+
+
+
+
+* 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
+
+
+```
+
+* C++ 版本
+
+由 [TCeason](https://github.com/TCeason) 提供
+
+这里采用 hash map 来解决问题
+
+```cpp
+class Solution {
+public:
+ unordered_map
-======其他语言代码======
\ No newline at end of file
+======其他语言代码======
+
+```python 动态规划
+class Solution:
+ def lengthOfLIS(self, nums: List[int]) -> int:
+ n = len(nums)
+ f = [1] * (n)
+
+ for i in range(n):
+ for j in range(i):
+ if nums[j] < nums[i]:
+ f[i] = max(f[i], f[j] + 1)
+
+ res = 0
+ for i in range(n):
+ res = max(res, f[i])
+ return res
+```
+
+```python 二分查找
+class Solution:
+ def lengthOfLIS(self, nums: List[int]) -> int:
+ stack = []
+
+ def find_index(num):
+ l, r = 0, len(stack)
+ while l < r:
+ mid = l + r >> 1
+ if stack[mid] >= num:
+ r = mid
+ else:
+ l = mid + 1
+
+ return r
+
+
+ for num in nums:
+ if not stack or num > stack[-1]:
+ stack.append(num)
+ else:
+ position = find_index(num)
+ stack[position] = num
+
+ return len(stack)
+```
+
+
+[Kian](https://github.com/KianKw/) 提供 C++ 代码
+
+```c++
+class Solution {
+public:
+ int lengthOfLIS(vector
-======其他语言代码======
\ No newline at end of file
+======其他语言代码======
+
+[DapangLiu](https://github.com/DapangLiu) 提供 509. 斐波那契数 Python3 解法代码：
+
+递归写法
+
+```python
+class Solution:
+ def fib(self, N: int) -> int:
+ if N <= 1:
+ return N
+ return self.fib(N-1) + self.fib(N-2)
+```
+
+动态规划写法
+
+```python
+class Solution:
+ def fib(self, N: int) -> int:
+ if N == 0:
+ return 0
+ # init
+ result = [0 for i in range(N+1)]
+ result[1] = 1
+
+ # status transition
+ for j in range(2, N+1):
+ result[j] = result[j-1] + result[j-2]
+ return result[-1]
+```
+
+动态规划写法 (状态压缩)
+
+```python
+class Solution:
+ def fib(self, n: int) -> int:
+ # current status only depends on two previous status
+ dp_0, dp_1 = 0, 1
+ for _ in range(n):
+ dp_0, dp_1 = dp_1, dp_0 + dp_1
+ return dp_0
+```
\ No newline at end of file
diff --git "a/\345\212\250\346\200\201\350\247\204\345\210\222\347\263\273\345\210\227/\345\233\242\347\201\255\350\202\241\347\245\250\351\227\256\351\242\230.md" "b/\345\212\250\346\200\201\350\247\204\345\210\222\347\263\273\345\210\227/\345\233\242\347\201\255\350\202\241\347\245\250\351\227\256\351\242\230.md"
index be2b4638141b1426b851511d00098aefb8d2f7da..61f64a36a5587908c7036445dd36f02ca72fe865 100644
--- "a/\345\212\250\346\200\201\350\247\204\345\210\222\347\263\273\345\210\227/\345\233\242\347\201\255\350\202\241\347\245\250\351\227\256\351\242\230.md"
+++ "b/\345\212\250\346\200\201\350\247\204\345\210\222\347\263\273\345\210\227/\345\233\242\347\201\255\350\202\241\347\245\250\351\227\256\351\242\230.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，看一眼就明白了。
先随便抽出一道题，看看别人的解法：
diff --git "a/\345\212\250\346\200\201\350\247\204\345\210\222\347\263\273\345\210\227/\346\212\242\346\210\277\345\255\220.md" "b/\345\212\250\346\200\201\350\247\204\345\210\222\347\263\273\345\210\227/\346\212\242\346\210\277\345\255\220.md"
index 35a0fb6a09d7dd6973829e92677169c2357a0538..081c583ac2748e9bf869248bbdb6095736c8a8f6 100644
--- "a/\345\212\250\346\200\201\350\247\204\345\210\222\347\263\273\345\210\227/\346\212\242\346\210\277\345\255\220.md"
+++ "b/\345\212\250\346\200\201\350\247\204\345\210\222\347\263\273\345\210\227/\346\212\242\346\210\277\345\255\220.md"
@@ -258,4 +258,66 @@ int[] dp(TreeNode root) {
-======其他语言代码======
\ No newline at end of file
+======其他语言代码======
+[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))
+```
+
diff --git "a/\345\212\250\346\200\201\350\247\204\345\210\222\347\263\273\345\210\227/\346\234\200\344\274\230\345\255\220\347\273\223\346\236\204.md" "b/\345\212\250\346\200\201\350\247\204\345\210\222\347\263\273\345\210\227/\346\234\200\344\274\230\345\255\220\347\273\223\346\236\204.md"
index 2dc21f2275e98eb47dfe5b42951dada0dac1bff0..caf68cfe986d3841317cef8c999d856f8b03d02b 100644
--- "a/\345\212\250\346\200\201\350\247\204\345\210\222\347\263\273\345\210\227/\346\234\200\344\274\230\345\255\220\347\273\223\346\236\204.md"
+++ "b/\345\212\250\346\200\201\350\247\204\345\210\222\347\263\273\345\210\227/\346\234\200\344\274\230\345\255\220\347\273\223\346\236\204.md"
@@ -54,7 +54,7 @@ return result;
当然，上面这个例子太简单了，不过请读者回顾一下，我们做动态规划问题，是不是一直在求各种最值，本质跟我们举的例子没啥区别，无非需要处理一下重叠子问题。
-前文不[同定义不同解法](../动态规划系列/动态规划之四键键盘.md) 和 [高楼扔鸡蛋进阶](../动态规划系列/高楼扔鸡蛋问题.md) 就展示了如何改造问题，不同的最优子结构，可能导致不同的解法和效率。
+前文不[同定义不同解法](https://labuladong.gitbook.io/algo) 和 [高楼扔鸡蛋进阶](https://labuladong.gitbook.io/algo) 就展示了如何改造问题，不同的最优子结构，可能导致不同的解法和效率。
再举个常见但也十分简单的例子，求一棵二叉树的最大值，不难吧（简单起见，假设节点中的值都是非负数）：
diff --git "a/\345\212\250\346\200\201\350\247\204\345\210\222\347\263\273\345\210\227/\346\234\200\351\225\277\345\205\254\345\205\261\345\255\220\345\272\217\345\210\227.md" "b/\345\212\250\346\200\201\350\247\204\345\210\222\347\263\273\345\210\227/\346\234\200\351\225\277\345\205\254\345\205\261\345\255\220\345\272\217\345\210\227.md"
index bee894738bed410f27b9ab8a9d5a81f3fab9e93f..bff1721aa8a88a5f9794c960a84ab1cdd5d44f55 100644
--- "a/\345\212\250\346\200\201\350\247\204\345\210\222\347\263\273\345\210\227/\346\234\200\351\225\277\345\205\254\345\205\261\345\255\220\345\272\217\345\210\227.md"
+++ "b/\345\212\250\346\200\201\350\247\204\345\210\222\347\263\273\345\210\227/\346\234\200\351\225\277\345\205\254\345\205\261\345\255\220\345\272\217\345\210\227.md"
@@ -1,4 +1,4 @@
-# 最长公共子序列
+# 最长公共子序列
@@ -147,4 +147,64 @@ else:
@@ -158,4 +158,43 @@ int findMinArrowShots(int[][] intvs) {
@@ -310,4 +310,142 @@ void BST(TreeNode root, int target) {
-======其他语言代码======
\ No newline at end of file
+======其他语言代码======
+### java
+
+```java
+// 739. Daily Temperatures
+class Solution {
+ public int[] dailyTemperatures(int[] T) {
+ Stack
-======其他语言代码======
\ No newline at end of file
+======其他语言代码======
+
+### python3
+
+由[SCUHZS](ttps://github.com/brucecat)提供
+
+
+```python
+from collections import deque
+
+class MonotonicQueue(object):
+ def __init__(self):
+ # 双端队列
+ self.data = deque()
+
+ def push(self, n):
+ # 实现单调队列的push方法
+ while self.data and self.data[-1] < n:
+ self.data.pop()
+ self.data.append(n)
+
+ def max(self):
+ # 取得单调队列中的最大值
+ return self.data[0]
+
+ def pop(self, n):
+ # 实现单调队列的pop方法
+ if self.data and self.data[0] == n:
+ self.data.popleft()
+
+
+class Solution:
+ def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
+ # 单调队列实现的窗口
+ window = MonotonicQueue()
+
+ # 结果
+ res = []
+
+ for i in range(0, len(nums)):
+
+ if i < k-1:
+ # 先填满窗口前k-1
+ window.push(nums[i])
+ else:
+ # 窗口向前滑动
+ window.push(nums[i])
+ res.append(window.max())
+ window.pop(nums[i-k+1])
+ return res
+
+```
+
+### java
+
+```java
+class Solution {
+ public int[] maxSlidingWindow(int[] nums, int k) {
+ int len = nums.length;
+ // 判断数组或者窗口长度为0的情况
+ if (len * k == 0) {
+ return new int[0];
+ }
+
+ /*
+ 采用两端扫描的方法
+ 将数组分成大小为 k 的若干个窗口, 对每个窗口分别从左往右和从右往左扫描, 记录扫描的最大值
+ left[] 记录从左往右扫描的最大值
+ right[] 记录从右往左扫描的最大值
+ */
+ int[] left = new int[len];
+ int[] right = new int[len];
+
+ for (int i = 0; i < len; i = i + k) {
+ // 每个窗口中的第一个值
+ left[i] = nums[i];
+ // 窗口的最后边界
+ int index = i + k - 1 >= len ? len - 1 : i + k - 1;
+ // 每个窗口的最后一个值
+ right[index] = nums[index];
+ // 对该窗口从左往右扫描
+ for (int j = i + 1; j <= index; j++) {
+ left[j] = Math.max(left[j - 1], nums[j]);
+ }
+ // 对该窗口从右往左扫描
+ for (int j = index - 1; j >= i; j--) {
+ right[j] = Math.max(right[j + 1], nums[j]);
+ }
+ }
+
+ int[] arr = new int[len - k + 1];
+
+ // 对于第 i 个位置, 它一定是该窗口从右往左扫描数组中的最后一个值, 相对的 i + k - 1 是该窗口从左向右扫描数组中的最后一个位置
+ // 对两者取最大值即可
+ for (int i = 0; i < len - k + 1; i++) {
+ arr[i] = Math.max(right[i], left[i + k - 1]);
+ }
+
+ return arr;
+ }
+}
+```
diff --git "a/\346\225\260\346\215\256\347\273\223\346\236\204\347\263\273\345\210\227/\350\256\276\350\256\241Twitter.md" "b/\346\225\260\346\215\256\347\273\223\346\236\204\347\263\273\345\210\227/\350\256\276\350\256\241Twitter.md"
index 399fbbbd2820c05fa4d4dcac7db32e458cf9d992..5f6c5f53c1da6e6bc30ac32b521ce0544d45c4f6 100644
--- "a/\346\225\260\346\215\256\347\273\223\346\236\204\347\263\273\345\210\227/\350\256\276\350\256\241Twitter.md"
+++ "b/\346\225\260\346\215\256\347\273\223\346\236\204\347\263\273\345\210\227/\350\256\276\350\256\241Twitter.md"
@@ -302,4 +302,121 @@ PS：本文前两张图片和 GIF 是我第一次尝试用平板的绘图软件
-======其他语言代码======
\ No newline at end of file
+======其他语言代码======
+
+[happy-yuxuan](https://github.com/happy-yuxuan) 提供 C++ 代码：
+
+```c++
+static int timestamp = 0;
+class Tweet {
+private:
+ int id;
+ int time;
+public:
+ Tweet *next;
+ // id为推文内容，time为发文时间
+ Tweet(int id, int time) {
+ this->id = id;
+ this->time = time;
+ next = nullptr;
+ }
+ int getId() const {
+ return this->id;
+ }
+ int getTime() const {
+ return this->time;
+ }
+};
+class User {
+private:
+ int id;
+public:
+ Tweet *head; // 发布的Twitter，用链表表示
+ unordered_set
-======其他语言代码======
\ No newline at end of file
+======其他语言代码======
+
+[DiamondI](https://github.com/DiamondI) 提供python3版本代码：
+
+思路：递归。时间复杂度为O(n)，由于递归调用需要借助栈的空间，因此空间复杂度亦为O(n)。
+
+```python3
+# Definition for singly-linked list.
+# class ListNode:
+# def __init__(self, val=0, next=None):
+# self.val = val
+# self.next = next
+class Solution:
+ def __init__(self):
+ self.__successor = None
+
+ def __reverseN(self, head: ListNode, n: int) -> ListNode:
+ if n == 1:
+ # 记录第 n + 1 个节点
+ self.__successor = head.next;
+ return head;
+ # 以 head.next 为起点，需要反转前 n - 1 个节点
+ last = self.__reverseN(head.next, n - 1);
+
+ head.next.next = head;
+ # 让反转之后的 head 节点和后面的节点连起来
+ head.next = self.__successor;
+ return last;
+
+ def reverseBetween(self, head: ListNode, m: int, n: int) -> ListNode:
+ # base case
+ if m == 1:
+ return self.__reverseN(head, n);
+ # 前进到反转的起点触发 base case
+ head.next = self.reverseBetween(head.next, m - 1, n - 1);
+ return head;
+```
diff --git "a/\347\256\227\346\263\225\346\200\235\347\273\264\347\263\273\345\210\227/\344\272\214\345\210\206\346\237\245\346\211\276\350\257\246\350\247\243.md" "b/\347\256\227\346\263\225\346\200\235\347\273\264\347\263\273\345\210\227/\344\272\214\345\210\206\346\237\245\346\211\276\350\257\246\350\247\243.md"
index 502962f74815072b701439c867766c354c6fcccf..a413541bfba6a4a88cb23d829441670a8d7a7fdb 100644
--- "a/\347\256\227\346\263\225\346\200\235\347\273\264\347\263\273\345\210\227/\344\272\214\345\210\206\346\237\245\346\211\276\350\257\246\350\247\243.md"
+++ "b/\347\256\227\346\263\225\346\200\235\347\273\264\347\263\273\345\210\227/\344\272\214\345\210\206\346\237\245\346\211\276\350\257\246\350\247\243.md"
@@ -65,7 +65,7 @@ int binarySearch(int[] nums, int target) {
### 一、寻找一个数（基本的二分搜索）
-这个场景是最简单的，肯能也是大家最熟悉的，即搜索一个数，如果存在，返回其索引，否则返回 -1。
+这个场景是最简单的，可能也是大家最熟悉的，即搜索一个数，如果存在，返回其索引，否则返回 -1。
```java
int binarySearch(int[] nums, int target) {
@@ -104,7 +104,7 @@ int binarySearch(int[] nums, int target) {
`while(left <= right)` 的终止条件是 `left == right + 1`，写成区间的形式就是 `[right + 1, right]`，或者带个具体的数字进去 `[3, 2]`，可见**这时候区间为空**，因为没有数字既大于等于 3 又小于等于 2 的吧。所以这时候 while 循环终止是正确的，直接返回 -1 即可。
-`while(left < right)` 的终止条件是 `left == right`，写成区间的形式就是 `[left, right]`，或者带个具体的数字进去 `[2, 2]`，**这时候区间非空**，还有一个数 2，但此时 while 循环终止了。也就是说这区间 `[2, 2]` 被漏掉了，索引 2 没有被搜索，如果这时候直接返回 -1 就是错误的。
+`while(left < right)` 的终止条件是 `left == right`，写成区间的形式就是 `[right, right]`，或者带个具体的数字进去 `[2, 2]`，**这时候区间非空**，还有一个数 2，但此时 while 循环终止了。也就是说这区间 `[2, 2]` 被漏掉了，索引 2 没有被搜索，如果这时候直接返回 -1 就是错误的。
当然，如果你非要用 `while(left < right)` 也可以，我们已经知道了出错的原因，就打个补丁好了：
diff --git "a/\347\256\227\346\263\225\346\200\235\347\273\264\347\263\273\345\210\227/\345\217\214\346\214\207\351\222\210\346\212\200\345\267\247.md" "b/\347\256\227\346\263\225\346\200\235\347\273\264\347\263\273\345\210\227/\345\217\214\346\214\207\351\222\210\346\212\200\345\267\247.md"
index cf5227d1846b7acd5da9f88db12afa94f570da1d..ff2aebea5758f48b5a333a5cf3473433bff7c565 100644
--- "a/\347\256\227\346\263\225\346\200\235\347\273\264\347\263\273\345\210\227/\345\217\214\346\214\207\351\222\210\346\212\200\345\267\247.md"
+++ "b/\347\256\227\346\263\225\346\200\235\347\273\264\347\263\273\345\210\227/\345\217\214\346\214\207\351\222\210\346\212\200\345\267\247.md"
@@ -20,7 +20,7 @@
[141.环形链表II](https://leetcode-cn.com/problems/linked-list-cycle-ii)
-[167.两数之和 II - 输入有序数组](https://leetcode-cn.com/problems/two-sum)
+[167.两数之和 II - 输入有序数组](https://leetcode-cn.com/problems/two-sum-ii-input-array-is-sorted)
**-----------**
@@ -80,6 +80,11 @@ ListNode detectCycle(ListNode head) {
if (fast == slow) break;
}
// 上面的代码类似 hasCycle 函数
+ if (fast == null || fast.next == null) {
+ // fast 遇到空指针说明没有环
+ return null;
+ }
+
slow = head;
while (slow != fast) {
fast = fast.next;
@@ -230,4 +235,25 @@ void reverse(int[] nums) {
-======其他语言代码======
\ No newline at end of file
+======其他语言代码======
+
+[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
+```
diff --git "a/\347\256\227\346\263\225\346\200\235\347\273\264\347\263\273\345\210\227/\345\255\227\347\254\246\344\270\262\344\271\230\346\263\225.md" "b/\347\256\227\346\263\225\346\200\235\347\273\264\347\263\273\345\210\227/\345\255\227\347\254\246\344\270\262\344\271\230\346\263\225.md"
index 02737442826e16336e4497a5b2d76ad77aa9ccef..6c7f67daeb720399dfe2b1e5caef2c0ba1d74544 100644
--- "a/\347\256\227\346\263\225\346\200\235\347\273\264\347\263\273\345\210\227/\345\255\227\347\254\246\344\270\262\344\271\230\346\263\225.md"
+++ "b/\347\256\227\346\263\225\346\200\235\347\273\264\347\263\273\345\210\227/\345\255\227\347\254\246\344\270\262\344\271\230\346\263\225.md"
@@ -101,4 +101,47 @@ string multiply(string num1, string num2) {
-======其他语言代码======
\ No newline at end of file
+======其他语言代码======
+
+[Zane Wang](https://github.com/zanecat) 提供 Java 解法代码：
+```java
+public String multiply(String num1, String num2) {
+ // 初始化字符数组
+ char[] s1 = num1.toCharArray();
+ char[] s2 = num2.toCharArray();
+
+ // 结果长度最多为两字符串长度之和
+ int[] res = new int[s1.length + s2.length];
+
+ // 从个位开始遍历，把两数字中每一位相乘
+ for (int i = s1.length - 1; i >= 0; i--) {
+ for (int j = s2.length - 1; j >= 0; j--) {
+ // 计算乘积，并把乘积放在 res 对应的位置， 暂时不考虑进位
+ res[i + j + 1] += (s1[i] - '0') * (s2[j] - '0');
+ }
+ }
+
+ // 从个位再次遍历，如果上一次遍历中两数乘积为两位数，进位并叠加到前面一位
+ int carry = 0;
+ for (int i = res.length - 1; i >= 0; i--) {
+ int sum = res[i] + carry;
+ res[i] = sum % 10;
+ carry = sum / 10;
+ }
+
+ //遍历res数组，构造最终答案字符串
+ StringBuilder ans = new StringBuilder();
+ int i = 0;
+
+ // 首先找到不为0的第一位
+ while (i < res.length - 1 && res[i] == 0) {
+ i++;
+ }
+
+ // 将后面的数字附加到ans后面
+ while (i < res.length) {
+ ans.append(res[i++]);
+ }
+ return ans.toString();
+}
+```
\ No newline at end of file
diff --git "a/\347\256\227\346\263\225\346\200\235\347\273\264\347\263\273\345\210\227/\346\273\221\345\212\250\347\252\227\345\217\243\346\212\200\345\267\247.md" "b/\347\256\227\346\263\225\346\200\235\347\273\264\347\263\273\345\210\227/\346\273\221\345\212\250\347\252\227\345\217\243\346\212\200\345\267\247.md"
index e65a1041f5d0b65707fc2c4389a9067fee5fe039..e213979693c724bd2a58a93c31f2a47cad78fd2d 100644
--- "a/\347\256\227\346\263\225\346\200\235\347\273\264\347\263\273\345\210\227/\346\273\221\345\212\250\347\252\227\345\217\243\346\212\200\345\267\247.md"
+++ "b/\347\256\227\346\263\225\346\200\235\347\273\264\347\263\273\345\210\227/\346\273\221\345\212\250\347\252\227\345\217\243\346\212\200\345\267\247.md"
@@ -12,8 +12,8 @@
**最新消息：关注公众号参与活动，有机会成为 [70k star 算法仓库](https://github.com/labuladong/fucking-algorithm) 的贡献者，机不可失时不再来**！
相关推荐：
-* [东哥吃葡萄时竟然吃出一道算法题！](../高频面试系列/吃葡萄.md)
-* [如何寻找缺失的元素](../高频面试系列/消失的元素.md)
+* [东哥吃葡萄时竟然吃出一道算法题！](https://labuladong.gitbook.io/algo)
+* [如何寻找缺失的元素](https://labuladong.gitbook.io/algo)
读完本文，你不仅学会了算法套路，还可以顺便去 LeetCode 上拿下如下题目：
@@ -371,4 +371,31 @@ class Solution:
-======其他语言代码======
\ No newline at end of file
+======其他语言代码======
+
+
+
+第3题 Python3 代码（提供: [FaDrYL](https://github.com/FaDrYL) ）：
+```Python3
+def lengthOfLongestSubstring(self, s: str) -> int:
+ # 子字符串
+ sub = ""
+ largest = 0
+
+ # 循环字符串，将当前字符加入子字符串，并检查长度
+ for i in range(len(s)):
+ if s[i] not in sub:
+ # 当前字符不存在于子字符串中，加入当前字符
+ sub += s[i]
+ else:
+ # 如果当前子字符串的长度超过了之前的记录
+ if len(sub) > largest:
+ largest = len(sub)
+ # 将子字符串从当前字符处+1切片至最后，并加入当前字符
+ sub = sub[sub.find(s[i])+1:] + s[i]
+
+ # 如果最后的子字符串长度超过了之前的记录
+ if len(sub) > largest:
+ return len(sub)
+ return largest
+```
diff --git "a/\347\256\227\346\263\225\346\200\235\347\273\264\347\263\273\345\210\227/\347\203\247\351\245\274\346\216\222\345\272\217.md" "b/\347\256\227\346\263\225\346\200\235\347\273\264\347\263\273\345\210\227/\347\203\247\351\245\274\346\216\222\345\272\217.md"
index 513cbdca8c165141fc2532c5b9b07dc8857b55ca..cd163bf415909f389a0e12cb831603537daf2ad2 100644
--- "a/\347\256\227\346\263\225\346\200\235\347\273\264\347\263\273\345\210\227/\347\203\247\351\245\274\346\216\222\345\272\217.md"
+++ "b/\347\256\227\346\263\225\346\200\235\347\273\264\347\263\273\345\210\227/\347\203\247\351\245\274\346\216\222\345\272\217.md"
@@ -149,4 +149,74 @@ void reverse(int[] arr, int i, int j) {
-======其他语言代码======
\ No newline at end of file
+======其他语言代码======
+
+[L-WEIWEI](https://github.com/L-WWEEII) 提供 第969题的 Java 代码：
+
+```java
+class Solution {
+ public List
-======其他语言代码======
\ No newline at end of file
+======其他语言代码======
+
+[gowufang](https://github.com/gowufang)提供第146题C++代码：
+```cpp
+class LRUCache {
+ public:
+ struct node {
+ int val;
+ int key;
+ node* pre;//当前节点的前一个节点
+ node* next;//当前节点的后一个节点
+ node(){}
+ node(int key, int val):key(key), val(val), pre(NULL), next(NULL){}
+ };
+
+ LRUCache(int size) {
+ this->size = size;
+ head = new node();
+ tail = new node();
+ head->next = tail;
+ tail->pre = head;
+ }
+
+
+ void movetohead(node* cur)//相当于一个insert操作，在head 和 head的next之间插入一个节点
+ {
+ node* next = head->next;//head的next先保存起来
+ head->next = cur;//将当前节点移动到head的后面
+ cur->pre = head;//当前节点cur的pre指向head
+ next->pre = cur;
+ cur->next = next;
+ }
+
+ node* deletecurrentnode(node* cur)//移除当前节点
+ {
+ cur->pre->next = cur->next;
+ cur->next->pre = cur->pre;
+ return cur;
+ }
+ void makerecently(node* cur)
+ {
+ node* temp = deletecurrentnode(cur);// 删除 cur，要重新插入到对头
+ movetohead(temp);//cur放到队头去
+ }
+ int get(int key)
+ {
+ int ret = -1;
+ if ( map.count(key))
+ {
+ node* temp = map[key];
+ makerecently(temp);// 将 key 变为最近使用
+ ret = temp->val;
+ }
+ return ret;
+ }
+
+ void put(int key, int value) {
+ if ( map.count(key))
+ {
+ // 修改 key 的值
+ node* temp = map[key];
+ temp->val = value;
+ // 将 key 变为最近使用
+ makerecently(temp);
+ }
+ else
+ {
+ node* cur = new node(key, value);
+ if( map.size()== size )
+ {
+ // 链表头部就是最久未使用的 key
+ node *temp = deletecurrentnode(tail->pre);
+ map.erase(temp->key);
+ }
+ movetohead(cur);
+ map[key] = cur;
+
+ }
+
+ }
+
+ unordered_map
-======其他语言代码======
\ No newline at end of file
+======其他语言代码======
+[dekunma](https://www.linkedin.com/in/dekun-ma-036a9b198/) 提供C++代码
+**解法一：遍历（也可以用双指针）：**
+```C++
+class Solution {
+public:
+ bool isSubsequence(string s, string t) {
+ // 遍历s
+ for(int i = 0; i < s.size(); i++) {
+ // 找到s[i]字符在t中的位置
+ size_t pos = t.find(s[i]);
+
+ // 如果s[i]字符不在t中，返回false
+ if(pos == std::string::npos) return false;
+ // 如果s[i]在t中，后面就只看pos以后的字串，防止重复查找
+ else t = t.substr(pos + 1);
+ }
+ return true;
+ }
+};
+```
+
+**解法二：二分查找：**
+```C++
+class Solution {
+public:
+ bool isSubsequence(string s, string t) {
+ int m = s.size(), n = t.size();
+ // 对 t 进行预处理
+ vector
-======其他语言代码======
\ No newline at end of file
+======其他语言代码======
+
+C++版本：
+```cpp
+ bool isPalindrome(ListNode* head) {
+ if (head == nullptr || head->next == nullptr) //为空或者只有一个节点时，直接判断为true
+ return true;
+ ListNode* slow = head, * fast = head;
+ while (fast != nullptr) {//首先找到中间节点
+ slow = slow->next;
+ fast = fast->next == nullptr? fast->next:fast->next->next; //因为链表长度可能是奇数或偶数，所以需要进行判断
+ }
+
+ ListNode* temp = nullptr,* pre = nullptr;//pre始终保持后续链表的头部，temp节点则作为中间零时替换的节点
+ while (slow != nullptr) {//利用头插法，将当前节点与后续链表断链处理，反转后半部分的链表
+ temp = slow->next;
+ slow->next = pre;//建立连接
+ pre = slow;//pre始终作为后续链表的头部
+ slow = temp;
+ }
+
+ while (head !=nullptr && pre != nullptr) {//同步进行比较
+ if (head->val != pre->val) {//值有不一样的，说明不是回文联表，直接返回false了
+ return false;
+ }
+ head = head->next;//head向下走，直到走到空
+ pre = pre->next;//pre节点也向下走，直到走到空
+ }
+ return true;//到此说明当前链表是回文链表返回true即可
+ }
+
+```
diff --git "a/\351\253\230\351\242\221\351\235\242\350\257\225\347\263\273\345\210\227/\345\220\210\346\263\225\346\213\254\345\217\267\345\210\244\345\256\232.md" "b/\351\253\230\351\242\221\351\235\242\350\257\225\347\263\273\345\210\227/\345\220\210\346\263\225\346\213\254\345\217\267\345\210\244\345\256\232.md"
index 32239bdae460f4d342f1a499bb0ecfb3839e9df6..6516aa1b53ed0c47efd7abe27e8229e37bd23a5b 100644
--- "a/\351\253\230\351\242\221\351\235\242\350\257\225\347\263\273\345\210\227/\345\220\210\346\263\225\346\213\254\345\217\267\345\210\244\345\256\232.md"
+++ "b/\351\253\230\351\242\221\351\235\242\350\257\225\347\263\273\345\210\227/\345\220\210\346\263\225\346\213\254\345\217\267\345\210\244\345\256\232.md"
@@ -112,4 +112,51 @@ char leftOf(char c) {
-======其他语言代码======
\ No newline at end of file
+======其他语言代码======
+
+### Python3
+```python
+def isValid(self, s: str) -> bool:
+ left = []
+ leftOf = {
+ ')':'(',
+ ']':'[',
+ '}':'{'
+ }
+ for c in s:
+ if c in '([{':
+ left.append(c)
+ elif left and leftOf[c]==left[-1]: # 右括号 + left不为空 + 和最近左括号能匹配
+ left.pop()
+ else: # 右括号 + （left为空 / 和堆顶括号不匹配）
+ return False
+
+ # left中所有左括号都被匹配则return True 反之False
+ return not left
+```
+
+
+```java
+//基本思想：每次遇到左括号时都将相对应的右括号'）'，']'或'}'推入堆栈
+//如果在字符串中出现右括号，则需要检查堆栈是否为空，以及顶部元素是否与该右括号相同。如果不是，则该字符串无效。
+//最后，我们还需要检查堆栈是否为空
+public boolean isValid(String s) {
+ Deque
-======其他语言代码======
\ No newline at end of file
+======其他语言代码======
+
+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;
+ }
+};
+```
+
+
+
diff --git "a/\351\253\230\351\242\221\351\235\242\350\257\225\347\263\273\345\210\227/\346\216\245\351\233\250\346\260\264.md" "b/\351\253\230\351\242\221\351\235\242\350\257\225\347\263\273\345\210\227/\346\216\245\351\233\250\346\260\264.md"
index e1fd62583f3a5a563afffc34df9af8e6a3092452..a500aac0f73498427cb2908cd78480037cc11b1c 100644
--- "a/\351\253\230\351\242\221\351\235\242\350\257\225\347\263\273\345\210\227/\346\216\245\351\233\250\346\260\264.md"
+++ "b/\351\253\230\351\242\221\351\235\242\350\257\225\347\263\273\345\210\227/\346\216\245\351\233\250\346\260\264.md"
@@ -211,4 +211,99 @@ if (l_max < r_max) {
-======其他语言代码======
\ No newline at end of file
+======其他语言代码======
+
+[Yifan Zhang](https://github.com/FanFan0919) 提供 java 代码
+
+**双指针解法**：时间复杂度 O(N)，空间复杂度 O(1)
+
+对cpp版本的解法有非常微小的优化。
+因为我们每次循环只会选 left 或者 right 处的柱子来计算，因此我们并不需要在每次循环中同时更新`maxLeft`和`maxRight`。
+我们可以先比较 `maxLeft` 和 `maxRight`，决定这次选择计算的柱子是 `height[left]` 或者 `height[right]` 后再更新对应的 `maxLeft` 或 `maxRight`。
+当然这并不会在时间上带来什么优化，只是提供一种思路。
+
+```java
+class Solution {
+ public int trap(int[] height) {
+ if (height == null || height.length == 0) return 0;
+ int left = 0, right = height.length - 1;
+ int maxLeft = height[left], maxRight = height[right];
+ int res = 0;
+
+ while (left < right) {
+ // 比较 maxLeft 和 maxRight，决定这次计算 left 还是 right 处的柱子
+ if (maxLeft < maxRight) {
+ left++;
+ maxLeft = Math.max(maxLeft, height[left]); // update maxLeft
+ res += maxLeft - height[left];
+ } else {
+ right--;
+ maxRight = Math.max(maxRight, height[right]); // update maxRight
+ res += maxRight - height[right];
+ }
+ }
+
+ return res;
+ }
+}
+```
+
+附上暴力解法以及备忘录解法的 java 代码
+
+**暴力解法**：时间复杂度 O(N^2)，空间复杂度 O(1)
+```java
+class Solution {
+ public int trap(int[] height) {
+ if (height == null || height.length == 0) return 0;
+ int n = height.length;
+ int res = 0;
+ // 跳过最左边和最右边的柱子，从第二个柱子开始
+ for (int i = 1; i < n - 1; i++) {
+ int maxLeft = 0, maxRight = 0;
+ // 找右边最高的柱子
+ for (int j = i; j < n; j++) {
+ maxRight = Math.max(maxRight, height[j]);
+ }
+ // 找左边最高的柱子
+ for (int j = i; j >= 0; j--) {
+ maxLeft = Math.max(maxLeft, height[j]);
+ }
+ // 如果自己就是最高的话，
+ // maxLeft == maxRight == height[i]
+ res += Math.min(maxLeft, maxRight) - height[i];
+ }
+ return res;
+ }
+}
+```
+
+**备忘录解法**：时间复杂度 O(N)，空间复杂度 O(N)
+```java
+class Solution {
+ public int trap(int[] height) {
+ if (height == null || height.length == 0) return 0;
+ int n = height.length;
+ int res = 0;
+ // 数组充当备忘录
+ int[] maxLeft = new int[n];
+ int[] maxRight = new int[n];
+ // 初始化 base case
+ maxLeft[0] = height[0];
+ maxRight[n - 1] = height[n - 1];
+
+ // 从左向右计算 maxLeft
+ for (int i = 1; i < n; i++) {
+ maxLeft[i] = Math.max(maxLeft[i - 1], height[i]);
+ }
+ // 从右向左计算 maxRight
+ for (int i = n - 2; i >= 0; i--) {
+ maxRight[i] = Math.max(maxRight[i + 1], height[i]);
+ }
+ // 计算答案
+ for (int i = 1; i < n; i++) {
+ res += Math.min(maxLeft[i], maxRight[i]) - height[i];
+ }
+ return res;
+ }
+}
+```
\ No newline at end of file
diff --git "a/\351\253\230\351\242\221\351\235\242\350\257\225\347\263\273\345\210\227/\346\266\210\345\244\261\347\232\204\345\205\203\347\264\240.md" "b/\351\253\230\351\242\221\351\235\242\350\257\225\347\263\273\345\210\227/\346\266\210\345\244\261\347\232\204\345\205\203\347\264\240.md"
index 844b5cb6ff0f178fe304042ad519e56cf261fdc0..355953e3cef6c9c8a19a987f0afdd4178e64e867 100644
--- "a/\351\253\230\351\242\221\351\235\242\350\257\225\347\263\273\345\210\227/\346\266\210\345\244\261\347\232\204\345\205\203\347\264\240.md"
+++ "b/\351\253\230\351\242\221\351\235\242\350\257\225\347\263\273\345\210\227/\346\266\210\345\244\261\347\232\204\345\205\203\347\264\240.md"
@@ -89,6 +89,7 @@ int missingNumber(int[] nums) {
for (int x : nums)
sum += x;
return expect - sum;
+}
```
你看，这种解法应该是最简单的，但说实话，我自己也没想到这个解法，而且我去问了几个大佬，他们也没想到这个最简单的思路。相反，如果去问一个初中生，他也许很快就能想到。
@@ -132,4 +133,49 @@ public int missingNumber(int[] nums) {
-======其他语言代码======
\ No newline at end of file
+======其他语言代码======
+
+[happy-yuxuan](https://github.com/happy-yuxuan) 提供 三种方法的 C++ 代码：
+
+```c++
+// 方法：异或元素和索引
+int missingNumber(vector
-======其他语言代码======
\ No newline at end of file
+======其他语言代码======
+
+[zhuli](https://github.com/1097452462 "zhuli")提供的Java代码：
+```java
+class Solution {
+ public int[] findErrorNums(int[] nums) {
+ int n = nums.length;
+ int dup = -1;
+ for (int i = 0; i < n; i++) {
+ // 元素是从 1 开始的
+ int index = Math.abs(nums[i]) - 1;
+ // nums[index] 小于 0 则说明重复访问
+ if (nums[index] < 0)
+ dup = Math.abs(nums[i]);
+ else
+ nums[index] *= -1;
+ }
+ int missing = -1;
+ for (int i = 0; i < n; i++)
+ // nums[i] 大于 0 则说明没有访问
+ if (nums[i] > 0)
+ // 将索引转换成元素
+ missing = i + 1;
+ return new int[]{dup, missing};
+ }
+}
+```