update 209

Author: 2xiao

src/leetcode/problem/0001.md

@@ -47,9 +47,9 @@ time complexity?
 
 ## 解题思路
 
-这道题最优的做法时间复杂度是 O(n)。
+这道题最优的做法时间复杂度是 `O(n)`。
 
-使用哈希表，顺序扫描数组，对每一个元素，在 object 中找能组合给定值的另一半数字，如果找到了，直接返回 2 个数字的下标即可。如果找不到，就把这个数字存入 object 中，等待扫到“另一半”数字的时候，再取出来返回结果。
+使用哈希表，顺序扫描数组，对每一个元素，在 `object` 中找能组合给定值的另一半数字，如果找到了，直接返回 2 个数字的下标即可。如果找不到，就把这个数字存入 `object` 中，等待扫到“另一半”数字的时候，再取出来返回结果。
 
 ## 代码
 

src/leetcode/problem/0005.md

@@ -54,13 +54,13 @@ Given a string `s`, return _the longest_ _palindromic_ _substring_ in `s`.
 - 定义动态规划数组 `dp`，其中 `dp[i][j]` 表示字符串 `s` 从索引 `i` 到索引 `j` 是否为回文串。
 - 状态转移方程为：
 
-  - `s[i] = s[j] && dp[i+1][j-1] = true` 时，`dp[i][j] = true`
+  - `s[i] == s[j] && dp[i+1][j-1] == true` 时，`dp[i][j] = true`
   - 否则，`dp[i][j] = false`
 
 - 边界条件：
 
   - `dp[i][i] = true`
-  - `s[i] = s[i+1]` 时，`dp[i][i+1] = true`
+  - `s[i] == s[i+1]` 时，`dp[i][i+1] = true`
 
 - 时间复杂度：`O(n^2)`，其中 `n` 是字符串的长度。
 - 空间复杂度：`O(n^2)`。

src/leetcode/problem/0014.md

@@ -37,14 +37,14 @@ If there is no common prefix, return an empty string `""`.
 
 ## 解题思路
 
-### 解法一：循环比较
+### 思路一：循环比较
 
 初始化公共前缀为字符串数组中的第一个字符串，然后将数组中的字符串与公共前缀一依次比较，每次比较出不同时就缩小公共前缀，直到公共前缀为空或者遍历完所有字符串数组。
 
 - 时间复杂度：`O(len(strs[0]))` 或 `O(len(strs))`
 - 空间复杂度：`O(len(strs[0]))`
 
-### 解法二：二维数组
+### 思路二：二维数组
 
 把字符串列表看成一个二维数组，然后用一个嵌套 `for` 循环计算这个二维数组前面有多少列的元素完全相同即可。
 

src/leetcode/problem/0151.md

@@ -60,7 +60,7 @@ solve it **in-place** with `O(1)` extra space?
 
 ## 解题思路
 
-### 解法一：分割+倒序
+### 思路一：分割+倒序
 
 常规的方式是把 `s` 按空格 `split` 成若干单词，然后 `reverse` 这些单词的顺序，最后把这些单词 `join` 成句子。
 
@@ -71,7 +71,7 @@ solve it **in-place** with `O(1)` extra space?
   - `join()` 方法为 `O(n)`
 - 空间复杂度： `O(n)`，新建的字符串数组总长度 `≤n` ，占用 `O(n)` 大小的额外空间。
 
-### 解法二：双指针
+### 思路二：双指针
 
 - 倒序遍历字符串 `s` ，记录单词左右索引边界 `i` , `j` 。
 - 每确定一个单词的边界，则将其添加至单词列表 `res` 。

src/leetcode/problem/0167.md

@@ -48,14 +48,24 @@ Your solution must use only constant extra space.
 
 ## 题目大意
 
-找出两个数之和等于 target 的两个数字，要求输出它们的下标。注意一个数字不能使用 2 次。下标从小到大输出。假定题目一定有一个解。
+给你一个下标从 `1` 开始的整数数组 `numbers` ，该数组已按 **非递减顺序排列** ，请你从数组中找出满足相加之和等于目标数 `target` 的两个数。如果设这两个数分别是 `numbers[index1]` 和 `numbers[index2]` ，则 `1 <= index1 < index2 <= numbers.length` 。
+
+以长度为 `2` 的整数数组 `[index1, index2]` 的形式返回这两个整数的下标 `index1` 和 `index2`。
+
+你可以假设每个输入 **只对应唯一的答案** ，而且你 **不可以** 重复使用相同的元素。
+
+你所设计的解决方案必须只使用常量级的额外空间。
 
 ## 解题思路
 
 这一题比 [第 1 题 Two Sum](./0001.md) 的问题还要简单，因为这里数组是有序的。可以直接用第一题的解法解决这道题。
 
 ## 代码
 
+:::: code-tabs
+
+@tab 对撞指针
+
 ```javascript
 // 解法一 这一题可以利用数组有序的特性，使用对撞指针
 /**
@@ -64,37 +74,43 @@ Your solution must use only constant extra space.
  * @return {number[]}
  */
 var twoSum = function (numbers, target) {
-  let i = 0;
-  let j = numbers.length - 1;
-  while (i < j) {
-    if (numbers[i] + numbers[j] === target) {
-      return [i + 1, j + 1];
-    } else if (numbers[i] + numbers[j] < target) {
-      i++;
-    } else {
-      j--;
-    }
-  }
+	let i = 0;
+	let j = numbers.length - 1;
+	while (i < j) {
+		if (numbers[i] + numbers[j] === target) {
+			return [i + 1, j + 1];
+		} else if (numbers[i] + numbers[j] < target) {
+			i++;
+		} else {
+			j--;
+		}
+	}
 };
+```
+
+@tab 哈希表
 
