✨style: Bulk processing format

Author: SharingSource

LeetCode/1-10/1. 两数之和（简单）.md

@@ -15,25 +15,27 @@ Tag : 「哈希表」、「模拟」
 示例 1：
 ```
 输入：nums = [2,7,11,15], target = 9
+
 输出：[0,1]
+
 解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
 ```
 
 示例 2：
 ```
 输入：nums = [3,2,4], target = 6
+
 输出：[1,2]
 ```
 
 示例 3：
 ```
 输入：nums = [3,3], target = 6
+
 输出：[0,1]
 ```
 
-
 提示：
-
 * $2 <= nums.length <= 10^3$
 * -$10^9 <= nums[i] <= 10^9$
 * -$10^9 <= target <= 10^9$
@@ -45,13 +47,15 @@ Tag : 「哈希表」、「模拟」
 
 由于我们每次要从数组中找两个数。
 
-因此一个很简单的思路是：使用两重循环枚举下标 i 和 j ，分别代表要找的两个数。
+因此一个很简单的思路是：使用两重循环枚举下标 $i$ 和 $j$ ，分别代表要找的两个数。
+
+然后判断 $nums[i] + nums[j] = target$ 是否成立。
 
-然后判断 $nums[i] + nums[j] == target$ 是否成立。
+另外为了防止得到重复的解，我们需要在第一层循环中让 $i$ 从 $0$ 开始，到 $n - 2$ 结束（确保能取到下一位数作为 j ）；在第二层循环中让 $j$ 从 $i + 1$ 开始，到 $n - 1$ 结束。
 
-另外为了防止得到重复的解，我们需要在第一层循环中让 i 从 0 开始，到 n - 2 结束（确保能取到下一位数作为 j ）；在第二层循环中让 j 从 i + 1 开始，到 n - 1 结束。
+代码：
 
