修正文章内容

Author: itcharge

docs/01_array/01_15_array_two_pointers.md

@@ -380,8 +380,8 @@ class Solution:
 
 ##### 思路 1：复杂度分析
 
-- **时间复杂度**：$O(n)$。
-- **空间复杂度**：$O(1)$。
+- **时间复杂度**：$O(m \log m + n \log n)$，其中 $m$ 和 $n$ 分别为两个数组的长度。排序用时 $O(m \log m + n \log n)$，双指针遍历用时 $O(m + n)$，因此总的时间复杂度为 $O(m \log m + n \log n)$。
+- **空间复杂度**：$O(\min(m, n))$。
 
 ## 5. 双指针总结
 

docs/04_string/04_09_ac_automaton.md

@@ -12,9 +12,6 @@
 
 如果只使用字典树（Trie），虽然能够共享前缀，但每次匹配失败都必须回到根节点重新开始，无法实现高效跳转，最坏情况下复杂度也接近 $O(n \times m)$。
 
-
-
-
 ### 1.2 AC 自动机高效匹配原理
 
 AC 自动机能够高效解决多模式匹配问题，其核心思想是：将所有模式串构建为一棵字典树（Trie），并为每个节点设置失配指针（fail 指针），结合 KMP 算法的失配机制，实现对文本串的一次扫描即可同时匹配多个模式串。
@@ -65,9 +62,9 @@ AC 自动机的时间复杂度为 $O(n + m + k)$，其中 $n$ 为文本串长度
 
 失配指针的构造遵循以下规则：
 
-1. **根节点**：失配指针为 `null`
-2. **根节点的子节点**：失配指针都指向根节点
-3. **其他节点**：从父节点的失配指针开始查找，如果找到对应字符的子节点，则指向该子节点；否则继续向上查找，直到找到或到达根节点
+1. **根节点**：失配指针为 `null`。
+2. **根节点的子节点**：失配指针都指向根节点。
+3. **其他节点**：从父节点的失配指针开始查找，如果找到对应字符的子节点，则指向该子节点；否则继续向上查找，直到找到或到达根节点。
 
 #### 2.2.3 构造示例
 
