feat: add solutions to lc problems (doocs#2036)

Author: yanglbme

solution/0000-0099/0049.Group Anagrams/README_EN.md

@@ -50,7 +50,7 @@ The time complexity is $O(n\times k\times \log k)$, where $n$ and $k$ are the le
 
 **Solution 2: Counting**
 
-We can also change the sorting part in Method 1 to counting, that is, use the characters in each string $s$ and their occurrence times as `key`, and use the string $s$ as `value` to store in the hash table.
+We can also change the sorting part in Solution 1 to counting, that is, use the characters in each string $s$ and their occurrence times as `key`, and use the string $s$ as `value` to store in the hash table.
 
 The time complexity is $O(n\times (k + C))$, where $n$ and $k$ are the lengths of the string array and the maximum length of the string, respectively, and $C$ is the size of the character set. In this problem, $C = 26$.
 

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

@@ -48,21 +48,21 @@ Total profit is 4.
 
 ## Solutions
 
-**Solution 1: Greedy**
+**Solution 1: Greedy Algorithm**
 
-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.
+Starting from the second day, if the stock price is higher than the previous day, buy on the previous day and sell on the current day to make a profit. If the stock price is lower than the previous day, do not buy or sell. In other words, buy and sell on all rising trading days, and do not trade on all falling trading days. The final profit will be the maximum.
 
-The time complexity is $O(n)$, where $n$ is the length of the array `prices`. The space complexity is $O(1)$.
+The time complexity is $O(n)$, where $n$ is the length of the `prices` array. The space complexity is $O(1)$.
 
 **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$.
+We define $f[i][j]$ as the maximum profit after trading on the $i$th day, where $j$ indicates whether we currently hold the stock. When holding the stock, $j=0$, and when not holding the stock, $j=1$. The initial state is $f[0][0]=-prices[0]$, and all other states are $0$.
 
-If the current stock is held, it may be that the stock was held on the previous day and nothing was done today, that is, $f[i][0]=f[i-1][0]$; or the stock was not held the previous day and the stock was bought today, that is, $f[i][0]=f[i-1][1]-prices[i]$.
+If we currently hold the stock, it may be that we held the stock the day before and do nothing today, i.e., $f[i][0]=f[i-1][0]$. Or it may be that we did not hold the stock the day before and bought the stock today, i.e., $f[i][0]=f[i-1][1]-prices[i]$.
 
-If the current stock is not held, it may be that the stock was not held the previous day and nothing was done today, that is, $f[i][1]=f[i-1][1]$; or the stock was held the previous day and the stock was sold today, that is, $f[i][1]=f[i-1][0]+prices[i]$.
+If we currently do not hold the stock, it may be that we did not hold the stock the day before and do nothing today, i.e., $f[i][1]=f[i-1][1]$. Or it may be that we held the stock the day before and sold the stock today, i.e., $f[i][1]=f[i-1][0]+prices[i]$.
 
-Therefore, we can write down the state transition equation:
+Therefore, we can write the state transition equation as:
 
 $$
 \begin{cases}
@@ -71,15 +71,15 @@ f[i][1]=\max(f[i-1][1],f[i-1][0]+prices[i])
 \end{cases}
 $$
 
-The final answer is $f[n-1][1]$, where $n$ is the length of the array `prices`.
+The final answer is $f[n-1][1]$, where $n$ is the length of the `prices` array.
 
-The time complexity is $O(n)$ and the space complexity is $O(n)$. $n$ is the length of the array `prices`.
+The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the `prices` array.
 
-**Solution 3: Dynamic Programming (space optimization)**
+**Solution 3: Dynamic Programming (Space Optimization)**
 
-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)$.
+We can find that in Solution 2, the state of the $i$th day is only related to the state of the $i-1$th day. Therefore, we can use only two variables to maintain the state of the $i-1$th day, thereby optimizing the space complexity to $O(1)$.
 
-Time complexity $O(n)$, where $n$ is the length of the array `prices`. Space complexity $O(1)$.
+The time complexity is $O(n)$, where $n$ is the length of the `prices` array. The space complexity is $O(1)$.
 
 <!-- tabs:start -->
 

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

