修复格式问题

itcharge · itcharge · commit f25ca376dc3e · 2025-10-17T14:04:59.000+08:00
diff --git a/docs/solutions/0001-0099/container-with-most-water.md b/docs/solutions/0001-0099/container-with-most-water.md
@@ -28,7 +28,7 @@
 ```python
 输入：[1,8,6,2,5,4,8,3,7]
 输出：49 
-解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
+解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
 ```
 
 ## 解题思路
diff --git a/docs/solutions/0001-0099/jump-game-ii.md b/docs/solutions/0001-0099/jump-game-ii.md
@@ -25,7 +25,7 @@
 ```python
 输入：nums = [2,3,1,1,4]
 输出：2
-解释：跳到最后一个位置的最小跳跃数是 2。从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。
+解释：跳到最后一个位置的最小跳跃数是 2。从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。
 ```
 
 ## 解题思路
@@ -42,7 +42,7 @@
 
 ###### 3. 状态转移方程
 
-对于当前位置 `i`，如果之前的位置 `j`（$o \le j < i$） 能够跳到位置 `i` 需要满足：位置 `j`（$o \le j < i$）加上位置 `j` 所能跳到的最远长度要大于等于 `i`，即 `j + nums[j] >= i` 。
+对于当前位置 `i`，如果之前的位置 `j`（$o \le j < i$） 能够跳到位置 `i` 需要满足：位置 `j`（$o \le j < i$）加上位置 `j` 所能跳到的最远长度要大于等于 `i`，即 `j + nums[j] >= i` 。
 
 而跳到下标 `i` 所需要的最小跳跃次数则等于满足上述要求的位置 `j` 中最小跳跃次数加 `1`，即 `dp[i] = min(dp[i], dp[j] + 1)`。
 
diff --git a/docs/solutions/0001-0099/permutation-sequence.md b/docs/solutions/0001-0099/permutation-sequence.md
@@ -13,7 +13,7 @@
 
 给出集合 $[1,2,3,...,n]$，其所有元素共有 $n!$ 种排列。
 
-按大小顺序列出所有排列情况，并一一标记，当 $n = 3$ 时, 所有排列如下：
+按大小顺序列出所有排列情况，并一一标记，当 $n = 3$ 时, 所有排列如下：
 
 1. `"123"`
 2. `"132"`
@@ -22,11 +22,11 @@
 5. `"312"`
 6. `"321"`
 
-给定 $n$ 和 $k$。
+给定 $n$ 和 $k$。
 
 **要求**：
 
-返回第 $k$ 个排列。
+返回第 $k$ 个排列。
 
 **说明**：
 
diff --git a/docs/solutions/0001-0099/recover-binary-search-tree.md b/docs/solutions/0001-0099/recover-binary-search-tree.md
@@ -22,7 +22,7 @@
 - 树上节点的数目在范围 $[2, 1000]$ 内。
 - $-2^{31} \le Node.val \le 2^{31} - 1$。
 
-- 进阶：使用 $O(n)$ 空间复杂度的解法很容易实现。你能想出一个只使用 $O(1)$ 空间的解决方案吗？
+- 进阶：使用 $O(n)$ 空间复杂度的解法很容易实现。你能想出一个只使用 $O(1)$ 空间的解决方案吗？
 
 **示例**：
 
diff --git a/docs/solutions/0001-0099/remove-duplicates-from-sorted-array-ii.md b/docs/solutions/0001-0099/remove-duplicates-from-sorted-array-ii.md
@@ -26,15 +26,15 @@
 ```python
 输入：nums = [1,1,1,2,2,3]
 输出：5, nums = [1,1,2,2,3]
-解释：函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3 。 不需要考虑数组中超出新长度后面的元素。
+解释：函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3。 不需要考虑数组中超出新长度后面的元素。
 ```
 
 - 示例 2：
 
 ```python
 输入：nums = [0,0,1,1,1,1,2,3,3]
 输出：7, nums = [0,0,1,1,2,3,3]
-解释：函数应返回新长度 length = 7, 并且原数组的前五个元素被修改为 0, 0, 1, 1, 2, 3, 3 。 不需要考虑数组中超出新长度后面的元素。
+解释：函数应返回新长度 length = 7, 并且原数组的前五个元素被修改为 0, 0, 1, 1, 2, 3, 3。 不需要考虑数组中超出新长度后面的元素。
 ```
 
 ## 解题思路
