chore: update lc problems (doocs#1095)

Author: yanglbme

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

@@ -48,7 +48,7 @@
 
 ## Solutions
 
-**Approach 1: Hash Table**
+**Solution 1: Hash Table**
 
 We can use the hash table $m$ to store the array value and the corresponding subscript.
 

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

@@ -42,7 +42,7 @@
 
 ## Solutions
 
-**Approach 1: Simulation**
+**Solution 1: Simulation**
 
 We traverse two linked lists $l_1$ and $l_2$ at the same time, and use the variable $carry$ to indicate whether there is a carry.
 

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

@@ -42,7 +42,7 @@ Notice that the answer must be a substring, "pwke" is a subsequence an
 
 ## Solutions
 
-**Approach 1: Two pointers + Hash Table**
+**Solution 1: Two pointers + Hash Table**
 
 Define a hash table to record the characters in the current window. Let $i$ and $j$ represent the start and end positions of the non-repeating substring, respectively. The length of the longest non-repeating substring is recorded by `ans`.
 

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

@@ -32,7 +32,7 @@
 
 ## Solutions
 
-**Approach 1: Dynamic Programming**
+**Solution 1: Dynamic Programming**
 
 Set $dp[i][j]$ to indicate whether the string $s[i..j]$ is a palindrome.
 
@@ -41,7 +41,7 @@ Set $dp[i][j]$ to indicate whether the string $s[i..j]$ is a palindrome.
 
 The time complexity is $O(n^2)$ and the space complexity is $O(n^2)$. Where $n$ is the length of the string $s$.
 
-**Approach 2: Enumerate the Palindrome Center**
+**Solution 2: Enumerate the Palindrome Center**
 
 We can enumerate the palindrome center, spread to both sides, and find the longest palindrome.
 

solution/0000-0099/0006.Zigzag Conversion/README_EN.md

@@ -58,7 +58,7 @@ P     I
 
 ## Solutions
 
-**Approach 1: Simulation**
+**Solution 1: Simulation**
 
 We use a 2D array $g$ to simulate the process of the $Z$-shaped arrangement, where $g[i][j]$ represents the character in the $i$th row and the $j$th column. Initially, $i=0$, and we also define a direction variable $k$, initially $k=-1$, which means up.
 

solution/0000-0099/0007.Reverse Integer/README_EN.md

@@ -39,7 +39,7 @@
 
 ## Solutions
 
-**Approach 1: Mathematical**
+**Solution 1: Mathematical**
 
 Let $mi$ and $mx$ be $-2^{31}$ and $2^{31} - 1$ respectively. The reversed result $ans$ needs to satisfy $mi \le ans \le mx$.
 

solution/0000-0099/0012.Integer to Roman/README_EN.md

@@ -62,7 +62,7 @@ M             1000</pre>
 
 ## Solutions
 
-**Approach 1: Greedy**
+**Solution 1: Greedy**
 
 We can list all possible symbols $cs$ and corresponding values $vs$ first, then enumerate the value $vs[i]$ from large to small, and use the symbol $cs[i]$ as much as possible each time until the number $num$ becomes $0$.
 

solution/0000-0099/0013.Roman to Integer/README_EN.md

@@ -64,7 +64,7 @@ M             1000</pre>
 
 ## Solutions
 
-**Approach 1: Hash table + simulation**
+**Solution 1: Hash table + simulation**
 
 We first use a hash table $d$ to record the numerical value corresponding to each character, and then traverse the string $s$ from left to right. If the numerical value corresponding to the current character is less than the numerical value corresponding to the right character, subtract the numerical value corresponding to the current character, otherwise add the numerical value corresponding to the current character.
 

solution/0000-0099/0014.Longest Common Prefix/README_EN.md

@@ -35,7 +35,7 @@
 
 ## Solutions
 
-**Approach 1: Character Comparison**
+**Solution 1: Character Comparison**
 
 We take the first string $strs[0]$ as the benchmark, and compare the $i$th character of the string after it with the $i$th character of $strs[0]$. If it is the same, continue to compare the next character, otherwise return the first $i$ characters of $strs[0]$.
 

solution/0000-0099/0015.3Sum/README_EN.md

@@ -48,7 +48,7 @@ Notice that the order of the output and the order of the triplets does not matte
 
 ## Solutions
 
-**Approach 1: Sort + Two Pointers**
+**Solution 1: Sort + Two Pointers**
 
 We notice that the problem does not require us to return the triplet in order, so we might as well sort the array first, which makes it easy to skip duplicate elements.
 

solution/0000-0099/0018.4Sum/README_EN.md

@@ -40,7 +40,7 @@
 
 ## Solutions
 
-**Approach 1: Two Pointers**
+**Solution 1: Two Pointers**
 
 Time complexity $O(n^3)$, Space complexity $O(\log n)$.
 

solution/0000-0099/0024.Swap Nodes in Pairs/README_EN.md

@@ -38,11 +38,11 @@
 
 ## Solutions
 
-**Approach 1: Iteration**
+**Solution 1: Iteration**
 
 Time complexity $O(n)$, Space complexity $O(1)$.
 
-**Approach 2: Recursion**
+**Solution 2: Recursion**
 
 Time complexity $O(n)$, Space complexity $O(n)$.
 

solution/0000-0099/0025.Reverse Nodes in k-Group/README_EN.md

@@ -39,11 +39,11 @@
 
 ## Solutions
 
-**Approach 1: Iteration**
+**Solution 1: Iteration**
 
 Time complexity $O(n)$, Space complexity $O(1)$.
 
-**Approach 2: Recursion**
+**Solution 2: Recursion**
 
 Time complexity $O(n)$, Space complexity $O(\log _k n)$.
 

solution/0000-0099/0027.Remove Element/README_EN.md

@@ -65,7 +65,7 @@ It does not matter what you leave beyond the returned k (hence they are undersco
 
 ## Solutions
 
-**Approach 1: One Pass**
+**Solution 1: One Pass**
 
 We use the variable $k$ to record the number of elements that are not equal to $val$.
 

solution/0000-0099/0028.Find the Index of the First Occurrence in a String/README_EN.md

@@ -34,15 +34,15 @@ The first occurrence is at index 0, so we return 0.
 
 ## Solutions
 
-**Approach 1: Traverse**
+**Solution 1: Traverse**
 
 Time complexity $O((n-m) \times m)$, Space complexity $O(1)$.
 
-**Approach 2: Rabin-Karp**
+**Solution 2: Rabin-Karp**
 
 Time complexity $O(n+m)$, Space complexity $O(1)$.
 
-**Approach 3: KMP**
+**Solution 3: KMP**
 
 Time complexity $O(n+m)$, Space complexity $O(m)$.
 

solution/0000-0099/0029.Divide Two Integers/README_EN.md

@@ -39,7 +39,7 @@
 
 ## Solutions
 
-**Approach 1: Quick Power**
+**Solution 1: Quick Power**
 
 Time complexity $O(\log a \times \log b)$, Space complexity $O(1)$.
 

solution/0000-0099/0030.Substring with Concatenation of All Words/README_EN.md

@@ -59,7 +59,7 @@ The substring starting at 12 is "thefoobar". It is the concatenation o
 
 ## Solutions
 
-**Approach 1: Hash Table + Sliding Window**
+**Solution 1: Hash Table + Sliding Window**
 
 We use a hash table $cnt$ to count the number of times each word in $words$ appears, and use a hash table $cnt1$ to count the number of times each word in the current sliding window appears. Let the length of the string $s$ be $m$, the number of words in the string array $words$ be $n$, and the length of each word be $k$.
 

solution/0000-0099/0031.Next Permutation/README_EN.md

@@ -54,7 +54,7 @@
 
 ## Solutions
 
-**Approach 1: Two traversals**
+**Solution 1: Two traversals**
 
 We first traverse the array from back to front and find the first position $i$ where $nums[i] \lt nums[i + 1]$.
 

solution/0000-0099/0032.Longest Valid Parentheses/README_EN.md

@@ -40,7 +40,7 @@
 
 ## Solutions
 
-**Approach 1: Dynamic Programming**
+**Solution 1: Dynamic Programming**
 
 We define $f[i]$ to be the length of the longest valid parentheses that ends with $s[i-1]$, and the answer is $max(f[i])$.
 

solution/0000-0099/0036.Valid Sudoku/README_EN.md

@@ -64,7 +64,7 @@
 
 ## Solutions
 
-**Approach 1: Traversal once**
+**Solution 1: Traversal once**
 
 The valid sudoku satisfies the following three conditions:
 

solution/0000-0099/0042.Trapping Rain Water/README_EN.md

@@ -33,7 +33,7 @@
 
 ## Solutions
 
-**Approach 1: Dynamic Programming**
+**Solution 1: Dynamic Programming**
 
 We define $left[i]$ as the height of the highest pillar to the left of and including the position with index $i$, and define $right[i]$ as the height of the highest pillar to the right of and including the position with index $i$. Then the amount of rain water that can be trapped at the position with index $i$ is $min(left[i], right[i]) - height[i]$. We traverse the array, calculate $left[i]$ and $right[i]$, and the answer is $\sum_{i=0}^{n-1} min(left[i], right[i]) - height[i]$.
 

solution/0000-0099/0045.Jump Game II/README_EN.md

@@ -42,7 +42,7 @@
 
 ## Solutions
 
-**Approach 1: Greedy**
+**Solution 1: Greedy**
 
 We can use a variable $mx$ to record the furthest position that can be reached at the current position, and use a variable $last$ to record the last jump position, and use a variable $ans$ to record the number of jumps.
 

solution/0000-0099/0048.Rotate Image/README_EN.md

@@ -34,7 +34,7 @@
 
 ## Solutions
 
-**Approach 1: In-place**
+**Solution 1: In-place**
 
 According to the requirements of the problem, we actually need to rotate $matrix[i][j]$ to $matrix[j][n - i - 1]$.
 

solution/0000-0099/0054.Spiral Matrix/README_EN.md

@@ -33,15 +33,15 @@
 
 ## Solutions
 
-**Approach 1: Simulation**
+**Solution 1: Simulation**
 
 We use $i$ and $j$ to respectively represent the row and column of the current element being visited, and use $k$ to represent the current direction. We use an array or hash table $vis$ to record whether each element has been visited. After each element is visited, it is marked as visited, and then the current direction is moved forward one step. If the forward step goes out of bounds or has been visited, the direction is changed and continued. Move forward until the entire matrix is traversed.
 
 The time complexity is $O(m \times n)$ and the space complexity is $O(m \times n)$. Where $m$ and $n$ are the number of rows and columns of the matrix.
 
 For the visited elements, we can also add a constant $300$ to their values, so we do not need an extra $vis$ array or hash table to record whether it has been visited, thus reducing the space complexity to $O(1)$.
 
-**Approach 2: Layer-by-layer Simulation**
+**Solution 2: Layer-by-layer Simulation**
 
 We can also traverse and store the matrix elements from the outside to the inside layer by layer.
 

solution/0000-0099/0055.Jump Game/README_EN.md

@@ -35,7 +35,7 @@
 
 ## Solutions
 
-**Approach 1: Greedy**
+**Solution 1: Greedy**
 
 We use a variable $mx$ to maintain the farthest index that can be reached, initially $mx = 0$.
 

solution/0000-0099/0058.Length of Last Word/README_EN.md

@@ -44,7 +44,7 @@
 
 ## Solutions
 
-**Approach 1: Reverse traversal + two pointers**
+**Solution 1: Reverse traversal + two pointers**
 
 We start traversing from the end of the string $s$, finding the last character of the last word, which is not a space, and the subscript is $i$. Then continue to traverse forward to find the first space character, which is the character before the first character of the last word, and mark it as $j$. Then the length of the last word is $i - j$.
 

solution/0000-0099/0071.Simplify Path/README_EN.md

@@ -55,7 +55,7 @@
 
 ## Solutions
 
-**Approach 1: Stack**
+**Solution 1: Stack**
 
 We first split the path into a number of substrings split by `'/'`. Then, we traverse each substring and perform the following operations based on the content of the substring:
 

solution/0000-0099/0073.Set Matrix Zeroes/README_EN.md

@@ -44,15 +44,15 @@
 
 ## Solutions
 
-**Approach 1: Array Mark**
+**Solution 1: Array Mark**
 
 We use arrays `rows` and `cols` to mark the rows and columns to be cleared.
 
 Then traverse the matrix again, and clear the elements in the rows and columns marked in `rows` and `cols`.
 
 The time complexity is $O(m\times n)$, and the space complexity is $O(m+n)$. Where $m$ and $n$ are the number of rows and columns of the matrix respectively.
 
-**Approach 2: Mark in Place**
+**Solution 2: Mark in Place**
 
 In the first method, we use an additional array to mark the rows and columns to be cleared. In fact, we can also use the first row and first column of the matrix to mark them, without creating an additional array.
 

solution/0000-0099/0076.Minimum Window Substring/README_EN.md

@@ -49,7 +49,7 @@ Since the largest window of s only has one 'a', return empty string.
 
 ## Solutions
 
-**Approach 1: Counting + Two Pointers**
+**Solution 1: Counting + Two Pointers**
 
 We use a hash table or array $need$ to count the number of characters in string $t$, and use another hash table or array $window$ to count the number of characters in the sliding window. In addition, define two pointers $j$ and $i$ pointing to the left and right boundaries of the window, and the variable $cnt$ represents the number of characters in $t$ that are already included in the window. The variables $k$ and $mi$ represent the starting position and length of the minimum cover substring respectively.
 

solution/0000-0099/0088.Merge Sorted Array/README_EN.md

@@ -55,7 +55,7 @@ Note that because m = 0, there are no elements in nums1. The 0 is only there to
 
 ## Solutions
 
-**Approach 1: Two Pointers**
+**Solution 1: Two Pointers**
 
 We use two pointers $i$ and $j$ pointing to the end of two arrays, and a pointer $k$ pointing to the end of the merged array.
 

solution/0100-0199/0121.Best Time to Buy and Sell Stock/README_EN.md

@@ -38,7 +38,7 @@ Note that buying on day 2 and selling on day 1 is not allowed because you must b
 
 ## Solutions
 
-**Approach 1: Enumerate + Maintain the Minimum Value of the Prefix**
+**Solution 1: Enumerate + Maintain the Minimum Value of the Prefix**
 
 We can enumerate each element of the array $nums$ as the selling price. Then we need to find a minimum value in front of it as the purchase price to maximize the profit.
 

solution/0100-0199/0122.Best Time to Buy and Sell Stock II/README_EN.md

@@ -48,13 +48,13 @@ Total profit is 4.
 
 ## Solutions
 
-**Approach 1: Greedy**
+**Solution 1: Greedy**
 
 From the second day, if the stock price on that day is greater than the previous day, buy it on the previous day and sell it on that day to get a profit. If the stock price on that day is less than the previous day, do not buy it or sell it. That is to say, all the rising trading days are bought and sold, and all the falling trading days are not bought or sold, and the final profit is the maximum.
 
 The time complexity is $O(n)$, where $n$ is the length of the array `prices`. The space complexity is $O(1)$.
 
-**Approach 2: Dynamic Programming**
+**Solution 2: Dynamic Programming**
 
 Let $f[i][j]$ represent the maximum profit after the $i$th day of trading, where $j$ represents whether the current stock is held, and $j=0$ when the stock is held, and $j=1$ when the stock is not held. The initial state is $f[0][0]=-prices[0]$, and all other states are $0$.
 
@@ -75,9 +75,9 @@ The final answer is $f[n-1][1]$, where $n$ is the length of the array `prices`.
 
 The time complexity is $O(n)$ and the space complexity is $O(n)$. $n$ is the length of the array `prices`.
 
-**Approach 3: Dynamic Programming (space optimization)**
+**Solution 3: Dynamic Programming (space optimization)**
 
-We can find that in approach 2, the state of the $i$th day only depends on the state of the $i-1$th day, so we can only use two variables to maintain the state of the $i-1$th day. Therefore, the space complexity can be optimized to $O(1)$.
+We can find that in Solution 2, the state of the $i$th day only depends on the state of the $i-1$th day, so we can only use two variables to maintain the state of the $i-1$th day. Therefore, the space complexity can be optimized to $O(1)$.
 
 Time complexity $O(n)$, where $n$ is the length of the array `prices`. Space complexity $O(1)$.
 

solution/0100-0199/0128.Longest Consecutive Sequence/README_EN.md

@@ -34,7 +34,7 @@
 
 ## Solutions
 
-**Approach 1: Sorting**
+**Solution 1: Sorting**
 
 First, we sort the array, and use a variable $t$ to record the length of the current continuous sequence, and use a variable $ans$ to record the length of the longest continuous sequence.
 
@@ -48,7 +48,7 @@ Finally, we return the answer $ans$.
 
 Time complexity $O(n \times \log n)$, space complexity $O(\log n)$, where $n$ is the length of the array.
 
-**Approach 2: Hash Table**
+**Solution 2: Hash Table**
 
 We use a hash table to store all the elements in the array, and then we traverse the array to find the longest continuous sequence for each element $x$. If the predecessor of the current element $x-1$ is not in the hash table, we use the current element as the starting point, and keep trying to match $x+1, x+2, x+3, \dots$ until we cannot match, the matching length at this time is the length of the longest continuous sequence starting from $x$, so we update the answer.
 

solution/0100-0199/0135.Candy/README_EN.md

@@ -44,7 +44,7 @@ The third child gets 1 candy because it satisfies the above two conditions.
 
 ## Solutions
 
-**Approach 1: Two traversals**
+**Solution 1: Two traversals**
 
 We initialize two arrays $left$ and $right$, where $left[i]$ represents the minimum number of candies the current child should get when the current child's score is higher than the left child's score, and $right[i]$ represents the minimum number of candies the current child should get when the current child's score is higher than the right child's score. Initially, $left[i]=1$, $right[i]=1$.
 

solution/0100-0199/0151.Reverse Words in a String/README_EN.md

@@ -50,13 +50,13 @@
 
 ## Solutions
 
-**Approach 1: Use Language Built-in Functions**
+**Solution 1: Use Language Built-in Functions**
 
 We split the string into a list of strings by spaces, then reverse the list, and finally join the list into a string separated by spaces.
 
 Time complexity $O(n)$, space complexity $O(n)$, where $n$ is the length of the string.
 
-**Approach 2: Two Pointers**
+**Solution 2: Two Pointers**
 
 We can use two pointers $i$ and $j$, each time we find a word, add it to the result list, then reverse the result list, and finally join the list into a string.