@@ -46,6 +46,21 @@ Note that you cannot buy on day 1, buy on day 2 and sell them later, as you are
 
 ## Solutions
 
+**Solution 1: Dynamic Programming**
+
+We define the following variables:
+
+-   `f1` represents the maximum profit after the first purchase of the stock;
+-   `f2` represents the maximum profit after the first sale of the stock;
+-   `f3` represents the maximum profit after the second purchase of the stock;
+-   `f4` represents the maximum profit after the second sale of the stock.
+
+During the traversal, we directly calculate `f1`, `f2`, `f3`, `f4`. We consider that buying and selling on the same day will result in a profit of $0$, which will not affect the answer.
+
+Finally, return `f4`.
+
+The time complexity is $O(n)$, where $n$ is the length of the `prices` array. The space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/0100-0199/0124.Binary Tree Maximum Path Sum/README_EN.md

@@ -39,25 +39,25 @@
 
 **Solution 1: Recursion**
 
-We think about the classic routine of binary tree recursion problem:
+When thinking about the classic routine of recursion problems in binary trees, we consider:
 
 1. Termination condition (when to terminate recursion)
-2. Recursion processing left and right subtrees
-3. Combine the calculation results of the left and right subtrees
+2. Recursively process the left and right subtrees
+3. Merge the calculation results of the left and right subtrees
 
-For this topic, we design a function $dfs(root)$, which returns the maximum path sum of the binary tree with $root$ as the root node.
+For this problem, we design a function $dfs(root)$, which returns the maximum path sum of the binary tree with $root$ as the root node.
 
 The execution logic of the function $dfs(root)$ is as follows:
 
 If $root$ does not exist, then $dfs(root)$ returns $0$;
 
-Otherwise, we recursively calculate the maximum path sum of the left subtree and the right subtree of $root$, denoted as $left$ and $right$, respectively. If $left$ is less than $0$, then we set it to $0$, similarly, if $right$ is less than $0$, then we set it to $0$.
+Otherwise, we recursively calculate the maximum path sum of the left and right subtrees of $root$, denoted as $left$ and $right$. If $left$ is less than $0$, then we set it to $0$, similarly, if $right$ is less than $0$, then we set it to $0$.
 
 Then, we update the answer with $root.val + left + right$. Finally, the function returns $root.val + \max(left, right)$.
 
-In the main function, we call $dfs(root)$ to get the maximum path sum of each node, and the maximum value in it is the answer.
+In the main function, we call $dfs(root)$ to get the maximum path sum of each node, and the maximum value among them is the answer.
 
-Time complexity $O(n)$, space complexity $O(n)$. Where $n$ is the number of nodes in the binary tree.
+The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the number of nodes in the binary tree.
 
 <!-- tabs:start -->
 

solution/0100-0199/0125.Valid Palindrome/README_EN.md

@@ -44,6 +44,19 @@ Since an empty string reads the same forward and backward, it is a palindrome.
 
 ## Solutions
 
+**Solution 1: Two Pointers**
+
+We use two pointers $i$ and $j$ to point to the two ends of the string $s$, and then loop through the following process until $i \geq j$:
+
+1. If $s[i]$ is not a letter or a number, move the pointer $i$ one step to the right and continue to the next loop.
+2. If $s[j]$ is not a letter or a number, move the pointer $j$ one step to the left and continue to the next loop.
+3. If the lowercase form of $s[i]$ and $s[j]$ are not equal, return `false`.
+4. Otherwise, move the pointer $i$ one step to the right and the pointer $j$ one step to the left, and continue to the next loop.
+
+At the end of the loop, return `true`.
+
+The time complexity is $O(n)$, where $n$ is the length of the string $s$. The space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/0100-0199/0127.Word Ladder/README.md

@@ -50,6 +50,8 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：BFS**
+
 BFS 最小步数模型。本题可以用朴素 BFS，也可以用双向 BFS 优化搜索空间，从而提升效率。
 
 双向 BFS 是 BFS 常见的一个优化方法，主要实现思路如下：

