style: update format options

Author: yanglbme

.clang-format

@@ -18,7 +18,7 @@ AllowShortLambdasOnASingleLine: All
 AllowShortIfStatementsOnASingleLine: true
 AllowShortLoopsOnASingleLine: true
 AlwaysBreakAfterDefinitionReturnType: None
-AlwaysBreakAfterReturnType: TopLevelDefinitions
+AlwaysBreakAfterReturnType: None
 AlwaysBreakBeforeMultilineStrings: false
 AlwaysBreakTemplateDeclarations: MultiLine
 BinPackArguments: true

basic/searching/BinarySearch/README.md

@@ -25,12 +25,10 @@ int search(int left, int right) {
 ### 模板 2
 
 ```java
-boolean
-check(int x) {
+boolean check(int x) {
 }
 
-int
-search(int left, int right) {
+int search(int left, int right) {
     while (left < right) {
         int mid = (left + right + 1) >> 1;
         if (check(mid)) {

basic/searching/BinarySearch/README_EN.md

@@ -23,12 +23,10 @@ int search(int left, int right) {
 ### Template 2
 
 ```java
-boolean
-check(int x) {
+boolean check(int x) {
 }
 
-int
-search(int left, int right) {
+int search(int left, int right) {
     while (left < right) {
         int mid = (left + right + 1) >> 1;
         if (check(mid)) {

basic/sorting/CountingSort/CountingSort.java

@@ -1,5 +1,4 @@
-public static void
-sort(int[] nums, int min, int max) {
+public static void sort(int[] nums, int min, int max) {
     int n = nums.length;
     int k = max - min + 1;
     int[] c = new int[k];

basic/sorting/CountingSort/README.md

@@ -17,8 +17,7 @@
 ### **Java**
 
 ```java
-public static void
-sort(int[] nums, int min, int max) {
+public static void sort(int[] nums, int min, int max) {
     int[] c = new int[max - min + 1];
     for (int v : nums) {
         c[v - min]++;

solution/0000-0099/0001.Two Sum/README.md

@@ -59,7 +59,7 @@
 
 遍历数组，当发现 `target - nums[i]` 在哈希表中，说明找到了目标值。
 
-时间复杂度 $O(n)$，空间复杂度 $O(n)$。
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是数组 `nums` 的长度。
 
 <!-- tabs:start -->
 

solution/0000-0099/0002.Add Two Numbers/README.md

@@ -52,9 +52,9 @@
 
 **方法一：模拟**
 
-同时遍历两个链表 $l1$, $l2$，对应节点值相加，进位记为 $carry$。当 $l1$, $l2$ 同时遍历结束，并且 $carry$ 为 $0$ 时，结束遍历。
+同时遍历两个链表 `l1`, `l2`，对应节点值相加，进位记为 `carry`。当 `l1`, `l2` 同时遍历结束，并且 `carry` 为 `0` 时，结束遍历。
 
-时间复杂度 $O(max(m, n))$，其中 $m$, $n$ 分别表示两个链表的长度。忽略结果链表的空间消耗，空间复杂度 $O(1)$。
+时间复杂度 $O(\max(m, n))$，其中 $m$, $n$ 分别表示两个链表的长度。忽略结果链表的空间消耗，空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 

solution/0000-0099/0003.Longest Substring Without Repeating Characters/README.md

@@ -50,13 +50,13 @@
 
 **方法一：双指针 + 哈希表**
 
-定义一个哈希表记录当前窗口内出现的字符，记 $i$ 和 $j$ 分别表示不重复子串的开始位置和结束位置，无重复字符子串的最大长度记为 $ans$。
+定义一个哈希表记录当前窗口内出现的字符，记 $i$ 和 $j$ 分别表示不重复子串的开始位置和结束位置，无重复字符子串的最大长度记为 `ans`。
 
-遍历字符串 $s$ 的每个字符 $s[j]$，我们记为 $c$。若 $s[i..j-1]$ 窗口内存在 $c$，则 $i$ 循环向右移动，更新哈希表，直至 $s[i..j-1]$ 窗口不存在 $c$，循环结束。将 $c$ 加入哈希表中，此时 $s[i..j]$ 窗口内不含重复元素，更新 $ans$ 的最大值 $ans = max(ans, j - i + 1)$。
+遍历字符串 `s` 的每个字符 $s[j]$，我们记为 $c$。若 $s[i..j-1]$ 窗口内存在 $c$，则 $i$ 循环向右移动，更新哈希表，直至 $s[i..j-1]$ 窗口不存在 `c`，循环结束。将 `c` 加入哈希表中，此时 $s[i..j]$ 窗口内不含重复元素，更新 `ans` 的最大值。
 
-最后返回 $ans$ 即可。
+最后返回 `ans` 即可。
 
-时间复杂度 $O(n)$，其中 $n$ 表示字符串 $s$ 的长度。
+时间复杂度 $O(n)$，其中 $n$ 表示字符串 `s` 的长度。
 
 双指针算法模板：
 

solution/0000-0099/0004.Median of Two Sorted Arrays/README.md

@@ -47,17 +47,22 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-本题限制了时间复杂度为 `O(log (m+n))`，看到这个时间复杂度，自然而然的想到了应该使用二分查找法来求解。那么回顾一下中位数的定义，如果某个有序数组长度是奇数，那么其中位数就是最中间那个，如果是偶数，那么就是最中间两个数字的平均值。这里对于两个有序数组也是一样的，假设两个有序数组的长度分别为 m 和 n，由于两个数组长度之和 m+n 的奇偶不确定，因此需要分情况来讨论，对于奇数的情况，直接找到最中间的数即可，偶数的话需要求最中间两个数的平均值。为了简化代码，不分情况讨论，我们使用一个小 trick，我们分别找第 `(m+n+1) / 2` 个，和 `(m+n+2) / 2` 个，然后求其平均值即可，这对奇偶数均适用。假如 m+n 为奇数的话，那么其实 `(m+n+1) / 2` 和 `(m+n+2) / 2` 的值相等，相当于两个相同的数字相加再除以 2，还是其本身。
+**方法一：分治**
 
-这里我们需要定义一个函数来在两个有序数组中找到第 K 个元素，下面重点来看如何实现找到第 K 个元素。
+本题限制了时间复杂度为 $O(\log (m+n))$，看到这个时间复杂度，自然而然的想到了应该使用二分查找法来求解。那么回顾一下中位数的定义，如果某个有序数组长度是奇数，那么其中位数就是最中间那个，如果是偶数，那么就是最中间两个数字的平均值。这里对于两个有序数组也是一样的，假设两个有序数组的长度分别为 $m$ 和 $n$，由于两个数组长度之和 $m+n$ 的奇偶不确定，因此需要分情况来讨论，对于奇数的情况，直接找到最中间的数即可，偶数的话需要求最中间两个数的平均值。为了简化代码，不分情况讨论，我们使用一个小 trick，我们分别找第 $\frac{m+n+1}{2}$ 和 $\frac{m+n+2}{2}$ 个，然后求其平均值即可，这对奇偶数均适用。假如 $m+n$ 为奇数的话，那么其实 $\frac{m+n+1}{2}$ 和 $\frac{m+n+2}{2}$ 的值相等，相当于两个相同的数字相加再除以 2，还是其本身。
 
-首先，为了避免产生新的数组从而增加时间复杂度，我们使用两个变量 i 和 j 分别来标记数组 nums1 和 nums2 的起始位置。然后来处理一些边界问题，比如当某一个数组的起始位置大于等于其数组长度时，说明其所有数字均已经被淘汰了，相当于一个空数组了，那么实际上就变成了在另一个数组中找数字，直接就可以找出来了。还有就是如果 K=1 的话，那么我们只要比较 nums1 和 nums2 的起始位置 i 和 j 上的数字就可以了。
 
-难点就在于一般的情况怎么处理？因为我们需要在两个有序数组中找到第 K 个元素，为了加快搜索的速度，我们要使用二分法，对 K 二分，意思是我们需要分别在 nums1 和 nums2 中查找第 K/2 个元素，注意这里由于两个数组的长度不定，所以有可能某个数组没有第 K/2 个数字，所以我们需要先检查一下，数组中到底存不存在第 K/2 个数字，如果存在就取出来，否则就赋值上一个整型最大值。如果某个数组没有第 K/2 个数字，那么我们就淘汰另一个数字的前 K/2 个数字即可。有没有可能两个数组都不存在第 K/2 个数字呢，这道题里是不可能的，因为我们的 K 不是任意给的，而是给的 m+n 的中间值，所以必定至少会有一个数组是存在第 K/2 个数字的。
+这里我们需要定义一个函数来在两个有序数组中找到第 $k$ 个元素，下面重点来看如何实现找到第 $k$ 个元素。
 
-最后是二分法的核心，比较这两个数组的第 K/2 小的数字 midVal1 和 midVal2 的大小，如果第一个数组的第 K/2 个数字小的话，那么说明我们要找的数字肯定不在 nums1 中的前 K/2 个数字，所以我们可以将其淘汰，将 nums1 的起始位置向后移动 K/2 个，并且此时的 K 也自减去 K/2，调用递归。反之，我们淘汰 nums2 中的前 K/2 个数字，并将 nums2 的起始位置向后移动 K/2 个，并且此时的 K 也自减去 K/2，调用递归即可。
+首先，为了避免产生新的数组从而增加时间复杂度，我们使用两个变量 $i$ 和 $j$ 分别来标记数组 `nums1` 和 `nums2` 的起始位置。然后来处理一些边界问题，比如当某一个数组的起始位置大于等于其数组长度时，说明其所有数字均已经被淘汰了，相当于一个空数组了，那么实际上就变成了在另一个数组中找数字，直接就可以找出来了。还有就是如果 $k=1$ 的话，那么我们只要比较 `nums1` 和 `nums2` 的起始位置 $i$ 和 $j$ 上的数字就可以了。
 
-> 实际是比较两个数组中的第 K/2 个数字哪一个可能到达最后合并后排序数组中的第 K 个元素的位置，其中小的那个数字注定不可能到达，所以可以直接将小的元素对应的数组的前 K/2 个数字淘汰。
+难点就在于一般的情况怎么处理？因为我们需要在两个有序数组中找到第 $k$ 个元素，为了加快搜索的速度，我们要使用二分法，对 $k$ 二分，意思是我们需要分别在 `nums1` 和 `nums2` 中查找第 $\left \lfloor \frac{k}{2} \right \rfloor$ 个元素，注意这里由于两个数组的长度不定，所以有可能某个数组没有第 $\left \lfloor \frac{k}{2} \right \rfloor$ 个数字，所以我们需要先检查一下，数组中到底存不存在第 $\left \lfloor \frac{k}{2} \right \rfloor$ 个数字，如果存在就取出来，否则就赋值上一个整型最大值。如果某个数组没有第 $\left \lfloor \frac{k}{2} \right \rfloor$ 个数字，那么我们就淘汰另一个数字的前 $\left \lfloor \frac{k}{2} \right \rfloor$ 个数字即可。有没有可能两个数组都不存在第 $\left \lfloor \frac{k}{2} \right \rfloor$ 个数字呢，这道题里是不可能的，因为我们的 $k$ 不是任意给的，而是给的 $m+n$ 的中间值，所以必定至少会有一个数组是存在第 $\left \lfloor \frac{k}{2} \right \rfloor$ 个数字的。
+
+最后是二分法的核心，比较这两个数组的第 $\left \lfloor \frac{k}{2} \right \rfloor$ 小的数字 `midVal1` 和 `midVal2` 的大小，如果第一个数组的第 $\left \lfloor \frac{k}{2} \right \rfloor$ 个数字小的话，那么说明我们要找的数字肯定不在 `nums1` 中的前 $\left \lfloor \frac{k}{2} \right \rfloor$ 个数字，所以我们可以将其淘汰，将 `nums1` 的起始位置向后移动 $\left \lfloor \frac{k}{2} \right \rfloor$ 个，并且此时的 $k$ 也自减去 $\left \lfloor \frac{k}{2} \right \rfloor$，调用递归。反之，我们淘汰 `nums2` 中的前 $\left \lfloor \frac{k}{2} \right \rfloor$ 个数字，并将 `nums2` 的起始位置向后移动 $\left \lfloor \frac{k}{2} \right \rfloor$ 个，并且此时的 $k$ 也自减去 $\left \lfloor \frac{k}{2} \right \rfloor$，调用递归即可。
+
+> 实际是比较两个数组中的第 $\left \lfloor \frac{k}{2} \right \rfloor$ 个数字哪一个可能到达最后合并后排序数组中的第 $k$ 个元素的位置，其中小的那个数字注定不可能到达，所以可以直接将小的元素对应的数组的前 $\left \lfloor \frac{k}{2} \right \rfloor$ 个数字淘汰。
+
+时间复杂度 $O(\log (m+n))$，其中 $m$ 和 $n$ 是两个数组的长度。
 
 <!-- tabs:start -->
 

solution/0000-0099/0005.Longest Palindromic Substring/README.md

@@ -38,12 +38,14 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-动态规划法。
+**方法一：动态规划**
 
-设 `dp[i][j]` 表示字符串 `s[i..j]` 是否为回文串。
+设 $dp[i][j]$ 表示字符串 $s[i..j]$ 是否为回文串。
 
--   当 `j - i < 2`，即字符串长度为 2 时，只要 `s[i] == s[j]`，`dp[i][j]` 就为 true。
--   当 `j - i >= 2`，`dp[i][j] = dp[i + 1][j - 1] && s[i] == s[j]`。
+-   当 $j - i \lt 2$，即字符串长度为 `2` 时，只要 $s[i] == s[j]$，那么 $dp[i][j]$ 就为 `true`。
+-   当 $j - i \ge 2$，有 $dp[i][j] = dp[i + 1][j - 1] \cap s[i] == s[j]$。
+
+时间复杂度 $O(n^2)$，空间复杂度 $O(n^2)$。
 
 <!-- tabs:start -->
 

solution/0900-0999/0983.Minimum Cost For Tickets/Solution.java

@@ -1,5 +1,5 @@
 class Solution {
-    private static final int[] T = new int[]{1, 7, 30};
+    private static final int[] T = new int[] {1, 7, 30};
     private int[] costs;
     private int[] days;
     private int[] f;

solution/2300-2399/2399.Check Distances Between Same Letters/Solution.c

@@ -1,4 +1,4 @@
-bool checkDistances(char *s, int *distance, int distanceSize) {
+bool checkDistances(char* s, int* distance, int distanceSize) {
     int n = strlen(s);
     int d[26] = {0};
     for (int i = 0; i < n; i++) {