diff --git a/docs/solutions/0001-0099/scramble-string.md b/docs/solutions/0001-0099/scramble-string.md
@@ -19,11 +19,11 @@
    - 随机决定是要「交换两个子字符串」还是要「保持这两个子字符串的顺序不变」。即，在执行这一步骤之后，$s$ 可能是 $s = x + y$ 或者 $s = y + x$。
    - 在 $x$ 和 $y$ 这两个子字符串上继续从步骤 $1$ 开始递归执行此算法。
 
-给定两个长度相等的字符串 $s1$ 和 $s2$。
+给定两个长度相等的字符串 $s1$ 和 $s2$。
 
 **要求**：
 
-判断 $s2$ 是否是 $s1$ 的扰乱字符串。如果是，返回 $true$；否则，返回 $false$。
+判断 $s2$ 是否是 $s1$ 的扰乱字符串。如果是，返回 $true$；否则，返回 $false$。
 
 **说明**：
 
diff --git a/docs/solutions/0001-0099/simplify-path.md b/docs/solutions/0001-0099/simplify-path.md
@@ -13,10 +13,10 @@
 
 在 Unix 风格的文件系统中规则如下：
 
-- 一个点 `'.'` 表示当前目录本身。
-- 此外，两个点 `'..'` 表示将目录切换到上一级（指向父目录）。
-- 任意多个连续的斜杠（即，`'//'` 或 `'///'`）都被视为单个斜杠 `'/'`。
-- 任何其他格式的点（例如，`'...'` 或 `'....'`）均被视为有效的文件 / 目录名称。
+- 一个点 `'.'` 表示当前目录本身。
+- 此外，两个点 `'..'` 表示将目录切换到上一级（指向父目录）。
+- 任意多个连续的斜杠（即，`'//'` 或 `'///'`）都被视为单个斜杠 `'/'`。
+- 任何其他格式的点（例如，`'...'` 或 `'....'`）均被视为有效的文件 / 目录名称。
 
 给定一个字符串 $path$，表示指向某一文件或目录的 Unix 风格绝对路径 （以 `'/'` 开头），
 
diff --git a/docs/solutions/0001-0099/substring-with-concatenation-of-all-words.md b/docs/solutions/0001-0099/substring-with-concatenation-of-all-words.md
@@ -13,19 +13,19 @@
 
 给定一个字符串 $s$ 和一个字符串数组 $words$。$words$ 中所有字符串长度相同。
 
-$s$ 中的「串联子串」是指一个包含 $words$ 中所有字符串以任意顺序排列连接起来的子串。
-- 例如，如果 $words = ["ab","cd","ef"]$， 那么 `"abcdef"`， `"abefcd"`，`"cdabef"`， `"cdefab"`，`"efabcd"` 和 `"efcdab"` 都是串联子串。 `"acdbef"` 不是串联子串，因为他不是任何 $words$ 排列的连接。
+$s$ 中的「串联子串」是指一个包含 $words$ 中所有字符串以任意顺序排列连接起来的子串。
+- 例如，如果 $words = ["ab","cd","ef"]$， 那么 `"abcdef"`， `"abefcd"`，`"cdabef"`， `"cdefab"`，`"efabcd"` 和 `"efcdab"` 都是串联子串。 `"acdbef"` 不是串联子串，因为他不是任何 $words$ 排列的连接。
 
 **要求**：
 
-返回所有串联子串在 $s$ 中的开始索引。你可以以任意顺序返回答案。
+返回所有串联子串在 $s$ 中的开始索引。你可以以任意顺序返回答案。
 
 **说明**：
 
 - $1 \le s.length \le 10^4$。
 - $1 \le words.length \le 5000$。
 - $1 <= words[i].length <= 30$。