+```javascript
 // 解法二 不管数组是否有序，空间复杂度比上一种解法要多 O(n)
 /**
  * @param {number[]} nums
  * @param {number} target
  * @return {number[]}
  */
 var twoSum = function (nums, target) {
-  let obj = {};
-  for (let i = 0; i < nums.length; i++) {
-    let another = target - nums[i];
-    if (another in obj) {
-      return [obj[another], i];
-    }
-    obj[nums[i]] = i;
-  }
+	let obj = {};
+	for (let i = 0; i < nums.length; i++) {
+		let another = target - nums[i];
+		if (another in obj) {
+			return [obj[another], i];
+		}
+		obj[nums[i]] = i;
+	}
 };
 ```
 
+::::
+
 ## 相关题目
 
 :::: md-demo 相关题目

src/leetcode/problem/0209.md

@@ -43,17 +43,48 @@ solution of which the time complexity is `O(n log(n))`.
 
 找出该数组中满足其总和大于等于 `target` 的长度最小的 **子数组** ，并返回其长度。如果不存在符合条件的子数组，返回 `0` 。
 
+子数组是数组中连续的非空元素序列。
+
 ## 解题思路
 
+### 思路一：滑动窗口
+
 1. 初始化变量：使用两个指针（或滑动窗口）来遍历数组；
 2. 扩大窗口：移动右指针，向右扩大求和；
 3. 缩小窗口：一旦窗口总和大于等于 `target`，就移动左指针缩小窗口；
 4. 更新最小长度：过程中更新最小长度；
 
-时间复杂度：`O(n)`，空间复杂度：`O(1)`
+- 时间复杂度：`O(n)`，其中 n 是数组的长度；
+- 空间复杂度：`O(1)`
+
+### 思路二：暴力查找
+
+1. 初始化子数组的最小长度为无穷大；
+2. 枚举数组 `nums` 中的每个下标作为子数组的开始下标；
+3. 对于每个开始下标 `i`，需要找到大于或等于 `i` 的最小下标 `j`，使得从 `nums[i]` 到 `nums[j]` 的元素和大于或等于 `s`；
+4. 更新子数组的最小长度（此时子数组的长度是 `j−i+1`）；
+
+- 时间复杂度：`O(n^2)`，需要遍历每个下标作为子数组的开始下标，对于每个开始下标，需要遍历其后面的下标；
+- 空间复杂度：`O(1)`
+
+### 思路三：二分查找
+
+1. 暴力查找的时间复杂度是 `O(n^2)`，因为在确定每个子数组的开始下标后，找到长度最小的子数组需要 `O(n)` 的时间。如果使用二分查找，则可以将时间优化到 `O(logn)`。
+2. 为了使用二分查找，需要额外创建一个数组 sums 用于存储数组 nums 的前缀和，其中 `sums[i]` 表示从 `nums[0]` 到 `nums[i−1]` 的元素和。
+3. 得到前缀和之后，对于每个开始下标 `i`，可通过二分查找得到大于或等于 `i` 的最小下标 `bound`，使得 `sums[bound]−sums[i−1]≥s`，并更新子数组的最小长度（此时子数组的长度是 `bound−(i−1)`）。
+
+因为这道题保证了数组中每个元素都为正，所以前缀和一定是递增的，这一点保证了二分的正确性。如果题目没有说明数组中每个元素都为正，这里就不能使用二分来查找这个位置了。
+
+- 时间复杂度：`O(nlogn)`，遍历每个下标的时间复杂度是 `O(n)`，二分查找的时间复杂度是 `O(logn)`，因此总时间复杂度是 `O(nlogn)`。
+
+- 空间复杂度：`O(n)`，额外创建数组 `sums` 存储前缀和。
 
 ## 代码
 
+:::: code-tabs
+
+@tab 滑动窗口
+
 ```javascript
 /**
  * @param {number} target
@@ -76,6 +107,74 @@ var minSubArrayLen = function (target, nums) {
 };
 ```
 
+@tab 暴力查找
+
+```javascript
+/**
+ * @param {number} target
+ * @param {number[]} nums
+ * @return {number}
+ */
+var minSubArrayLen = function (target, nums) {
+	let n = nums.length,
+		res = Infinity;
+	if (n == 0) return 0;
+
+	for (let i = 0; i < n; i++) {
+		let sum = 0;
+		for (let j = i; j < n; j++) {
+			sum += nums[j];
+			if (sum >= target) {
+				res = Math.min(res, j - i + 1);
+				break;
+			}
+		}
+	}
+	return res == Infinity ? 0 : res;
+};
+```
+
+@tab 二分查找
+
+```javascript
+/**
+ * @param {number} target
+ * @param {number[]} nums
+ * @return {number}
+ */
+var minSubArrayLen = function (target, nums) {
+	let n = nums.length,
+		sum = [0],
+		res = Infinity;
+	for (let i = 1; i <= n; i++) {
+		sum[i] = nums[i - 1] + sum[i - 1];
+	}
+	for (let i = 1; i <= n; i++) {
+		let newTarget = target + sum[i - 1];
+		let bound = binarySearch(sum, newTarget, i, n);
+		if (bound != -1) {
+			res = Math.min(res, bound - i + 1);
+		}
+	}
+	return res == Infinity ? 0 : res;
+};
+
+var binarySearch = function (arr, target, l, r) {
+	if (arr[r] < target) return -1;
+	while (l < r) {
+		let mid = (l + r) >> 1;
+		if (arr[mid] < target) {
+			l = mid + 1;
+		} else {
+			r = mid;
+		}
+	}
+	return arr[l] >= target ? l : -1;
+};
+```
+
+::::
+
 ## 相关题目
 
 :::: md-demo 相关题目