@@ -84,36 +81,37 @@ AC 自动机的时间复杂度为 $O(n + m + k)$，其中 $n$ 为文本串长度
 ```
 
 **失配指针构造过程**：
+
 - `s` → `root`（根节点子节点指向根节点）
 - `h` → `root`（根节点子节点指向根节点）
 - `sa` → `root`（根节点没有 `a` 子节点）
 - `sh` → `h`（根节点有 `h` 子节点）
-- `he` → `e`（根节点有 `e` 子节点）
-- `hr` → `root`（根节点没有 `r` 子节点）
 - `say` → `root`（根节点没有 `y` 子节点）
 - `she` → `he`（`h` 节点有 `e` 子节点）
 - `shr` → `root`（`h` 和根节点都没有 `r` 子节点）
-- `her` → `root`（`e` 和根节点都没有 `r` 子节点）
+- `he` → `root`（根节点没有 `e` 子节点）
+- `her` → `root`（`root` 没有 `r` 子节点）
 
 #### 2.2.4 失配指针的作用
 
 失配指针的主要作用是：
-1. **快速跳转**：匹配失败时，不需要回到根节点重新开始
-2. **避免重复比较**：利用已匹配的部分信息，避免重复比较
-3. **保证匹配连续性**：确保跳转后当前匹配的字符串仍是某个模式串的前缀
+
+1. **快速跳转**：匹配失败时，不需要回到根节点重新开始。
+2. **避免重复比较**：利用已匹配的部分信息，避免重复比较。
+3. **保证匹配连续性**：确保跳转后当前匹配的字符串仍是某个模式串的前缀。
 
 ### 2.3 文本串匹配过程
 
 有了字典树和失配指针，我们就可以进行高效的文本串匹配了。
 
 #### 2.3.1 匹配算法流程
 
-1. **初始化**：从根节点开始
+1. **初始化**：从根节点开始。
 2. **字符匹配**：对于文本串中的每个字符：
-   - 如果当前节点有对应字符的子节点，移动到该子节点
-   - 否则，沿着失配指针向上查找，直到找到匹配的子节点或到达根节点
-3. **模式串检测**：每到达一个节点，检查该节点是否为某个模式串的结尾
-4. **输出匹配结果**：如果找到匹配的模式串，记录其位置和内容
+   - 如果当前节点有对应字符的子节点，移动到该子节点。
+   - 否则，沿着失配指针向上查找，直到找到匹配的子节点或到达根节点。
+3. **模式串检测**：每到达一个节点，检查该节点是否为某个模式串的结尾。
+4. **输出匹配结果**：如果找到匹配的模式串，记录其位置和内容。
 
 #### 2.3.2 匹配过程示例
 
@@ -125,12 +123,12 @@ AC 自动机的时间复杂度为 $O(n + m + k)$，其中 $n$ 为文本串长度
 | `a` | 根节点 | 无匹配，保持根节点 | - | - |
 | `s` | 根节点 | 移动到 `s` 节点 | `s` | - |
 | `h` | `s` 节点 | 移动到 `sh` 节点 | `sh` | - |
-| `e` | `sh` 节点 | 移动到 `she` 节点 | `she` | **找到 `she`** |
-| `r` | `she` 节点 | 失配，跳转到根节点 | - | - |
-| `h` | 根节点 | 移动到 `h` 节点 | `h` | - |
-| `s` | `h` 节点 | 失配，跳转到根节点，再移动到 `s` 节点 | `s` | - |
+| `e` | `sh` 节点 | 移动到 `she` 节点 | `she` | **找到 `she`、`he`**（沿 fail 链） |
+| `r` | `she` 节点 | 失配，沿 fail 跳到 `he`，再转移到 `her` 节点 | `her` | **找到 `her`** |
+| `h` | `her` 节点 | 失配，跳到根节点，再移动到 `h` 节点 | `h` | - |
+| `s` | `h` 节点 | 失配，跳到根节点，再移动到 `s` 节点 | `s` | - |
 
-**最终结果**：在文本串 `yasherhs` 中找到模式串 `she`（位置 2-4）。
+**最终结果**：在文本串 `yasherhs` 中找到模式串 `she`（位置 3-5）、`he`（位置 4-5）、`her`（位置 4-6）。
 
 
 ## 3. AC 自动机代码实现

docs/08_dynamic_programming/08_03_linear_dp_01.md

@@ -114,6 +114,59 @@ class Solution:
 - **时间复杂度**：$O(n^2)$。外层和内层循环各遍历一次数组，整体为 $O(n^2)$，最后取最大值为 $O(n)$，因此总时间复杂度为 $O(n^2)$。
 - **空间复杂度**：$O(n)$。仅需一个长度为 $n$ 的一维数组存储状态，故空间复杂度为 $O(n)$。
 
+##### 思路 2：进阶的线性 DP + 二分查找
+
+###### 1. 算法思想
+
+使用 **数组作为可实时更新内部的单调栈**，结合 **贪心法** 和 **二分查找** 来优化时间复杂度。
+
+核心思想：
+- $tails[k]$ 表示长度为 $k+1$ 的 LIS 的最小末尾元素（无闲置索引，动态扩展）
+- 对于每个元素 $x$，使用二分查找在 $tails$ 中找到第一个 $\ge x$ 的位置
+- 如果 $x$ 比所有元素都大，则追加到 $tails$ 末尾，形成新的 LIS 长度
+- 否则，用较小的 $x$ 更新 $tails[k]$，优化同长度 LIS 的末尾元素（变得更小）
+
+###### 2. 算法步骤
+
+1. 初始化 $tails$ 为空数组。
+2. 遍历数组 $nums$ 中的每个元素 $x$：
+   - 使用二分查找在 $tails$ 中找到第一个 $\ge x$ 的位置 $k$。
+   - 如果 $k == len(tails)$，说明 $x$ 比所有元素都大，追加到 $tails$ 末尾。
+   - 否则，用 $x$ 更新 $tails[k]$，优化同长度 LIS 的末尾元素。
+3. 返回 $tails$ 的长度，即为最终 LIS 的长度。
+
+##### 思路 2：进阶的线性 DP + 二分查找代码
+
+```python
+import bisect
+
+class Solution:
+    def lengthOfLIS(self, nums: List[int]) -> int:
+        if len(nums) == 1:
+            return 1
+        
+        # tails[k] 表示长度为 k+1 的 LIS 的最小末尾元素（无闲置索引，动态扩展）
+        tails = list()
+        for x in nums:
+            # 二分查找：在tails中找首个≥x的位置
+            k = bisect.bisect_left(tails, x)
+            # 如果 x 比所有元素都大，k 的结果会是当前数组长度（末尾位置索引 +1）
+            # x 直接新增在 tails 数组末尾，形成新问题（LIS 长度 +1）
+            if k == len(tails):
+                tails.append(x)
+            # 用较小的 x 更新较大的 tails[k]，优化同长度 LIS 问题的末尾元素（变得更小）
+            else:
+                tails[k] = x
+        
+        # tails 的长度即为最终 LIS 问题的长度
+        return len(tails)
+```
+
+##### 思路 2：复杂度分析
+
+- **时间复杂度**：$O(n \log n)$。遍历数组的时间复杂度是 $O(n)$，每个元素进行二分查找的时间复杂度是 $O(\log n)$，所以总体时间复杂度为 $O(n \log n)$。
+- **空间复杂度**：$O(n)$。$tails$ 数组最多存储 $n$ 个元素，所以总体空间复杂度为 $O(n)$。
+
 ### 3.2 经典例题：最大子数组和
 
 在线性 DP 问题中，除了关注子序列相关的线性 DP，还常常遇到子数组相关的线性 DP 问题。
@@ -451,3 +504,4 @@ class Solution:
 
 - 【书籍】算法竞赛进阶指南
 - 【文章】[动态规划概念和基础线性DP | 潮汐朝夕](https://chengzhaoxi.xyz/1a4a2483.html)
+- 【题解】[进阶的线性DP + 二分查找 ｜ 来自评论区](https://github.com/xiaos2021)

docs/solutions/0001-0099/sort-colors.md

@@ -45,11 +45,12 @@
 这道题我们也可以借鉴快速排序算法中的 $partition$ 过程，将 $1$ 作为基准数 $pivot$，然后将序列分为三部分：$0$（即比 $1$ 小的部分）、等于 $1$ 的部分、$2$（即比 $1$ 大的部分）。具体步骤如下：
 
 1. 使用两个指针 $left$、$right$，分别指向数组的头尾。$left$ 表示当前处理好红色元素的尾部，$right$ 表示当前处理好蓝色的头部。
-2. 再使用一个下标 $index$ 遍历数组，如果遇到 $nums[index] == 0$，就交换 $nums[index]$ 和 $nums[left]$，同时将 $left$ 右移。如果遇到 $nums[index] == 2$，就交换 $nums[index]$ 和 $nums[right]$，同时将 $right$ 左移。
+2. 再使用一个下标 $index$ 遍历数组：
+   - 如果遇到 $nums[index] == 0$，就交换 $nums[index]$ 和 $nums[left]$，同时将 $left$ 和 $index$ 都右移（因为交换后 $nums[index]$ 可能是从 $left$ 位置换过来的，需要继续检查）。
+   - 如果遇到 $nums[index] == 2$，就交换 $nums[index]$ 和 $nums[right]$，同时将 $right$ 左移（注意 $index$ 不增加，因为交换后 $nums[index]$ 可能是从 $right$ 位置换过来的 0 或 1，需要再次检查）。
+   - 如果遇到 $nums[index] == 1$，直接将 $index$ 右移。
 3. 直到 $index$ 移动到 $right$ 位置之后，停止遍历。遍历结束之后，此时 $left$ 左侧都是红色，$right$ 右侧都是蓝色。
 
-注意：移动的时候需要判断 $index$ 和 $left$ 的位置，因为 $left$ 左侧是已经处理好的数组，所以需要判断 $index$ 的位置是否小于 $left$，小于的话，需要更新 $index$ 位置。
-
 ### 思路 1：代码
 
 ```python
