Add a solution to problem 287. Remove the footers.

selected_coding_interview/docs/10. 正则表达式匹配.md

@@ -179,10 +179,3 @@ public:
 
 - **时间复杂度 $O(MN)$ ：** 其中 $M, N$ 分别为 `s` 和 `p` 的长度，状态转移需遍历整个 `dp` 矩阵。
 - **空间复杂度 $O(MN)$ ：** 状态矩阵 `dp` 使用 $O(MN)$ 的额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/101. 对称二叉树.md

@@ -77,10 +77,3 @@ private:
 - **空间复杂度 $O(N)$ ：** 如下图所示，最差情况下（二叉树退化为链表），系统使用 $O(N)$ 大小的空间。
 
 ![Picture2.png](https://pic.leetcode-cn.com/1599398062-LmPbix-Picture2.png){:width=450}
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/102. 二叉树的层序遍历.md

@@ -90,10 +90,3 @@ public:
 
 - **时间复杂度 $O(N)$ ：** $N$ 为二叉树的节点数量，即 BFS 需循环 $N$ 次。
 - **空间复杂度 $O(N)$ ：** 最差情况下，即当树为平衡二叉树时，最多有 $N/2$ 个树节点**同时**在 `queue` 中，使用 $O(N)$ 大小的额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/103. 二叉树的锯齿形层序遍历.md

@@ -278,10 +278,3 @@ public:
 
 - **时间复杂度 $O(N)$ ：** $N$ 为二叉树的节点数量，即 BFS 需循环 $N$ 次，占用 $O(N)$ 。**共完成** 少于 $N$ 个节点的倒序操作，占用 $O(N)$ 。
 - **空间复杂度 $O(N)$ ：** 最差情况下，即当树为满二叉树时，最多有 $N/2$ 个树节点**同时**在 `queue` 中，使用 $O(N)$ 大小的额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/104. 二叉树的最大深度.md

@@ -140,10 +140,3 @@ public:
 
 - **时间复杂度 $O(N)$ ：** $N$ 为树的节点数量，计算树的深度需要遍历所有节点。
 - **空间复杂度 $O(N)$ ：** 最差情况下（当树平衡时），队列 `queue` 同时存储 $N/2$ 个节点。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/105. 从前序与中序遍历序列构造二叉树.md

@@ -114,10 +114,3 @@ private:
 
 - **时间复杂度 $O(N)$ ：** 其中 $N$ 为树的节点数量。初始化 HashMap 需遍历 `inorder` ，占用 $O(N)$ 。递归共建立 $N$ 个节点，每层递归中的节点建立、搜索操作占用 $O(1)$ ，因此使用 $O(N)$ 时间。
 - **空间复杂度 $O(N)$ ：** HashMap 使用 $O(N)$ 额外空间；最差情况下（输入二叉树为链表时），递归深度达到 $N$ ，占用 $O(N)$ 的栈帧空间；因此总共使用 $O(N)$ 空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/113. 路径总和 II.md

@@ -103,10 +103,3 @@ private:
 
 - **时间复杂度 $O(N)$ ：** $N$ 为二叉树的节点数，先序遍历需要遍历所有节点。
 - **空间复杂度 $O(N)$ ：** 最差情况下，即树退化为链表时，`path` 存储所有树节点，使用 $O(N)$ 额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/121. 买卖股票的最佳时机.md

@@ -58,10 +58,3 @@ public:
 
 - **时间复杂度 $O(N)$ ：** 其中 $N$ 为数组 `prices` 长度。遍历 `prices` 使用线性时间。
 - **空间复杂度 $O(1)$ ：** 变量  `cost` , `profit` 使用 $O(1)$ 空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/136. 只出现一次的数字.md

@@ -60,10 +60,3 @@ public:
 
 - **时间复杂度 $O(N)$ ：** 线性遍历 $nums$ 使用 $O(N)$ 时间，异或操作使用 $O(1)$ 时间。
 - **空间复杂度 $O(1)$ ：** 辅助变量 $a$ , $b$ , $x$ , $y$ 使用常数大小额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/138. 复制带随机指针的链表.md

@@ -351,10 +351,3 @@ public:
 
 - **时间复杂度 $O(N)$ ：** 三轮遍历链表，使用 $O(N)$ 时间。
 - **空间复杂度 $O(1)$ ：** 节点引用变量使用常数大小的额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/1480. 一维数组的动态和.md

@@ -58,10 +58,3 @@ public:
 
 - **时间复杂度 $O(N)$ ：** 遍历 `nums` 使用线性时间。
 - **空间复杂度 $O(1)$ ：** 用于保存结果的  `dp` 是必须使用的空间，此处不计入。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/151. 反转字符串中的单词.md

@@ -101,10 +101,3 @@ class Solution:
   - [`join()` 方法：](https://stackoverflow.com/questions/37133547/time-complexity-of-string-concatenation-in-python) 为 $O(N)$ 。
   - [`reverse()` 方法：](https://stackoverflow.com/questions/37606159/what-is-the-time-complexity-of-python-list-reverse) 为 $O(N)$ 。
 - **空间复杂度 $O(N)$ ：** 单词列表 $strs$ 占用线性大小的额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/154. 寻找旋转排序数组中的最小值 II.md

@@ -157,10 +157,3 @@ public:
 
 - **时间复杂度 $O(\log_2 N)$ ：** 在特例情况下（例如 $[1, 1, 1, 1]$），会退化到 $O(N)$。
 - **空间复杂度 $O(1)$ ：** $i$ , $j$ , $m$ 变量使用常数大小的额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/167. 两数之和 II.md

@@ -76,10 +76,3 @@ public:
 
 - **时间复杂度 $O(N)$ ：** $N$ 为数组 $numbers$ 的长度；双指针共同线性遍历整个数组。
 - **空间复杂度 $O(1)$ ：** 变量 $i$, $j$ 使用常数大小的额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/169. 多数元素.md

@@ -135,10 +135,3 @@ public:
 ```
 
 时间复杂度和空间复杂度都不变，仍为 $O(N)$ 和 $O(1)$ 。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/179. 最大数.md

@@ -212,10 +212,3 @@ private:
 
 - **时间复杂度 $O(N \log N)$ ：** $N$ 为最终返回值的字符数量（ $strs$ 列表的长度 $\leq N$ ）；使用快排或内置函数的平均时间复杂度为 $O(N \log N)$ ，最差为 $O(N^2)$ 。
 - **空间复杂度 $O(N)$ ：** 字符串列表 $strs$ 占用线性大小的额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/1823. 找出游戏的获胜者.md

@@ -119,10 +119,3 @@ public:
 
 - **时间复杂度 $O(n)$ ：** 状态转移循环 $n - 1$ 次使用 $O(n)$ 时间，状态转移方程计算使用 $O(1)$ 时间。
 - **空间复杂度 $O(1)$ ：** 使用常数大小的额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/191. 位1的个数.md

@@ -125,10 +125,3 @@ public:
 
 - **时间复杂度 $O(M)$ ：** $n \& (n - 1)$ 操作仅有减法和与运算，占用 $O(1)$ ；设 $M$ 为二进制数字 $n$ 中 $1$ 的个数，则需循环 $M$ 次（每轮消去一个 $1$ ），占用 $O(M)$ 。
 - **空间复杂度 $O(1)$ ：** 变量 $res$ 使用常数大小额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/205. 同构字符串.md

@@ -81,10 +81,3 @@ public:
 
 - **时间复杂度 $O(N)$ ：** 其中 $N$ 为字符串 `s` , `t` 的长度。遍历字符串 `s` , `t` 使用线性时间，hashmap 查询操作使用 $O(1)$ 时间。
 - **空间复杂度 $O(1)$ ：** 题目说明 `s` 和 `t` 由任意有效的 ASCII 字符组成。由于 ASCII 字符共 128 个，因此 hashmap `s2t` , `t2s` 使用 $O(128) = O(1)$ 空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/206. 反转链表.md

@@ -136,10 +136,3 @@ private:
 
 - **时间复杂度 $O(N)$ ：** 遍历链表使用线性大小时间。
 - **空间复杂度 $O(N)$ ：** 遍历链表的递归深度达到 $N$ ，系统使用 $O(N)$ 大小额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/21. 合并两个有序链表.md

@@ -86,10 +86,3 @@ public:
 
 - **时间复杂度 $O(M+N)$ ：** $M, N$ 分别为链表 $l_1$, $l_2$ 的长度，合并操作需遍历两链表。
 - **空间复杂度 $O(1)$ ：** 节点引用 $dum$ , $cur$ 使用常数大小的额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/215. 数组中的第K个最大元素.md

@@ -181,10 +181,3 @@ private:
 
 - **时间复杂度 $O(N)$ ：** 其中 $N$ 为数组元素数量；对于长度为 $N$ 的数组执行哨兵划分操作的时间复杂度为 $O(N)$ ；每轮哨兵划分后根据 $k$ 和 $i$ 的大小关系选择递归，由于 $i$ 分布的随机性，则向下递归子数组的平均长度为 $\frac{N}{2}$ ；因此平均情况下，哨兵划分操作一共有 $N + \frac{N}{2} + \frac{N}{4} + ... + \frac{N}{N} = \frac{N - \frac{1}{2}}{1 - \frac{1}{2}} = 2N - 1$ （等比数列求和），即总体时间复杂度为 $O(N)$ 。
 - **空间复杂度 $O(\log N)$ ：** 划分函数的平均递归深度为 $O(\log N)$ 。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/226. 翻转二叉树.md

@@ -151,10 +151,3 @@ public:
 - **空间复杂度 $O(N)$ ：** 如下图所示，最差情况下，栈 $stack$ 最多同时存储 $\frac{N + 1}{2}$ 个节点，占用 $O(N)$ 额外空间。
 
 ![Picture0.png](https://pic.leetcode-cn.com/1614450330-bTAcyj-Picture0.png){:width=450}
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/230. 二叉搜索树中第K小的元素.md

@@ -75,10 +75,3 @@ private:
 
 - **时间复杂度 $O(N)$ ：** 当树退化为链表，即全部为左子节点时，无论 $k$ 的值大小，递归深度都为 $N$ ，使用 $O(N)$ 时间。
 - **空间复杂度 $O(N)$ ：**  当树退化为链表时，系统使用 $O(N)$ 大小的栈空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/232. 用栈实现队列.md

@@ -126,10 +126,3 @@ public:
 
 - **时间复杂度：** `push()`, `empty()` 函数的时间复杂度为 $O(1)$ ；`peek()` , `pop()` 函数在 $N$ 次队首元素删除操作中总共需完成 $N$ 个元素的倒序，均摊时间复杂度为 $O(1)$ 。
 - **空间复杂度 $O(N)$ ：** 最差情况下，栈 `A` 和 `B` 共保存 $N$ 个元素。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/233. 数字 1 的个数.md

@@ -159,10 +159,3 @@ public:
 
 - **时间复杂度 $O(\log n)$ ：** 循环内的计算操作使用 $O(1)$ 时间；循环次数为数字 $n$ 的位数，即 $\log_{10}{n}$ ，因此循环使用 $O(\log n)$ 时间。
 - **空间复杂度 $O(1)$ ：** 几个变量使用常数大小的额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/235. 二叉搜索树的最近公共祖先.md

@@ -181,10 +181,3 @@ public:
 
 - **时间复杂度 $O(N)$ ：** 其中 $N$ 为二叉树节点数；每循环一轮排除一层，二叉搜索树的层数最小为 $\log N$ （满二叉树），最大为 $N$ （退化为链表）。
 - **空间复杂度 $O(N)$ ：** 最差情况下，即树退化为链表时，递归深度达到树的层数 $N$ 。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/237. 删除链表中的节点.md

@@ -82,10 +82,3 @@ public:
 **时间复杂度 $O(1)$ ：** 使用常数时间。
 
 **空间复杂度 $O(1)$ ：** 使用常数大小额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/238. 除自身以外数组的乘积.md

@@ -76,10 +76,3 @@ public:
 
 - **时间复杂度 $O(N)$ ：** 其中 $N$ 为数组长度，两轮遍历数组 $nums$ ，使用 $O(N)$ 时间。
 - **空间复杂度 $O(1)$ ：** 变量 $tmp$ 使用常数大小额外空间（数组 $ans$ 作为返回值，不计入复杂度考虑）。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/239. 滑动窗口最大值.md

@@ -224,10 +224,3 @@ public:
 
 - **时间复杂度 $O(N^2)$ ：** 其中 $N$ 为输入矩阵的行（列）数。需要将矩阵中每个元素旋转到新的位置，即对矩阵所有元素操作一次，使用 $O(N^2)$ 时间。 
 - **空间复杂度 $O(1)$ ：** 临时变量 $tmp$ 使用常数大小的额外空间。值得注意，当循环中进入下轮迭代，上轮迭代初始化的 $tmp$ 占用的内存就会被自动释放，因此无累计使用空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/240. 搜索二维矩阵 II.md

@@ -71,10 +71,3 @@ public:
 
 - 时间复杂度 $O(M+N)$ ：其中，$N$ 和 $M$ 分别为矩阵行数和列数，此算法最多循环 $M+N$ 次。
 - 空间复杂度 $O(1)$ : `i`, `j` 指针使用常数大小额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/242. 有效的字母异位词.md

@@ -169,10 +169,3 @@ public:
 **时间复杂度 $O(M + N)$ ：** 其 $M$ , $N$ 分别为字符串 $s_1$ , $s_2$ 长度。当 $s_1$ , $s_2$ 无相同字符时，三轮循环的总迭代次数最多为 $2M + 2N$ ，使用 $O(M + N)$ 线性时间。
 
 **空间复杂度 $O(1)$ ：** 由于字符种类是有限的（常量），一般 ASCII 码共包含 128 个字符，因此可假设使用 $O(1)$ 大小的额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/264. 丑数 II .md

@@ -80,10 +80,3 @@ public:
 
 - **时间复杂度 $O(n)$ ：** 计算 $res$ 列表需遍历 $n-1$ 轮。
 - **空间复杂度 $O(n)$ ：** 长度为 $n$ 的 $res$ 列表使用 $O(n)$ 的额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/266. 回文排列.md

@@ -149,10 +149,3 @@ public:
 **时间复杂度 $O(N)$ ：** 其中 $N$ 为字符串长度；哈希表统计字符数量迭代 $N$ 次，判断是否为回文串最多迭代 $N$ 次，总体使用 $O(N + N) = O(N)$ 时间。
 
 **空间复杂度 $O(N)$ ：** 哈希表 `dic` 使用 $O(N)$ 大小的额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/278. 第一个错误的版本.md

@@ -68,10 +68,3 @@ public:
 
 - **时间复杂度 $O(\log n)$ ：** 其中 $n$ 为版本数；二分查找使用对数级别时间。
 - **空间复杂度 $O(1)$ ：** 变量 $i$ , $j$ 使用常数大小空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/287. 寻找重复数.md

@@ -1,3 +1,10 @@
+## 解题思路：
+
+本文介绍三种时间复杂度为 $O(N)$ 的解法，其中只有方法三完全满足题目要求，其中：
+
+- 方法一使用了哈希表额外空间；
+- 方法二需要修改原数组 `nums` ；
+
 ## 方法一：哈希表
 
 利用数据结构特点，容易想到使用哈希表（Set）记录数组的各个数字，当查找到重复数字则直接返回。
@@ -137,9 +144,94 @@ public:
 - **时间复杂度 $O(N)$ ：** 遍历数组使用 $O(N)$ ，每轮遍历的判断和交换操作使用 $O(1)$ 。
 - **空间复杂度 $O(1)$ ：** 使用常数复杂度的额外空间。
 
----
+## 方法三：环形链表
 
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
+根据题意，数组索引和元素的取值范围 $\in [1, n]$ 。我们考虑建立一个 $n$ 个节点的链表：
 
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。
+- $n$ 个节点的值：$1$ , $2$ , $\cdots$ , $n$ ；
+- 对于每个节点 $i$ ，其 `next` 引用指向节点 $nums[i]$ 。
+
+![image.png](https://pic.leetcode.cn/1699101015-eXfiQU-image.png)
+
+假设重复元素为 $x$ ，那么在这个链表中，一定同时有两条边指向节点 $x$  。例如在上图中，有两条边都指向节点 $2$ 。因此可得到推论：**此链表中一定存在环，且节点 $x$ 是环的入口**。
+
+换句话说，**找出重复元素 $x$ 等价于找出链表中环的入口**。这个问题实际上就是[环形链表 II](https://leetcode.cn/problems/linked-list-cycle-ii/description/)，唯一的不同点在于我们需要在数组中进行链表操作。
+
+### 代码：
+
+```Python []
+class Solution:
+    def findDuplicate(self, nums: List[int]) -> int:
+        def next(i):
+            return nums[i]
+        slow = fast = 0
+        # 第一次相遇
+        while True:
+            slow = next(slow)
+            fast = next(next(fast))
+            if slow == fast:
+                break
+        slow = 0
+        # 第二次相遇
+        while slow != fast:
+            slow = next(slow)
+            fast = next(fast)
+        return slow
+```
+
+```Java []
+public class Solution {
+    private int next(int[] nums, int index) {
+        return nums[index];
+    }
+    public int findDuplicate(int[] nums) {
+        int slow = 0;
+        int fast = 0;
+        // 第一次相遇
+        do {
+            slow = next(nums, slow);
+            fast = next(nums, next(nums, fast));
+        } while (slow != fast);
+        slow = 0;
+        // 第二次相遇
+        while (slow != fast) {
+            slow = next(nums, slow);
+            fast = next(nums, fast);
+        }
+        return slow;
+    }
+}
+```
+
+```C++ []
+class Solution {
+public:
+    vector<int> nums;
+    int next(int index) {
+        // 直接返回当前索引处的值作为下一个索引
+        return nums[index];
+    }
+    int findDuplicate(vector<int>& nums) {
+        this->nums = nums;
+        int slow = 0;
+        int fast = 0;
+        // 第一次相遇
+        do {
+            slow = next(slow);
+            fast = next(next(fast));
+        } while (slow != fast);
+        slow = 0;
+        // 第二次相遇
+        while (slow != fast) {
+            slow = next(slow);
+            fast = next(fast);
+        }
+        return slow;
+    }
+};
+```
+
+### 复杂度分析：
+
+- **时间复杂度 $O(N)$ ：** 遍历链表使用 $O(N)$ 。
+- **空间复杂度 $O(1)$ ：** 使用常数复杂度的额外空间。

selected_coding_interview/docs/295. 数据流的中位数.md

@@ -132,10 +132,3 @@ class MedianFinder:
   - **查找中位数 $O(1)$ ：** 获取堆顶元素使用 $O(1)$ 时间。
   - **添加数字 $O(\log N)$ ：** 堆的插入和弹出操作使用 $O(\log N)$ 时间。  
 - **空间复杂度 $O(N)$ ：** 其中 $N$ 为数据流中的元素数量，小顶堆 $A$ 和大顶堆 $B$ 最多同时保存 $N$ 个元素。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/297. 二叉树的序列化与反序列化.md

@@ -155,10 +155,3 @@ public class Codec {
 
 - **时间复杂度 $O(N)$ ：** $N$ 为二叉树的节点数，按层构建二叉树需要遍历整个 $vals$ ，其长度最大为 $2N+1$ 。
 - **空间复杂度 $O(N)$ ：** 最差情况下，队列 `queue` 同时存储 $\frac{N + 1}{2}$ 个节点，因此使用 $O(N)$ 额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/3. 无重复字符的最长子串.md

@@ -165,10 +165,3 @@ public:
 
 - **时间复杂度 $O(N)$ ：** 其中 $N$ 为字符串长度，动态规划需遍历计算 $dp$ 列表。
 - **空间复杂度 $O(1)$ ：** 字符的 ASCII 码范围为 $0$ ~ $127$ ，哈希表 $dic$ 最多使用 $O(128) = O(1)$ 大小的额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/371. 两整数之和.md

@@ -101,10 +101,3 @@ print(hex(-1 & 0xffffffff)) # = 0xffffffff 负数补码
 
 print(-1 & 0xffffffff) # = 4294967295 （ Python 将其认为正数）
 ```
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/387. 字符串中的第一个唯一字符.md

@@ -64,10 +64,3 @@ public:
 
 - **时间复杂度 $O(N)$ ：** $N$ 为字符串 `s` 的长度；需遍历 `s` 两轮，使用 $O(N)$ ；HashMap 查找操作的复杂度为 $O(1)$ 。
 - **空间复杂度 $O(1)$ ：** 由于题目指出 `s`  只包含小写字母，因此最多有 26 个不同字符，HashMap 存储需占用 $O(26) = O(1)$ 的额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/39. 组合总和.md

@@ -152,10 +152,3 @@ class Solution:
 如下图所示，为将数组 $[3, 4, 5]$ 和目标元素 $9$ 输入到以上代码后的整体回溯过程。
 
 ![subset_sum_i.png](https://pic.leetcode.cn/1690624990-TxtFOY-subset_sum_i.png)
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/392. 判断子序列.md

@@ -67,10 +67,3 @@ public:
 
 - **时间复杂度 $O(N)$ ：** 其中 $N$ 为字符串 `t` 的长度。最差情况下需完整遍历 `t` 。
 - **空间复杂度 $O(1)$ ：** `i` , `j` 变量使用常数大小空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/40. 组合总和 II.md

@@ -139,10 +139,3 @@ private:
 下图展示了数组 $[4, 4, 5]$ 和目标元素 $9$ 的回溯过程，共包含四种剪枝操作。请你将图示与代码注释相结合，理解整个搜索过程，以及每种剪枝操作是如何工作的。
 
 ![subset_sum_ii.png](https://pic.leetcode.cn/1690625346-mkEVHR-subset_sum_ii.png)
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/400. 第 N 位数字.md

@@ -167,10 +167,3 @@ public:
 
 - **时间复杂度 $O(\log n)$ ：** 所求数位 $n$ 对应数字 $num$ 的位数 $digit$ 最大为 $O(\log n)$ ；第一步最多循环 $O(\log n)$ 次；第三步中将 $num$ 转化为字符串使用 $O(\log n)$ 时间；因此总体为 $O(\log n)$ 。
 - **空间复杂度 $O(\log n)$ ：** 将数字 $num$ 转化为字符串 `str(num)` ，占用 $O(\log n)$ 的额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/409. 最长回文串.md

@@ -84,10 +84,3 @@ public:
 
 - **时间复杂度 $O(N)$ ：** 其中 $N$ 为字符串 `s` 长度。遍历字符串 `s` 和哈希表  `counter` 皆使用线性时间。
 - **空间复杂度 $O(1)$ ：** 由于 ASCII 字符数量为 128 ，哈希表 `counter` 最多使用 $O(128) = O(1)$ 空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/426. 将二叉搜索树转化为排序的双向链表.md

@@ -140,10 +140,3 @@ private:
 
 - **时间复杂度 $O(N)$ ：** $N$ 为二叉树的节点数，中序遍历需要访问所有节点。
 - **空间复杂度 $O(N)$ ：** 最差情况下，即树退化为链表时，递归深度达到 $N$，系统使用 $O(N)$ 栈空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/46. 全排列.md

@@ -106,10 +106,3 @@ private:
 
 - **时间复杂度 $O(N!N)$ ：** $N$ 为数组 `nums` 的长度；时间复杂度和数组排列的方案数成线性关系，方案数为 $N \times (N-1) \times (N-2) … \times 2 \times 1$ ，即复杂度为 $O(N!)$ ；数组拼接操作 `join()` 使用 $O(N)$ ；因此总体时间复杂度为 $O(N!N)$ 。
 - **空间复杂度 $O(N)$ ：** 全排列的递归深度为 $N$ ，系统累计使用栈空间大小为 $O(N)$ 。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/47. 全排列 II.md

@@ -115,10 +115,3 @@ private:
 
 - **时间复杂度 $O(N!N)$ ：** 与上一题相同 。
 - **空间复杂度 $O(N^2)$ ：** 递归中辅助 Set 累计存储的元素数量最多为 $N + (N-1) + ... + 2 + 1 = (N+1)N/2$ ，因此占用 $O(N^2)$ 的额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/48. 旋转图像.md

@@ -224,10 +224,3 @@ public:
 
 - **时间复杂度 $O(N^2)$ ：** 其中 $N$ 为输入矩阵的行（列）数。需要将矩阵中每个元素旋转到新的位置，即对矩阵所有元素操作一次，使用 $O(N^2)$ 时间。
 - **空间复杂度 $O(1)$ ：** 临时变量 $tmp$ 使用常数大小的额外空间。值得注意，当循环中进入下轮迭代，上轮迭代初始化的 $tmp$ 占用的内存就会被自动释放，因此无累计使用空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/509. 斐波那契数.md

@@ -74,10 +74,3 @@ public:
 
 - **时间复杂度 $O(n)$ ：** 计算 $f(n)$ 需循环 $n$ 次，每轮循环内计算操作使用 $O(1)$ 。
 - **空间复杂度 $O(1)$ ：** 几个标志变量使用常数大小的额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/53. 最大子数组和.md

@@ -77,10 +77,3 @@ public:
 
 - **时间复杂度 $O(N)$ ：** 线性遍历数组 $nums$ 即可获得结果，使用 $O(N)$ 时间。
 - **空间复杂度 $O(1)$ ：** 使用常数大小的额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/54. 螺旋矩阵.md

@@ -103,10 +103,3 @@ public:
 
 - **时间复杂度 $O(MN)$ ：** $M, N$ 分别为矩阵行数和列数。
 - **空间复杂度 $O(1)$ ：** 四个边界 `l` , `r` , `t` , `b` 使用常数大小的额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/65. 有效数字.md

@@ -137,10 +137,3 @@ public:
 
 - **时间复杂度 $O(N)$ ：** 其中 $N$ 为字符串 `s` 的长度，判断需遍历字符串，每轮状态转移的使用 $O(1)$ 时间。
 - **空间复杂度 $O(1)$ ：** `states` 和 `p` 使用常数大小的额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/70. 爬楼梯.md

@@ -69,10 +69,3 @@ public:
 
 - **时间复杂度 $O(n)$ ：** 计算 $f(n)$ 需循环 $n$ 次，每轮循环内计算操作使用 $O(1)$ 。
 - **空间复杂度 $O(1)$ ：** 几个标志变量使用常数大小的额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/704. 二分查找.md

@@ -77,10 +77,3 @@ public:
 
 - **时间复杂度 $O(\log N)$ ：** 其中 $N$ 为数组 $nums$ 长度。二分查找使用对数级别时间。
 - **空间复杂度 $O(1)$ ：** 变量 $i$ , $j$ 使用常数大小空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/724. 寻找数组的中心下标.md

@@ -74,10 +74,3 @@ public:
 
 - **时间复杂度 $O(N)$ ：** 其中 $N$ 为数组 `nums` 长度。求和操作使用 $O(N)$ 线性时间，遍历 `nums` 最差使用 $O(N)$ 线性时间。
 - **空间复杂度 $O(1)$ ：** 变量 `sum_left` , `sum_right` 使用常数大小空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/79. 单词搜索.md

@@ -99,10 +99,3 @@ private:
 - **时间复杂度 $O(3^KMN)$ ：** 最差情况下，需要遍历矩阵中长度为 $K$ 字符串的所有方案，时间复杂度为 $O(3^K)$；矩阵中共有 $MN$ 个起点，时间复杂度为 $O(MN)$ 。
   - **方案数计算：** 设字符串长度为 $K$ ，搜索中每个字符有上、下、左、右四个方向可以选择，舍弃回头（上个字符）的方向，剩下 $3$ 种选择，因此方案数的复杂度为 $O(3^K)$ 。
 - **空间复杂度 $O(K)$ ：** 搜索过程中的递归深度不超过 $K$ ，因此系统因函数调用累计使用的栈空间占用 $O(K)$ （因为函数返回后，系统调用的[栈空间会释放](https://leetcode-cn.com/explore/orignial/card/recursion-i/259/complexity-analysis/1223/)）。最坏情况下 $K = MN$ ，递归深度为 $MN$ ，此时系统栈使用 $O(MN)$ 的额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/796. 旋转字符串.md

@@ -52,10 +52,3 @@ public:
 > 本文直接调用编程语言的库函数，时间复杂度由库函数的具体实现方法确定。
 
 **空间复杂度 $O(N)$ ：** 构造拼接字符串 $goal \ goal$ 使用 $O(N)$ 大小的额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/8. 字符串转换整数 (atoi).md

@@ -141,10 +141,3 @@ public:
     }
 };
 ```
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/86. 分隔链表.md

@@ -165,10 +165,3 @@ public:
 **时间复杂度 $O(N)$ ：** 其中 $N$ 为链表长度；遍历链表使用线性时间。
 
 **空间复杂度 $O(1)$ ：** 假头节点使用常数大小的额外空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/876. 链表的中间结点.md

@@ -58,10 +58,3 @@ public:
 
 - **时间复杂度 $O(N)$ ：** 其中 $N$ 为链表长度。 `fast` 遍历完链表需 $\frac{N}{2}$ 轮迭代，使用 $O(\frac{N}{2}) = O(N)$ 线性时间。
 - **空间复杂度 $O(1)$ ：** 节点指针  `fast` , `slow` 使用常数大小空间。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。

selected_coding_interview/docs/946. 验证栈序列.md

@@ -80,10 +80,3 @@ public:
 
 - **时间复杂度 $O(N)$ ：** 其中 $N$ 为列表 $pushed$ 的长度；每个元素最多入栈与出栈一次，即最多共 $2N$ 次出入栈操作。
 - **空间复杂度 $O(N)$ ：** 辅助栈 $stack$ 最多同时存储 $N$ 个元素。
-
----
-
-**本学习计划的配套代码请见「[代码仓](https://github.com/krahets/selected-coding-interview)」，包括：**
-
-- 代码与测试样例，方便 VSCode 本地运行与调试代码。
-- 数据结构封装，提升刷题与 Debug 效率。