-- $words[i]$ 和 $s$ 由小写英文字母组成。
+- $words[i]$ 和 $s$ 由小写英文字母组成。
 
 **示例**：
 
diff --git a/docs/solutions/0001-0099/valid-number.md b/docs/solutions/0001-0099/valid-number.md
@@ -18,11 +18,11 @@
 
 关于「整数」、「十进制数」、「指数」、「数字」的定义：
 
-- 一个「整数」定义为一个 「可选符号」 `'-'` 或 `'+'` 后面跟着「数字」。
-- 一个「十进制数」定义为一个「可选符号」 `'-'` 或 `'+'` 后面跟着下述规则：
-   1. 「数字」后跟着一个 小数点 `.`。
-   2. 「数字」后跟着一个 小数点 `.` 再跟着「数位」。
-   3. 一个「小数点」 `.` 后跟着「数位」。
+- 一个「整数」定义为一个 「可选符号」 `'-'` 或 `'+'` 后面跟着「数字」。
+- 一个「十进制数」定义为一个「可选符号」 `'-'` 或 `'+'` 后面跟着下述规则：
+   1. 「数字」后跟着一个 小数点 `.`。
+   2. 「数字」后跟着一个 小数点 `.` 再跟着「数位」。
+   3. 一个「小数点」 `.` 后跟着「数位」。
 - 「指数」定义为指数符号 `'e'` 或 `'E'`，后面跟着一个 整数。
 - 「数字」定义为一个或多个数位。
 
diff --git a/docs/solutions/0100-0199/compare-version-numbers.md b/docs/solutions/0100-0199/compare-version-numbers.md
@@ -11,17 +11,17 @@
 
 **描述**：
 
-给定两个版本号字符串 $version1$ 和 $version2$。
+给定两个版本号字符串 $version1$ 和 $version2$。
 
 **要求**：
 
-请你比较它们。版本号由被点 `'.'` 分开的修订号组成。修订号的值是它转换为整数并忽略前导零。
+请你比较它们。版本号由被点 `'.'` 分开的修订号组成。修订号的值是它转换为整数并忽略前导零。
 比较版本号时，请按从左到右的顺序 依次比较它们的修订号。如果其中一个版本字符串的修订号较少，则将缺失的修订号视为 $0$。
 
 返回规则如下：
 
-- 如果 $version1 < version2$ 返回 $-1$。
-- 如果 $version1 > version2$ 返回 $1$。
+- 如果 $version1 < version2$ 返回 $-1$。
+- 如果 $version1 > version2$ 返回 $1$。
 - 除此之外返回 $0$。
 
 **说明**：
@@ -38,7 +38,7 @@
 ```python
 输入：version1 = "1.2", version2 = "1.10"
 输出：-1
-解释：version1 的第二个修订号为 "2"，version2 的第二个修订号为 "10"：2 < 10，所以 version1 < version2。
+解释：version1 的第二个修订号为 "2"，version2 的第二个修订号为 "10"：2 < 10，所以 version1 < version2。
 ```
 
 - 示例 2：
diff --git a/docs/solutions/0100-0199/convert-sorted-list-to-binary-search-tree.md b/docs/solutions/0100-0199/convert-sorted-list-to-binary-search-tree.md
@@ -19,8 +19,8 @@
 
 **说明**：
 
-- $head$ 中的节点数在 $[0, 2 \times 10^{4}]$ 范围内。
-- $-10^{5} \le Node.val \le 10^{5}$。
+- $head$ 中的节点数在 $[0, 2 \times 10^{4}]$ 范围内。
+- $-10^{5} \le Node.val \le 10^{5}$。
 
 **示例**：
 
diff --git a/docs/solutions/0100-0199/dungeon-game.md b/docs/solutions/0100-0199/dungeon-game.md
@@ -11,7 +11,7 @@
 
 **描述**：
 