solution/0100-0199/0127.Word Ladder/README_EN.md

@@ -46,7 +46,41 @@
 
 ## Solutions
 
-BFS.
+**Solution 1: BFS**
+
+BFS minimum step model. This problem can be solved with naive BFS, or it can be optimized with bidirectional BFS to reduce the search space and improve efficiency.
+
+Bidirectional BFS is a common optimization method for BFS, with the main implementation ideas as follows:
+
+1. Create two queues, q1 and q2, for "start -> end" and "end -> start" search directions, respectively.
+2. Create two hash maps, m1 and m2, to record the visited nodes and their corresponding expansion times (steps).
+3. During each search, prioritize the queue with fewer elements for search expansion. If a node visited from the other direction is found during the expansion, it means the shortest path has been found.
+4. If one of the queues is empty, it means that the search in the current direction cannot continue, indicating that the start and end points are not connected, and there is no need to continue the search.
+
+```python
+while q1 and q2:
+    if len(q1) <= len(q2):
+        # Prioritize the queue with fewer elements for expansion
+        extend(m1, m2, q1)
+    else:
+        extend(m2, m1, q2)
+
+
+def extend(m1, m2, q):
+    # New round of expansion
+    for _ in range(len(q)):
+        p = q.popleft()
+        step = m1[p]
+        for t in next(p):
+            if t in m1:
+                # Already visited before
+                continue
+            if t in m2:
+                # The other direction has been searched, indicating that a shortest path has been found
+                return step + 1 + m2[t]
+            q.append(t)
+            m1[t] = step + 1
+```
 
 <!-- tabs:start -->
 

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

@@ -36,23 +36,23 @@
 
 **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.
+First, we sort the array, then use a variable $t$ to record the current length of the consecutive sequence, and a variable $ans$ to record the length of the longest consecutive sequence.
 
-Then, we start to traverse the array from index $i=1$, for the current element $nums[i]$:
+Next, we start traversing the array from index $i=1$. For the current element $nums[i]$:
 
--   If $nums[i]=nums[i-1]$ , then the current element is duplicate, and we don't need to consider it;
--   If $nums[i]=nums[i-1]+1$ , then the current element can be connected to the previous continuous sequence to form a longer continuous sequence, so we update $t = t + 1$ and update the answer $ans = \max(ans, t)$;
--   Otherwise, the current element cannot be connected to the previous continuous sequence, so we reset $t$ to $1$.
+-   If $nums[i] = nums[i-1]$, it means the current element is repeated and does not need to be considered.
+-   If $nums[i] = nums[i-1] + 1$, it means the current element can be appended to the previous consecutive sequence to form a longer consecutive sequence. We update $t = t + 1$, and then update the answer $ans = \max(ans, t)$.
+-   Otherwise, it means the current element cannot be appended to the previous consecutive sequence, and we reset $t$ to $1$.
 
 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.
+The time complexity is $O(n \times \log n)$, and the space complexity is $O(\log n)$. Here, $n$ is the length of the array.
 
 **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.
+We use a hash table to store all elements in the array, and then traverse each element $x$ in the array. If the predecessor $x-1$ of the current element is not in the hash table, then we start with the current element and continuously try to match $x+1, x+2, x+3, \dots$, until no match is found. The length of the match at this time is the longest consecutive sequence length starting with $x$, and we update the answer accordingly.
 
-Time complexity $O(n)$, space complexity $O(n)$, where $n$ is the length of the array.
+The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the array.
 
 <!-- tabs:start -->
 

solution/0100-0199/0129.Sum Root to Leaf Numbers/README_EN.md

@@ -51,7 +51,18 @@ Therefore, sum = 495 + 491 + 40 = <code>1026</code>.
 
 ## Solutions
 
