修正 LaTex 公式

Author: itcharge

docs/01_array/01_04_array_selection_sort.md

@@ -12,7 +12,7 @@
 
 1. **初始状态**：已排序区间为空，未排序区间为 $[0, n - 1]$。
 2. **第 $i$ 趟选择**（$i$ 从 $1$ 开始）：
-   1. 在未排序区间 $[i - 1, n - 1]$ 中找到最小元素的位置 $min\underline{\hspace{0.5em}}i$。
+   1. 在未排序区间 $[i - 1, n - 1]$ 中找到最小元素的位置 $min\_i$。
    2. 将位置 $i - 1$ 的元素与位置 $min\_i$ 的元素交换。
    3. 此时 $[0, i - 1]$ 为已排序区间，$[i, n - 1]$ 为未排序区间。
 3. **重复步骤 2**，直到未排序区间为空，排序完成。

docs/01_array/01_07_array_merge_sort.md

@@ -9,12 +9,12 @@
 假设数组的元素个数为 $n$ 个，则归并排序的算法步骤如下：
 
 1. **分解过程**：递归地将当前数组平分为两部分，直到每个子数组只包含一个元素为止。
-   1. 找到数组的中间位置 $mid$，将数组划分为左、右两个子数组 $left\underline{\hspace{0.5em}}nums$ 和 $right\underline{\hspace{0.5em}}nums$。
-   2. 分别对 $left\underline{\hspace{0.5em}}nums$ 和 $right\underline{\hspace{0.5em}}nums$ 递归执行分解操作。
+   1. 找到数组的中间位置 $mid$，将数组划分为左、右两个子数组 $left\_nums$ 和 $right\_nums$。
+   2. 分别对 $left\_nums$ 和 $right\_nums$ 递归执行分解操作。
    3. 最终将原数组拆分为 $n$ 个长度为 $1$ 的有序子数组。
 2. **归并过程**：从长度为 $1$ 的有序子数组开始，逐步将相邻的有序子数组两两合并，最终合并为一个长度为 $n$ 的有序数组。
    1. 新建数组 $nums$ 用于存放合并后的有序结果。
-   2. 设置两个指针 $left\underline{\hspace{0.5em}}i$ 和 $right\underline{\hspace{0.5em}}i$，分别指向 $left\underline{\hspace{0.5em}}nums$ 和 $right\underline{\hspace{0.5em}}nums$ 的起始位置。
+   2. 设置两个指针 $left\_i$ 和 $right\_i$，分别指向 $left\_nums$ 和 $right\_nums$ 的起始位置。
    3. 比较两个指针所指元素，将较小者加入结果数组 $nums$，并将对应指针后移一位。
    4. 重复上述操作，直到某一指针到达对应子数组末尾。
    5. 将另一个子数组剩余的所有元素依次加入结果数组 $nums$。

docs/01_array/01_15_array_two_pointers.md

@@ -270,10 +270,10 @@ class Solution:
 
 ### 4.1 分离双指针求解步骤
 
-1. 定义两个指针 $left\underline{\hspace{0.5em}}1$ 和 $left\underline{\hspace{0.5em}}2$，分别指向两个数组的起始位置（均为 $0$）。
-2. 根据条件，若需要，两个指针同时右移：$left\underline{\hspace{0.5em}}1 += 1$，$left\underline{\hspace{0.5em}}2 += 1$。
-3. 若只需移动第一个数组指针，则 $left\underline{\hspace{0.5em}}1 += 1$。
-4. 若只需移动第二个数组指针，则 $left\underline{\hspace{0.5em}}2 += 1$。
+1. 定义两个指针 $left\_1$ 和 $left\_2$，分别指向两个数组的起始位置（均为 $0$）。
+2. 根据条件，若需要，两个指针同时右移：$left\_1 += 1$，$left\_2 += 1$。
+3. 若只需移动第一个数组指针，则 $left\_1 += 1$。
+4. 若只需移动第二个数组指针，则 $left\_2 += 1$。
 5. 当任一指针遍历到数组末尾或满足终止条件时，结束循环。
 
 ### 4.2 分离双指针通用模板
@@ -345,14 +345,14 @@ while left_1 < len(nums1) and left_2 < len(nums2):
 ##### 思路 1：分离双指针
 
 1. 先对 $nums1$ 和 $nums2$ 排序。