-恶魔们抓住了公主并将她关在了地下城 $dungeon$ 的右下角。地下城是由 $m \times n$ 个房间组成的二维网格。我们英勇的骑士最初被安置在「左上角」的房间里，他必须穿过地下城并通过对抗恶魔来拯救公主。
+恶魔们抓住了公主并将她关在了地下城 $dungeon$ 的右下角。地下城是由 $m \times n$ 个房间组成的二维网格。我们英勇的骑士最初被安置在「左上角」的房间里，他必须穿过地下城并通过对抗恶魔来拯救公主。
 
 骑士的初始健康点数为一个正整数。如果他的健康点数在某一时刻降至 $0$ 或以下，他会立即死亡。
 
diff --git a/docs/solutions/0100-0199/missing-ranges.md b/docs/solutions/0100-0199/missing-ranges.md
@@ -11,8 +11,8 @@
 
 **描述**：
 
-给定一个闭区间 $[lower, upper]$ 和一个按从小到大排序的整数数组 $nums$ ，其中元素的范围在闭区间 $[lower, upper]$ 当中。
-如果一个数字 $x$ 在 $[lower, upper]$ 区间内，并且 $x$ 不在 $nums$ 中，则认为 $x$ 缺失。
+给定一个闭区间 $[lower, upper]$ 和一个按从小到大排序的整数数组 $nums$ ，其中元素的范围在闭区间 $[lower, upper]$ 当中。
+如果一个数字 $x$ 在 $[lower, upper]$ 区间内，并且 $x$ 不在 $nums$ 中，则认为 $x$ 缺失。
 
 **要求**：
 
@@ -44,7 +44,7 @@
 ```python
 输入： nums = [-1], lower = -1, upper = -1
 输出： []
-解释： 没有缺失的区间，因为没有缺失的数字。
+解释： 没有缺失的区间，因为没有缺失的数字。
 ```
 
 ## 解题思路
diff --git a/docs/solutions/0100-0199/one-edit-distance.md b/docs/solutions/0100-0199/one-edit-distance.md
@@ -11,22 +11,22 @@
 
 **描述**：
 
-给定两个字符串 $s$ 和 $t$。
+给定两个字符串 $s$ 和 $t$。
 
 **要求**：
 
 如果它们的编辑距离为 $1$，则返回 $true$，否则返回 $false$。
 
 字符串 $s$ 和字符串 $t$ 之间满足编辑距离等于 $1$ 有三种可能的情形：
 
-- 往 $s$ 中插入「恰好一个」字符得到 $t$。
-- 从 $s$ 中删除「恰好一个」字符得到 $t$。
-- 在 $s$ 中用「一个不同的字符」替换「恰好一个」字符得到 $t$。
+- 往 $s$ 中插入「恰好一个」字符得到 $t$。
+- 从 $s$ 中删除「恰好一个」字符得到 $t$。
+- 在 $s$ 中用「一个不同的字符」替换「恰好一个」字符得到 $t$。
 
 **说明**：
 
 - $0 \le s.length, t.length \le 10^{4}$。
-- $s$ 和 $t$ 由小写字母，大写字母和数字组成。
+- $s$ 和 $t$ 由小写字母，大写字母和数字组成。
 
 **示例**：
 
@@ -35,7 +35,7 @@
 ```python
 输入: s = "ab", t = "acb"
 输出: true
-解释: 可以将 'c' 插入字符串 s 来得到 t。
+解释: 可以将 'c' 插入字符串 s 来得到 t。
 ```
 
 - 示例 2：
diff --git a/docs/solutions/0100-0199/palindrome-partitioning-ii.md b/docs/solutions/0100-0199/palindrome-partitioning-ii.md
@@ -32,7 +32,7 @@
 ```python
 输入：s = "aab"
 输出：1
-解释：只需一次分割就可将 s 分割成 ["aa","b"] 这样两个回文子串。
+解释：只需一次分割就可将 s 分割成 ["aa","b"] 这样两个回文子串。
 ```
 
 - 示例 2：
diff --git a/docs/solutions/0100-0199/repeated-dna-sequences.md b/docs/solutions/0100-0199/repeated-dna-sequences.md
@@ -11,23 +11,23 @@
 
 **描述**：
 