-DFS.
+**Solution 1: DFS**
+
+We can design a function $dfs(root, s)$, which represents the sum of all path numbers from the current node $root$ to the leaf nodes, given that the current path number is $s$. The answer is $dfs(root, 0)$.
+
+The calculation of the function $dfs(root, s)$ is as follows:
+
+-   If the current node $root$ is null, return $0$.
+-   Otherwise, add the value of the current node to $s$, i.e., $s = s \times 10 + root.val$.
+-   If the current node is a leaf node, return $s$.
+-   Otherwise, return $dfs(root.left, s) + dfs(root.right, s)$.
+
+The time complexity is $O(n)$, and the space complexity is $O(\log n)$. Here, $n$ is the number of nodes in the binary tree.
 
 <!-- tabs:start -->
 

solution/0100-0199/0191.Number of 1 Bits/README.md

@@ -262,12 +262,13 @@ int hammingWeight(uint32_t n) {
 ```
 
 ### **Typescript**
+
 ```ts
 function hammingWeight(n: number): number {
     let ans: number = 0;
     while (n !== 0) {
         ans++;
-        n &= (n - 1);
+        n &= n - 1;
     }
     return ans;
 }

solution/0100-0199/0191.Number of 1 Bits/README_EN.md

@@ -212,18 +212,18 @@ int hammingWeight(uint32_t n) {
 ```
 
 ### **Typescript**
+
 ```ts
 function hammingWeight(n: number): number {
     let ans: number = 0;
     while (n !== 0) {
         ans++;
-        n &= (n - 1);
+        n &= n - 1;
     }
     return ans;
 }
 ```
 
-
 ### **...**
 
 ```

solution/0100-0199/0191.Number of 1 Bits/solution.ts

@@ -1,8 +1,8 @@
-function hammingWeight(n: number): number {
-    let ans: number = 0;
-    while (n !== 0) {
-        ans++;
-        n &= (n - 1);
-    }
-    return ans;
-}
+function hammingWeight(n: number): number {
+    let ans: number = 0;
+    while (n !== 0) {
+        ans++;
+        n &= n - 1;
+    }
+    return ans;
+}

solution/2600-2699/2660.Determine the Winner of a Bowling Game/README.md

@@ -95,11 +95,7 @@ class Solution:
             return s
 
         a, b = f(player1), f(player2)
-        if a > b:
-            return 1
-        if b > a:
-            return 2
-        return 0
+        return 1 if a > b else (2 if b > a else 0)
 ```
 
 ### **Java**
@@ -130,18 +126,16 @@ class Solution {
 class Solution {
 public:
     int isWinner(vector<int>& player1, vector<int>& player2) {
+        auto f = [](vector<int>& arr) {
+            int s = 0;
+            for (int i = 0, n = arr.size(); i < n; ++i) {
+                int k = (i && arr[i - 1] == 10) || (i > 1 && arr[i - 2] == 10) ? 2 : 1;
+                s += k * arr[i];
+            }
+            return s;
+        };
         int a = f(player1), b = f(player2);
-        return a > b ? 1 : b > a ? 2
-                                 : 0;
-    }
-
-    int f(vector<int>& arr) {
-        int s = 0;
-        for (int i = 0; i < arr.size(); ++i) {
-            int k = (i > 0 && arr[i - 1] == 10) || (i > 1 && arr[i - 2] == 10) ? 2 : 1;
-            s += k * arr[i];
-        }
-        return s;
+        return a > b ? 1 : (b > a ? 2 : 0);
     }
 };
 ```
@@ -199,24 +193,22 @@ impl Solution {
     pub fn is_winner(player1: Vec<i32>, player2: Vec<i32>) -> i32 {
         let f = |arr: &Vec<i32>| -> i32 {
             let mut s = 0;
-
             for i in 0..arr.len() {
                 let mut k = 1;
                 if (i > 0 && arr[i - 1] == 10) || (i > 1 && arr[i - 2] == 10) {
                     k = 2;
                 }
                 s += k * arr[i];
             }
-
             s
         };
 
-        let p1 = f(&player1);
-        let p2 = f(&player2);
-        if p1 > p2 {
-            return 1;
-        } else if p1 < p2 {
-            return 2;
+        let a = f(&player1);
+        let b = f(&player2);
+        if a > b {
+            1
+        } else if a < b {
+            2
         } else {
             0
         }