@@ -59,11 +60,10 @@ class Solution:
         right = len(nums) - 1
         index = 0
         while index <= right:
-            if index < left:
-                index += 1
-            elif nums[index] == 0:
+            if nums[index] == 0:
                 nums[index], nums[left] = nums[left], nums[index]
                 left += 1
+                index += 1
             elif nums[index] == 2:
                 nums[index], nums[right] = nums[right], nums[index]
                 right -= 1

docs/solutions/0300-0399/intersection-of-two-arrays.md

@@ -100,5 +100,5 @@ class Solution:
 
 ### 思路 2：复杂度分析
 
-- **时间复杂度**：$O(n)$。
-- **空间复杂度**：$O(1)$。
+- **时间复杂度**：$O(m \log m + n \log n)$，其中 $m$ 和 $n$ 分别为两个数组的长度。排序用时 $O(m \log m + n \log n)$，双指针遍历用时 $O(m + n)$，因此总的时间复杂度为 $O(m \log m + n \log n)$。
+- **空间复杂度**：$O(\min(m, n))$。

docs/solutions/0300-0399/longest-increasing-subsequence.md

@@ -89,3 +89,59 @@ class Solution:
 - **时间复杂度**：$O(n^2)$。两重循环遍历的时间复杂度是 $O(n^2)$，最后求最大值的时间复杂度是 $O(n)$，所以总体时间复杂度为 $O(n^2)$。
 - **空间复杂度**：$O(n)$。用到了一维数组保存状态，所以总体空间复杂度为 $O(n)$。
 