-DNA 序列由一系列核苷酸组成，缩写为 `'A'`, `'C'`, `'G'` 和 `'T'`。
-* 例如，`"ACGAATTCCG"` 是一个 DNA 序列。
+DNA 序列由一系列核苷酸组成，缩写为 `'A'`, `'C'`, `'G'` 和 `'T'`。
+* 例如，`"ACGAATTCCG"` 是一个 DNA 序列。
 
 在研究 DNA 时，识别 DNA 中的重复序列非常有用。
 
 给定一个表示「DNA 序列」的字符串 $s$。
 
 **要求**：
 
-返回所有在 DNA 分子中出现不止一次的「长度为 $10$」的序列(子字符串)。
+返回所有在 DNA 分子中出现不止一次的「长度为 $10$」的序列(子字符串)。
 
 你可以按「任意顺序」返回答案。
 
 **说明**：
 
 - $0 \le s.length \le 10^{5}$。
-- `s[i]=='A'`、`'C'`、`'G'` or `'T'`。
+- `s[i]=='A'`、`'C'`、`'G'` or `'T'`。
 
 **示例**：
 
diff --git a/docs/solutions/0100-0199/surrounded-regions.md b/docs/solutions/0100-0199/surrounded-regions.md
@@ -29,7 +29,7 @@
 ```python
 输入：board = [["X","X","X","X"],["X","O","O","X"],["X","X","O","X"],["X","O","X","X"]]
 输出：[["X","X","X","X"],["X","X","X","X"],["X","X","X","X"],["X","O","X","X"]]
-解释：被围绕的区间不会存在于边界上，换句话说，任何边界上的 'O' 都不会被填充为 'X'。 任何不在边界上，或不与边界上的 'O' 相连的 'O' 最终都会被填充为 'X'。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。
+解释：被围绕的区间不会存在于边界上，换句话说，任何边界上的 'O' 都不会被填充为 'X'。 任何不在边界上，或不与边界上的 'O' 相连的 'O' 最终都会被填充为 'X'。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。
 ```
 
 - 示例 2：
diff --git a/docs/solutions/0100-0199/triangle.md b/docs/solutions/0100-0199/triangle.md
@@ -34,7 +34,7 @@
   3 4
  6 5 7
 4 1 8 3
-自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。
+自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。
 ```
 
 - 示例 2：
diff --git a/docs/solutions/0100-0199/word-ladder-ii.md b/docs/solutions/0100-0199/word-ladder-ii.md
@@ -15,10 +15,10 @@
 
 **要求**：
 
-按字典 $wordList$ 完成从单词 $beginWord$ 到单词 $endWord$ 转化，一个表示此过程的「转换序列」是形式上像 $beginWord \rightarrow s1 \rightarrow s2 \rightarrow ... \rightarrow sk$ 这样的单词序列，并满足：
+按字典 $wordList$ 完成从单词 $beginWord$ 到单词 $endWord$ 转化，一个表示此过程的「转换序列」是形式上像 $beginWord \rightarrow s1 \rightarrow s2 \rightarrow ... \rightarrow sk$ 这样的单词序列，并满足：
 
 - 每对相邻的单词之间仅有单个字母不同。
-- 转换过程中的每个单词 $si$（$1 \le i \le k$）必须是字典 $wordList$ 中的单词。注意，$beginWord$ 不必是字典 $wordList$ 中的单词。
+- 转换过程中的每个单词 $si$（$1 \le i \le k$）必须是字典 $wordList$ 中的单词。注意，$beginWord$ 不必是字典 $wordList$ 中的单词。
 - $sk == endWord$。
 
 找出并返回所有从 $beginWord$ 到 $endWord$ 的「最短转换序列」，如果不存在这样的转换序列，返回一个空列表。每个序列都应该以单词列表 $[beginWord, s1, s2, ..., sk]$ 的形式返回。
diff --git a/docs/solutions/0200-0299/first-bad-version.md b/docs/solutions/0200-0299/first-bad-version.md
@@ -27,8 +27,8 @@
 输出：4
 解释：
 调用 isBadVersion(3) -> false 
-调用 isBadVersion(5) -> true 
-调用 isBadVersion(4) -> true
+调用 isBadVersion(5) -> true 
+调用 isBadVersion(4) -> true
 所以，4 是第一个错误的版本。
 ```
 