-```Java []
+```Java
 class Solution {
     public int[] twoSum(int[] nums, int t) {
         int n = nums.length;
@@ -69,19 +73,20 @@ class Solution {
 
 ---
 
-### 哈希表解法
+### 哈希表
 
 首先，任何优化的思路都不外乎「减少重复」。
 
 从朴素解法中可以知道，逻辑上我们是先定下来一个数，然后从数组中往后找另外一个值是否存在。但其实我们在找第二个数的过程中是重复扫描了数组多次。
 
 举个例子，对于 `nums = [2,3,8,4], target = 9` 的样例，我们先确定下来第一个数是 `2`，然后从后扫描到最后一个数，检查是否有 `7`。发现没有，再决策第一个数为 `3` 的情况，这时候我们应该利用前一次扫描的结果来帮助我们快速判断是否存在 `6`，而不是再重新进行一次扫描。
 
-这是直观的优化思路，不难想到可以使用哈希表进行存储。以数值为 key，数值的下标为 value。
+这是直观的优化思路，不难想到可以使用哈希表进行存储。以数值为 `key`，数值的下标为 `value`。
 
 当动手将想法转化为代码时，会发现如果先敲定第一个数，将后面的数加入哈希表，再进行下一位的遍历的时候，还需要将该数值从哈希表中进行删除。
 
-```Java []
+代码：
+```Java
 class Solution {
     public int[] twoSum(int[] nums, int t) {
         Map<Integer, Integer> map = new HashMap<>();
@@ -99,9 +104,9 @@ class Solution {
 
 这时候不妨将思路转换过来，遍历过程中敲定第二个数，使用哈希表在第二个数的前面去找第一个数。
 
-具体的做法是，边遍历边存入哈希表，遍历过程中使用的下标 i 用作敲定第二个数，再从现有的哈希表中去找另外一个目标数（由于下标 i 前面的数都被加入哈希表了，即在下标 i 前面去找第一个数）。
+具体的做法是，边遍历边存入哈希表，遍历过程中使用的下标 i 用作敲定第二个数，再从现有的哈希表中去找另外一个目标数（由于下标 $i$ 前面的数都被加入哈希表了，即在下标 $i$ 前面去找第一个数）。
 
-```Java []
+```Java
 class Solution {
     public int[] twoSum(int[] nums, int t) {
         Map<Integer, Integer> map = new HashMap<>();

LeetCode/1-10/10. 正则表达式匹配（困难）.md

@@ -6,10 +6,10 @@ Tag : 「动态规划」
 
 
 
-给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。
+给你一个字符串 `s` 和一个字符规律 `p`，请你来实现一个支持 `'.'` 和 `'*'` 的正则表达式匹配。
 
-* '.' 匹配任意单个字符
-* '*' 匹配零个或多个前面的那一个元素
+* `'.'` 匹配任意单个字符
+* `'*'` 匹配零个或多个前面的那一个元素
 
 所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。
 
@@ -44,11 +44,11 @@ Tag : 「动态规划」
 ```
 
 提示：
-* 0 <= s.length <= 20
-* 0 <= p.length <= 30
-* s 可能为空，且只包含从 a-z 的小写字母。
-* p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。
-* 保证每次出现字符 * 时，前面都匹配到有效的字符
+* $0 <= s.length <= 20$
+* $0 <= p.length <= 30$
+* `s` 可能为空，且只包含从 `a-z` 的小写字母。
+* `p` 可能为空，且只包含从 `a-z` 的小写字母，以及字符 `.` 和 `*`。
+* 保证每次出现字符 `*` 时，前面都匹配到有效的字符
 
 ---
 
@@ -119,12 +119,11 @@ class Solution {
     }
 }
 ```
-* 时间复杂度：n 表示 s 的长度，m 表示 p 的长度，总共 $n * m$ 个状态。复杂度为 $O(n * m)$
-* 空间复杂度：使用了二维数组记录结果。复杂度为 $O(n * m)$
+* 时间复杂度：$n$ 表示 `s` 的长度，$m$ 表示 `p` 的长度，总共 $n \times m$ 个状态。复杂度为 $O(n \times m)$
+* 空间复杂度：使用了二维数组记录结果。复杂度为 $O(n \times m)$
 
 **动态规划本质上是枚举（不重复的暴力枚举），因此其复杂度很好分析，有多少个状态就要被计算多少次，复杂度就为多少。**
 
-
 ---
 
 ### 最后

LeetCode/1-10/2. 两数相加（中等）.md

@@ -10,32 +10,36 @@ Tag : 「递归」、「链表」、「数学」、「模拟」
 
 请你将两个数相加，并以相同形式返回一个表示和的链表。
 
-你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
+你可以假设除了数字 $0$ 之外，这两个数都不会以 $0$ 开头。
 
 示例 1：
 
 ![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2021/01/02/addtwonumber1.jpg)
 
 ```
 输入：l1 = [2,4,3], l2 = [5,6,4]
+
 输出：[7,0,8]
+
 解释：342 + 465 = 807.
 ```
 示例 2：
 ```
 输入：l1 = [0], l2 = [0]
+
 输出：[0]
 ```
 示例 3：
 ```
 输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
+
 输出：[8,9,9,9,0,0,0,1]
 ```
 
 提示：
 
-* 每个链表中的节点数在范围 [1, 100] 内
-* 0 <= Node.val <= 9
+* 每个链表中的节点数在范围 $[1, 100]$ 内
+* $0 <= Node.val <= 9$
 * 题目数据保证列表表示的数字不含前导零
 
 
@@ -45,7 +49,7 @@ Tag : 「递归」、「链表」、「数学」、「模拟」
 
 这是道模拟题，模拟人工竖式做加法的过程：
 
-从最低位至最高位，逐位相加，如果和大于等于 10，则保留个位数字，同时向前一位进 1 如果最高位有进位，则需在最前面补 1。
+从最低位至最高位，逐位相加，如果和大于等于 $10$，则保留个位数字，同时向前一位进 1 如果最高位有进位，则需在最前面补 $1$。
 
 做有关链表的题目，有个常用技巧：添加一个虚拟头结点（哨兵），帮助简化边界情况的判断。
 

LeetCode/1-10/3. 无重复字符的最长子串（中等）.md

@@ -11,32 +11,39 @@ Tag : 「哈希表」、「双指针」、「滑动窗口」
 示例 1:
 ```
 输入: s = "abcabcbb"
+
 输出: 3 
+
 解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
 ```
 示例 2:
 ```
 输入: s = "bbbbb"
+
 输出: 1
+
 解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
 ```
 示例 3:
 ```
 输入: s = "pwwkew"
+
 输出: 3
+
 解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
      请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
 ```
 示例 4:
 ```
 输入: s = ""
+
 输出: 0
 ```
 
 提示：
 
-* 0 <= s.length <= 5 * $10^4$
-* s 由英文字母、数字、符号和空格组成
+* $0 <= s.length <= 5 \times 10^4$
+* `s` 由英文字母、数字、符号和空格组成
 
 ---
 

LeetCode/1-10/4. 寻找两个正序数组的中位数（困难）.md

@@ -6,48 +6,55 @@ Tag : 「二分」、「分治」
 
 
 
-给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。
+给定两个大小分别为 $m$ 和 $n$ 的正序（从小到大）数组 `nums1` 和 `nums2`。
 
 请你找出并返回这两个正序数组的「中位数」。
 
 示例 1：
 ```
 输入：nums1 = [1,3], nums2 = [2]
+
 输出：2.00000
+
 解释：合并数组 = [1,2,3] ，中位数 2
 ```
 示例 2：
 ```
 输入：nums1 = [1,2], nums2 = [3,4]
+
 输出：2.50000
+
 解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5
 ```
 示例 3：
 ```
 输入：nums1 = [0,0], nums2 = [0,0]
+
 输出：0.00000
 ```
 示例 4：
 ```
 输入：nums1 = [], nums2 = [1]
+
 输出：1.00000
 ```
 示例 5：
 ```
 输入：nums1 = [2], nums2 = []
+
 输出：2.00000
 ```
 
 提示：
-* nums1.length == m
-* nums2.length == n
-* 0 <= m <= 1000
-* 0 <= n <= 1000
-* 1 <= m + n <= 2000
-* -$10^6$ <= nums1[i], nums2[i] <= $10^6$
+* $nums1.length == m$
+* $nums2.length == n$
+* $0 <= m <= 1000$
+* $0 <= n <= 1000$
+* $1 <= m + n <= 2000$
+* $-10^6 <= nums1[i], nums2[i] <= 10^6$
 
 
-进阶：你能设计一个时间复杂度为 O(log (m+n)) 的算法解决此问题吗？
+进阶：你能设计一个时间复杂度为 $O(\log (m+n))$ 的算法解决此问题吗？
 
 ---
 
@@ -143,14 +150,11 @@ class Solution {
    3. 根据数据规模，判断我们的朴素算法计算机是否可以在 1s 内处理完 ② ，即判断运算次数是否在 $10^7$ 以内 ③ 。例如本题使用双指针算法，指针移动和判断大小算一次运行，由于数据只有 2000，距离 $10^7$ 还很远，所以完全足够了
 
 
+说明 ①：正规的算法题目都会提供数据规模，LeetCode 上一些旧题目没有提供，是因为当时出的时候不太规范，LeetCode 新题、其他 OJ 平台题目，算法竞赛题目都会有。
 
-*说明 ①：正规的算法题目都会提供数据规模，LeetCode 上一些旧题目没有提供，是因为当时出的时候不太规范，LeetCode 新题、其他 OJ 平台题目，算法竞赛题目都会有。*
-
-*说明 ②：即使是最严格的 OJ 中最简单的题目，也会提供 1s 的运行时间，超过这个时间才算超时。*
-
-*说明 ③：计算器 1s 内极限的处理速度是 $10^8$ ，但为了尽可能不出现错误提交，使用技巧时尽量和 $10^7$ 进行比较。*
-
+说明 ②：即使是最严格的 OJ 中最简单的题目，也会提供 1s 的运行时间，超过这个时间才算超时。
 
+说明 ③：计算器 1s 内极限的处理速度是 $10^8$ ，但为了尽可能不出现错误提交，使用技巧时尽量和 $10^7$ 进行比较。
 
 **注意：这两个技巧，我只推荐在机试或者竞赛（尽可能快 AC 的场景）中使用。平时练习或者和面试的时候必须老实按照题目要求来。**
 

LeetCode/1-10/5. 最长回文子串（中等）.md

@@ -6,7 +6,7 @@ Tag : 「模拟」、「回文串」
 
 
 
-给你一个字符串 s，找到 s 中最长的回文子串。
+给你一个字符串 `s`，找到 `s` 中最长的回文子串。
 
 示例 1：
 ```
@@ -32,8 +32,8 @@ Tag : 「模拟」、「回文串」
 
 提示：
 
-* 1 <= s.length <= 1000
-* s 仅由数字和英文字母（大写和/或小写）组成
+* $1 <= s.length <= 1000$
+* `s` 仅由数字和英文字母（大写和/或小写）组成
 
 
 ---
@@ -166,8 +166,6 @@ class Solution {
 
 对于想要背过 Manacher 算法的同学，建议先敲 3 遍，默写 2 遍，然后过了 24 小时，再默写 2 遍，一周后，再进行重复，直到熟练。
 
-不要害怕遗忘，遗忘是正常的，多进行几次重复便会形成肌肉记忆。LeetCode 周赛上常年占据第一页的选手，无不都是对算法套路和模板极其熟练。加油 ~
-
 ---
 ### 最后
 

LeetCode/1-10/6. Z 字形变换（中等）.md

@@ -94,7 +94,7 @@ class Solution {
 }
 ```
 * 时间复杂度：创建数组的工作只会发生一次，清空 `idxs` 数组操作会发生在每个样例中，复杂度为 $O(m)$；将 `s` 的每个字符填入矩阵的复杂度为 $O(n)$；从矩阵中取出字符构建答案复杂度为 $O(n)$。整体复杂度为 $O(m + n)$
-* 空间复杂度：$O(n * m)$
+* 空间复杂度：$O(n \times m)$
 
 ---