-2. 用两个指针 $left\underline{\hspace{0.5em}}1$、$left\underline{\hspace{0.
+2. 用两个指针 $left\_1$、$left\underline{\hspace{0.
 5em}}2$ 分别从两个数组头部开始遍历。
-3. 若 $nums1[left\underline{\hspace{0.5em}}1] == nums2[left\underline
-{\hspace{0.5em}}2]$，将该元素（去重）加入结果，并同时右移 $left\underline{\hspace{0.5em}}1$、$left\underline
+3. 若 $nums1[left\_1] == nums2[left\underline
+{\hspace{0.5em}}2]$，将该元素（去重）加入结果，并同时右移 $left\_1$、$left\underline
 {\hspace{0.5em}}2$。
-4. 若 $nums1[left\underline{\hspace{0.5em}}1] < nums2[left\underline
-{\hspace{0.5em}}2]$，则 $left\underline{\hspace{0.5em}}1$ 右移。
-5. 若 $nums1[left\underline{\hspace{0.5em}}1] > nums2[left\underline
+4. 若 $nums1[left\_1] < nums2[left\underline
+{\hspace{0.5em}}2]$，则 $left\_1$ 右移。
+5. 若 $nums1[left\_1] > nums2[left\underline
 {\hspace{0.5em}}2]$，则 $left\underline
 {\hspace{0.5em}}2$ 右移。
 6. 遍历结束后返回结果数组。

docs/01_array/01_16_array_sliding_window.md

@@ -28,11 +28,11 @@
 
 ### 3.1 固定长度滑动窗口算法步骤
 
-假设窗口大小为 $window\underline{\hspace{0.5em}}size$，步骤如下：
+假设窗口大小为 $window\_size$，步骤如下：
 
 1. 定义两个指针 $left$ 和 $right$，初始都指向序列起始位置（$left = 0, right = 0$），区间 $[left, right]$ 表示当前窗口。
 2. 不断右移 $right$，将元素加入窗口（如 `window.append(nums[right])`）。
-3. 当窗口长度达到 $window\underline{\hspace{0.5em}}size$（即 `right - left + 1 >= window_size`）时：
+3. 当窗口长度达到 $window\_size$（即 `right - left + 1 >= window_size`）时：
    - 判断窗口内元素是否满足题目要求，若满足则更新答案。
    - 右移 $left$（`left += 1`），保持窗口长度不变。
 4. 重复上述过程，直到 $right$ 遍历完整个数组。
@@ -107,7 +107,7 @@ while right < len(nums):
 
 1. 用 $window\_sum$ 维护当前窗口内元素和，$ans$ 统计满足条件的子数组个数。
 2. 使用两个指针 $left$、$right$，初始都为 $0$。
-3. 每次将 $arr[right]$ 加入 $window\underline{\hspace{0.5em}}sum$，$right$ 右移。
+3. 每次将 $arr[right]$ 加入 $window\_sum$，$right$ 右移。
 4. 当窗口长度达到 $k$（即 `right - left + 1 >= k`）时，判断窗口平均值是否大于等于 $threshold$，满足则 $ans + 1$。
 5. 然后将 $arr[left]$ 移出窗口，$left$ 右移，保证窗口长度始终为 $k$。
 6. 重复上述过程直到遍历完整个数组，最后返回 $ans$。

docs/03_stack_queue_hash_table/03_02_monotone_stack.md

@@ -165,14 +165,14 @@ def monotoneDecreasingStack(nums):
 
 第二种思路是使用单调递增栈。因为 $nums1$ 是 $nums2$ 的子集，所以我们可以先遍历一遍 $nums2$，并构造单调递增栈，求出 $nums2$ 中每个元素右侧下一个更大的元素。然后将其存储到哈希表中。然后再遍历一遍 $nums1$，从哈希表中取出对应结果，存放到答案数组中。这种解法的时间复杂度是 $O(n)$。具体做法如下：
 
-- 使用数组 $res$ 存放答案。使用 $stack$ 表示单调递增栈。使用哈希表 $num\underline{\hspace{0.5em}}map$ 用于存储 $nums2$ 中下一个比当前元素大的数值，映射关系为 **当前元素值：下一个比当前元素大的数值**。
+- 使用数组 $res$ 存放答案。使用 $stack$ 表示单调递增栈。使用哈希表 $num\_map$ 用于存储 $nums2$ 中下一个比当前元素大的数值，映射关系为 **当前元素值：下一个比当前元素大的数值**。
 - 遍历数组 $nums2$，对于当前元素：
   - 如果当前元素值较小，则直接让当前元素值入栈。
   - 如果当前元素值较大，则一直出栈，直到当前元素值小于栈顶元素。
-    - 出栈时，出栈元素是第一个大于当前元素值的元素。则将其映射到 $num\underline{\hspace{0.5em}}map$ 中。
+    - 出栈时，出栈元素是第一个大于当前元素值的元素。则将其映射到 $num\_map$ 中。
 
 - 遍历完数组 $nums2$，建立好所有元素下一个更大元素的映射关系之后，再遍历数组 $nums1$。
-- 从 $num\underline{\hspace{0.5em}}map$ 中取出对应的值，将其加入到答案数组中。
+- 从 $num\_map$ 中取出对应的值，将其加入到答案数组中。
 - 最终输出答案数组 $res$。
 
 #### 4.1.4 代码

docs/04_string/04_05_string_boyer_moore.md

@@ -145,13 +145,13 @@ BM 算法的关键在于两种启发式移动规则：**坏字符规则（Bad Ch
 BM 算法的整体流程如下：
 
 1. 计算文本串 $T$ 的长度 $n$ 和模式串 $p$ 的长度 $m$。
-2. 对模式串 $p$ 进行预处理，分别生成坏字符表 $bc\underline{\hspace{0.5em}}table$ 和好后缀规则后移位数表 $gs\underline{\hspace{0.5em}}table$。
+2. 对模式串 $p$ 进行预处理，分别生成坏字符表 $bc\_table$ 和好后缀规则后移位数表 $gs\_table$。
 3. 将模式串 $p$ 的头部与文本串 $T$ 的当前位置 $i$ 对齐，初始 $i = 0$。每次从模式串的末尾（$j = m - 1$）开始向前逐位比较：
    - 如果 $T[i + j]$ 与 $p[j]$ 相等，则继续向前比较下一个字符。
      - 如果模式串所有字符均匹配，则返回当前匹配的起始位置 $i$。
    - 如果 $T[i + j]$ 与 $p[j]$ 不相等：
-     - 分别根据坏字符表和好后缀表，计算坏字符移动距离 $bad\underline{\hspace{0.5em}}move$ 和好后缀移动距离 $good\underline{\hspace{0.5em}}move$。
-     - 取两者的最大值作为本轮的实际移动距离，即 $i += \max(bad\underline{\hspace{0.5em}}move,\, good\underline{\hspace{0.5em}}move)$，然后继续下一轮匹配。
+     - 分别根据坏字符表和好后缀表，计算坏字符移动距离 $bad\_move$ 和好后缀移动距离 $good\_move$。
+     - 取两者的最大值作为本轮的实际移动距离，即 $i += \max(bad\_move,\, good\_move)$，然后继续下一轮匹配。
 4. 如果模式串移动到文本串末尾仍未找到匹配，则返回 $-1$。
 
 该流程充分利用了坏字符和好后缀两种规则，实现了高效的字符串匹配。
@@ -164,11 +164,11 @@ BM 算法的匹配过程本身实现相对简单，真正的难点主要集中
 
 坏字符位置表的构建非常直观，具体步骤如下：
 
-- 创建一个哈希表 $bc\underline{\hspace{0.5em}}table$，用于记录每个字符在模式串中最后一次出现的位置，即 $bc\underline{\hspace{0.5em}}table[bad\underline{\hspace{0.5em}}char]$ 表示坏字符 $bad\underline{\hspace{0.5em}}char$ 在模式串中的最右下标。
+- 创建一个哈希表 $bc\_table$，用于记录每个字符在模式串中最后一次出现的位置，即 $bc\_table[bad\_char]$ 表示坏字符 $bad\_char$ 在模式串中的最右下标。
 
 - 遍历模式串 $p$，将每个字符 $p[i]$ 及其下标 $i$ 存入哈希表。若某字符在模式串中多次出现，则后出现的下标会覆盖前面的值，确保记录的是最右侧的位置。
 
-在 BM 算法匹配过程中，如果 $bad\underline{\hspace{0.5em}}char$ 不在 $bc\underline{\hspace{0.5em}}table$ 中，则视为其最右位置为 $-1$；如果存在，则直接取 $bc\underline{\hspace{0.5em}}table[bad\underline{\hspace{0.5em}}char]$。据此即可计算模式串本轮应向右移动的距离。
+在 BM 算法匹配过程中，如果 $bad\_char$ 不在 $bc\_table$ 中，则视为其最右位置为 $-1$；如果存在，则直接取 $bc\_table[bad\_char]$。据此即可计算模式串本轮应向右移动的距离。
 
 坏字符位置表的实现代码如下：
 
@@ -226,7 +226,7 @@ def generateSuffixArray(p: str):
     return suffix
 ```
 
-有了 $suffix$ 数组后，我们可以基于它构建好后缀规则的后移位数表 $gs\underline{\hspace{0.5em}}list$。该表用一个数组表示，其中 $gs\underline{\hspace{0.5em}}list[j]$ 表示在模式串第 $j$ 位遇到坏字符时，根据好后缀规则可以向右移动的距离。
+有了 $suffix$ 数组后，我们可以基于它构建好后缀规则的后移位数表 $gs\_list$。该表用一个数组表示，其中 $gs\_list[j]$ 表示在模式串第 $j$ 位遇到坏字符时，根据好后缀规则可以向右移动的距离。
 
 根据「2.2 好后缀规则」的分析，好后缀的移动分为三种情况：
 
@@ -236,13 +236,13 @@ def generateSuffixArray(p: str):
 
 实际上，情况 2 和情况 3 可以合并处理（情况 3 可视为最长前缀长度为 $0$ 的特殊情况）。当某个坏字符同时满足多种情况时，应优先选择移动距离最小的方案，以避免遗漏可能的匹配。例如，若既有匹配子串又有匹配前缀，应优先采用匹配子串的移动方式。
 
-具体构建 $gs\underline{\hspace{0.5em}}list$ 的步骤如下：
+具体构建 $gs\_list$ 的步骤如下：
 
-- 首先，假设所有位置均为情况 3，即 $gs\underline{\hspace{0.5em}}list[i] = m$。
-- 然后，利用后缀和前缀的匹配关系，更新情况 2 下的移动距离：$gs\underline{\hspace{0.5em}}list[j] = m - 1 - i$，其中 $j$ 是好后缀前的坏字符位置，$i$ 是最长前缀的末尾下标，$m - 1 - i$ 为可移动的距离。
-- 最后，处理情况 1：对于好后缀的左端点（$m - 1 - suffix[i]$ 处）遇到坏字符时，更新其可移动距离为 $gs\underline{\hspace{0.5em}}list[m - 1 - suffix[i]] = m - 1 - i$。
+- 首先，假设所有位置均为情况 3，即 $gs\_list[i] = m$。
+- 然后，利用后缀和前缀的匹配关系，更新情况 2 下的移动距离：$gs\_list[j] = m - 1 - i$，其中 $j$ 是好后缀前的坏字符位置，$i$ 是最长前缀的末尾下标，$m - 1 - i$ 为可移动的距离。
+- 最后，处理情况 1：对于好后缀的左端点（$m - 1 - suffix[i]$ 处）遇到坏字符时，更新其可移动距离为 $gs\_list[m - 1 - suffix[i]] = m - 1 - i$。
 
-下面是生成好后缀规则后移位数表 $gs\underline{\hspace{0.5em}}list$ 的代码：
+下面是生成好后缀规则后移位数表 $gs\_list$ 的代码：
 
 ```python
 # 生成好后缀规则后移位数表

docs/04_string/04_06_string_horspool.md

@@ -23,11 +23,11 @@ Horspool 算法本质上继承了 Boyer-Moore 的思想，但只保留了「坏
 Horspool 算法流程如下：
 
 1. 设文本串 $T$ 长度为 $n$，模式串 $p$ 长度为 $m$。
-2. 预处理模式串 $p$，生成后移位数表 $bc\underline{\hspace{0.5em}}table$。
+2. 预处理模式串 $p$，生成后移位数表 $bc\_table$。
 3. 从文本串起始位置 $i = 0$ 开始，将模式串与文本串对齐，比较方式如下：
    - 从模式串末尾 $j = m - 1$ 开始，依次向前比较 $T[i + j]$ 与 $p[j]$。
    - 如果全部字符匹配，返回 $i$，即匹配起始位置。
-   - 如果遇到不匹配，查找 $T[i + m - 1]$ 在 $bc\underline{\hspace{0.5em}}table$ 中的值，右移相应距离（如果未出现则右移 $m$）。
+   - 如果遇到不匹配，查找 $T[i + m - 1]$ 在 $bc\_table$ 中的值，右移相应距离（如果未出现则右移 $m$）。
 4. 如果遍历完文本串仍未找到匹配，返回 $-1$。
 
 ## 3. Horspool 算法代码实现
@@ -36,10 +36,10 @@ Horspool 算法流程如下：
 
 后移位数表的生成非常简单，类似于 Boyer-Moore 算法的坏字符表：
 
-- 用一个哈希表 $bc\underline{\hspace{0.5em}}table$，记录每个字符在模式串中可向右移动的距离。
+- 用一个哈希表 $bc\_table$，记录每个字符在模式串中可向右移动的距离。
 - 遍历模式串 $p$，对每个字符 $p[i]$，将 $m - 1 - i$ 作为其移动距离存入表中。如果字符重复，保留最右侧的距离。
 
-匹配时，如果 $T[i + m - 1]$ 不在表中，则右移 $m$；如果在表中，则右移 $bc\underline{\hspace{0.5em}}table[T[i + m - 1]]$。
+匹配时，如果 $T[i + m - 1]$ 不在表中，则右移 $m$；如果在表中，则右移 $bc\_table[T[i + m - 1]]$。
 
 后移位数表代码如下：
 

docs/04_string/04_07_string_sunday.md

@@ -26,13 +26,13 @@ Sunday 算法的思想与 Boyer-Moore 算法类似，但 Sunday 算法始终从
 Sunday 算法的具体流程如下：
 
 - 设文本串 $T$ 长度为 $n$，模式串 $p$ 长度为 $m$。
-- 首先对模式串 $p$ 进行预处理，生成后移位数表 $bc\underline{\hspace{0.5em}}table$。
+- 首先对模式串 $p$ 进行预处理，生成后移位数表 $bc\_table$。
 - 令 $i = 0$，表示当前模式串 $p$ 的起始位置与文本串 $T$ 的第 $i$ 位对齐。
 - 在每一轮匹配中，从头开始比较 $T[i + j]$ 与 $p[j]$（$j$ 从 $0$ 到 $m-1$）：
   - 如果所有字符均匹配，则返回当前匹配的起始位置 $i$。
   - 如果出现不匹配，或未全部匹配完毕，则：
     - 检查 $T[i + m]$（即当前匹配窗口末尾的下一个字符）：
-      - 如果 $T[i + m]$ 存在于后移位数表中，则将 $i$ 增加 $bc\underline{\hspace{0.5em}}table[T[i + m]]$，即将模式串向右滑动相应距离。
+      - 如果 $T[i + m]$ 存在于后移位数表中，则将 $i$ 增加 $bc\_table[T[i + m]]$，即将模式串向右滑动相应距离。
       - 如果 $T[i + m]$ 不存在于后移位数表中，则将 $i$ 增加 $m + 1$，即整体右移 $m + 1$ 位。
 - 若遍历完整个文本串仍未找到匹配，则返回 $-1$。
 
@@ -42,10 +42,10 @@ Sunday 算法的具体流程如下：
 
 后移位数表的实现非常简洁，与 Horspool 算法类似。具体思路如下：
 
-- 使用一个哈希表 $bc\underline{\hspace{0.5em}}table$，其中 $bc\underline{\hspace{0.5em}}table[bad\underline{\hspace{0.5em}}char]$ 表示遇到该字符时，模式串可以向右移动的距离。
+- 使用一个哈希表 $bc\_table$，其中 $bc\_table[bad\_char]$ 表示遇到该字符时，模式串可以向右移动的距离。
 - 遍历模式串 $p$，将每个字符 $p[i]$ 作为键，其对应的移动距离 $m - i$ 作为值存入字典。如果字符重复出现，则以最右侧（下标最大的）位置为准，覆盖之前的值。这样，哈希表中存储的就是每个字符在模式串中最右侧出现时可向右移动的距离。
 
-在 Sunday 算法匹配过程中，如果 $T[i + m]$ 不在 $bc\underline{\hspace{0.5em}}table$ 中，则默认移动 $m + 1$ 位，即将模式串整体右移到当前匹配窗口末尾的下一个字符之后。如果 $T[i + m]$ 存在于表中，则移动距离为 $bc\underline{\hspace{0.5em}}table[T[i + m]]$。这样即可高效计算每次滑动的步长。
+在 Sunday 算法匹配过程中，如果 $T[i + m]$ 不在 $bc\_table$ 中，则默认移动 $m + 1$ 位，即将模式串整体右移到当前匹配窗口末尾的下一个字符之后。如果 $T[i + m]$ 存在于表中，则移动距离为 $bc\_table[T[i + m]]$。这样即可高效计算每次滑动的步长。
 
 后移位数表的代码如下：