diff --git a/docs/solutions/0200-0299/minimum-size-subarray-sum.md b/docs/solutions/0200-0299/minimum-size-subarray-sum.md
@@ -26,7 +26,7 @@
 ```python
 输入：target = 7, nums = [2,3,1,2,4,3]
 输出：2
-解释：子数组 [4,3] 是该条件下的长度最小的子数组。
+解释：子数组 [4,3] 是该条件下的长度最小的子数组。
 ```
 
 - 示例 2：
diff --git a/docs/solutions/0400-0499/repeated-substring-pattern.md b/docs/solutions/0400-0499/repeated-substring-pattern.md
@@ -47,7 +47,7 @@
   - 如果我们去除字符串中相同的前后缀的重叠部分，剩下两头前后缀部分（这两部分是相同的）。然后再去除剩余的后缀部分，只保留剩余的前缀部分。比如字符串 `"abcabcabc"` 去除重叠部分和剩余的后缀部分之后就是 `"abc"`。实际上这个部分就是字符串去除整个后缀部分的剩余部分。
   - 如果整个字符串可以通过子串重复构成的话，那么这部分就是最小周期的子串。
   - 我们只需要判断整个子串的长度是否是剩余部分长度的整数倍即可。也就是判断 `len(p) % (len(p) - next[size - 1]) == 0` 是否成立，如果成立，则字符串 `s` 可由 `s[0: len(p) - next[size - 1]]` 构成的子串重复构成，返回 `True`。否则返回 `False`。
-- 如果最长相等的前后缀是不重叠的，那我们可将重叠部分视为长度为 `0` 的空串，则剩余的部分其实就是去除后缀部分的剩余部分，上述结论依旧成立。 
+- 如果最长相等的前后缀是不重叠的，那我们可将重叠部分视为长度为 `0` 的空串，则剩余的部分其实就是去除后缀部分的剩余部分，上述结论依旧成立。 
 
 ### 思路 1：代码
 
diff --git a/docs/solutions/0600-0699/design-circular-queue.md b/docs/solutions/0600-0699/design-circular-queue.md
@@ -31,15 +31,15 @@
 
 ```python
 MyCircularQueue circularQueue = new MyCircularQueue(3); // 设置长度为 3
-circularQueue.enQueue(1);  // 返回 true
-circularQueue.enQueue(2);  // 返回 true
-circularQueue.enQueue(3);  // 返回 true
-circularQueue.enQueue(4);  // 返回 false，队列已满
-circularQueue.Rear();  // 返回 3
-circularQueue.isFull();  // 返回 true
-circularQueue.deQueue();  // 返回 true
-circularQueue.enQueue(4);  // 返回 true
-circularQueue.Rear();  // 返回 4
+circularQueue.enQueue(1);  // 返回 true
+circularQueue.enQueue(2);  // 返回 true
+circularQueue.enQueue(3);  // 返回 true
+circularQueue.enQueue(4);  // 返回 false，队列已满
+circularQueue.Rear();  // 返回 3
+circularQueue.isFull();  // 返回 true
+circularQueue.deQueue();  // 返回 true
+circularQueue.enQueue(4);  // 返回 true
+circularQueue.Rear();  // 返回 4
 ```
 
 ## 解题思路
diff --git a/docs/solutions/0700-0799/daily-temperatures.md b/docs/solutions/0700-0799/daily-temperatures.md
@@ -24,14 +24,14 @@
 
 ```python
 输入: temperatures = [73,74,75,71,69,72,76,73]
-输出: [1,1,4,2,1,1,0,0]
+输出: [1,1,4,2,1,1,0,0]
 ```
 
 - 示例 2：
 
 ```python
 输入: temperatures = [30,40,50,60]
-输出: [1,1,1,0]
+输出: [1,1,1,0]
 ```
 
 ## 解题思路