+### 思路 2：进阶的线性 DP + 二分查找
+
+###### 1. 算法思想
+
+使用 **数组作为可实时更新内部的单调栈**，结合 **贪心法** 和 **二分查找** 来优化时间复杂度。
+
+核心思想：
+- $tails[k]$ 表示长度为 $k+1$ 的 LIS 的最小末尾元素（无闲置索引，动态扩展）
+- 对于每个元素 $x$，使用二分查找在 $tails$ 中找到第一个 $\ge x$ 的位置
+- 如果 $x$ 比所有元素都大，则追加到 $tails$ 末尾，形成新的 LIS 长度
+- 否则，用较小的 $x$ 更新 $tails[k]$，优化同长度 LIS 的末尾元素（变得更小）
+
+###### 2. 算法步骤
+
+1. 初始化 $tails$ 为空数组。
+2. 遍历数组 $nums$ 中的每个元素 $x$：
+   - 使用二分查找在 $tails$ 中找到第一个 $\ge x$ 的位置 $k$。
+   - 如果 $k == len(tails)$，说明 $x$ 比所有元素都大，追加到 $tails$ 末尾。
+   - 否则，用 $x$ 更新 $tails[k]$，优化同长度 LIS 的末尾元素。
+3. 返回 $tails$ 的长度，即为最终 LIS 的长度。
+
+### 思路 2：进阶的线性 DP + 二分查找代码
+
+```python
+import bisect
+
+class Solution:
+    def lengthOfLIS(self, nums: List[int]) -> int:
+        if len(nums) == 1:
+            return 1
+        
+        # tails[k] 表示长度为 k+1 的 LIS 的最小末尾元素（无闲置索引，动态扩展）
+        tails = list()
+        for x in nums:
+            # 二分查找：在tails中找首个≥x的位置
+            k = bisect.bisect_left(tails, x)
+            # 如果 x 比所有元素都大，k 的结果会是当前数组长度（末尾位置索引 +1）
+            # x 直接新增在 tails 数组末尾，形成新问题（LIS 长度 +1）
+            if k == len(tails):
+                tails.append(x)
+            # 用较小的 x 更新较大的 tails[k]，优化同长度 LIS 问题的末尾元素（变得更小）
+            else:
+                tails[k] = x
+        
+        # tails 的长度即为最终 LIS 问题的长度
+        return len(tails)
+```
+
+### 思路 2：复杂度分析
+
+- **时间复杂度**：$O(n \log n)$。遍历数组的时间复杂度是 $O(n)$，每个元素进行二分查找的时间复杂度是 $O(\log n)$，所以总体时间复杂度为 $O(n \log n)$。
+- **空间复杂度**：$O(n)$。$tails$ 数组最多存储 $n$ 个元素，所以总体空间复杂度为 $O(n)$。
+
+## 参考资料
+
+- 【题解】[进阶的线性DP + 二分查找 ｜ 来自评论区](https://github.com/xiaos2021)

docs/solutions/0500-0599/number-of-provinces.md

@@ -9,13 +9,17 @@
 
 ## 题目大意
 
-**描述**：有 `n` 个城市，其中一些彼此相连，另一些没有相连。如果城市 `a` 与城市 `b` 直接相连，且城市 `b` 与城市 `c` 直接相连，那么城市 `a` 与城市 `c` 间接相连。
+**描述**：
+
+有 `n` 个城市，其中一些彼此相连，另一些没有相连。如果城市 `a` 与城市 `b` 直接相连，且城市 `b` 与城市 `c` 直接相连，那么城市 `a` 与城市 `c` 间接相连。
 
 「省份」是由一组直接或间接链接的城市组成，组内不含有其他没有相连的城市。
 
 现在给定一个 `n * n` 的矩阵 `isConnected` 表示城市的链接关系。其中 `isConnected[i][j] = 1` 表示第 `i` 个城市和第 `j` 个城市直接相连，`isConnected[i][j] = 0` 表示第 `i` 个城市和第 `j` 个城市没有相连。
 
-**要求**：根据给定的城市关系，返回「省份」的数量。
+**要求**：
+
+根据给定的城市关系，返回「省份」的数量。
 
 **说明**：
 
@@ -81,15 +85,13 @@ class Solution:
     def findCircleNum(self, isConnected: List[List[int]]) -> int:
         size = len(isConnected)
         union_find = UnionFind(size)
+        cnt = size
         for i in range(size):
             for j in range(i + 1, size):
                 if isConnected[i][j] == 1:
-                    union_find.union(i, j)
-
-        res = set()
-        for i in range(size):
-            res.add(union_find.find(i))
-        return len(res)
+                    if union_find.union(i, j):
+                        cnt -= 1
+        return cnt
 ```
 
 ### 思路 1：复杂度分析

docs/solutions/0600-0699/number-of-longest-increasing-subsequence.md

@@ -53,7 +53,7 @@
 - 当 `nums[j] < nums[i]`，而且 `dp[j] + 1 > dp[i]` 时，说明第一次找到 `dp[j] + 1`长度且以`nums[i]`结尾的最长递增子序列，则以 `nums[i]` 结尾的最长递增子序列的组合数就等于以 `nums[j]` 结尾的组合数，即 `count[i] = count[j]`。
 - 当 `nums[j] < nums[i]`，而且 `dp[j] + 1 == dp[i]` 时，说明以 `nums[i]` 结尾且长度为 `dp[j] + 1` 的递增序列已找到过一次了，则以 `nums[i]` 结尾的最长递增子序列的组合数要加上以 `nums[j]` 结尾的组合数，即 `count[i] += count[j]`。
 
-- 然后根据遍历 dp 数组得到的最长递增子序列的长度 max_length，然后再一次遍历 dp 数组，将所有 `dp[i] == max_length` 情况下的组合数 `coun[i]` 累加起来，即为最长递增序列的个数。
+- 然后根据遍历 dp 数组得到的最长递增子序列的长度 Z，然后再一次遍历 dp 数组，将所有 `dp[i] == max_length` 情况下的组合数 `coun[i]` 累加起来，即为最长递增序列的个数。
 
 ### 思路 1：动态规划代码
 

docs/solutions/1200-1299/minimum-swaps-to-make-strings-equal.md

@@ -19,7 +19,7 @@
 **说明**：
 
 - $1 \le s1.length, s2.length \le 1000$。
-- $s1$、$ s2$ 只包含 `'x'` 或 `'y'`。
+- $s1$、$s2$ 只包含 `'x'` 或 `'y'`。
 
 **示例**：