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

Author: yanglbme

solution/0100-0199/0117.Populating Next Right Pointers in Each Node II/README_EN.md

@@ -61,7 +61,7 @@ The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is
 
 **Solution 2: Space Optimization**
 
-The space complexity of Method 1 is relatively high because it requires a queue to store the nodes of each level. We can implement it with constant space.
+The space complexity of Solution 1 is relatively high because it requires a queue to store the nodes of each level. We can implement it with constant space.
 
 We define two pointers $prev$ and $next$, which point to the previous node and the first node of the next level, respectively. When traversing the nodes of the current level, we string the nodes of the next level together and find the first node of the next level. After the current level is traversed, we assign the first node $next$ of the next level to $node$ and continue to traverse.
 

solution/0200-0299/0207.Course Schedule/README_EN.md

@@ -44,6 +44,16 @@ To take course 1 you should have finished course 0, and to take course 0 you sho
 
 ## Solutions
 
+**Solution 1: Topological Sorting**
+
+For this problem, we can consider the courses as nodes in a graph, and prerequisites as edges in the graph. Thus, we can transform this problem into determining whether there is a cycle in the directed graph.
+
+Specifically, we can use the idea of topological sorting. For each node with an in-degree of $0$, we reduce the in-degree of its out-degree nodes by $1$, until all nodes have been traversed.
+
+If all nodes have been traversed, it means there is no cycle in the graph, and we can complete all courses; otherwise, we cannot complete all courses.
+
+The time complexity is $O(n + m)$, and the space complexity is $O(n + m)$. Here, $n$ and $m$ are the number of courses and prerequisites respectively.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/0200-0299/0209.Minimum Size Subarray Sum/README.md

@@ -70,7 +70,7 @@
 
 我们可以使用双指针 $j$ 和 $i$ 维护一个窗口，其中窗口中的所有元素之和小于 $target$。初始时 $j = 0$，答案 $ans = n + 1$，其中 $n$ 为数组 $nums$ 的长度。
 
-接下来，指针 $i$ 从 $0$ 开始向右移动，每次移动一步，我们将指针 $i$ 对应的元素加入窗口，同时更新窗口中元素之和。如果窗口中元素之和大于等于 $target$，说明当前子数组满足条件，我们可以更新答案，即 $ans = min(ans, i - j + 1)$。然后我们不断地从窗口中移除元素 $nums[j]$，直到窗口中元素之和小于 $target$，然后重复上述过程。
+接下来，指针 $i$ 从 $0$ 开始向右移动，每次移动一步，我们将指针 $i$ 对应的元素加入窗口，同时更新窗口中元素之和。如果窗口中元素之和大于等于 $target$，说明当前子数组满足条件，我们可以更新答案，即 $ans = \min(ans, i - j + 1)$。然后我们不断地从窗口中移除元素 $nums[j]$，直到窗口中元素之和小于 $target$，然后重复上述过程。
 
 最后，如果 $ans \leq n$，则说明存在满足条件的子数组，返回 $ans$，否则返回 $0$。
 

solution/0200-0299/0209.Minimum Size Subarray Sum/README_EN.md

@@ -43,9 +43,25 @@
 
 ## Solutions
 
-**Method 1: PreSum & Binary search**
+**Solution 1: Prefix Sum + Binary Search**
 
-**Method 2: Slide window**
+First, we preprocess the prefix sum array $s$ of the array $nums$, where $s[i]$ represents the sum of the first $i$ elements of the array $nums$. Since all elements in the array $nums$ are positive integers, the array $s$ is also monotonically increasing. Also, we initialize the answer $ans = n + 1$, where $n$ is the length of the array $nums$.
+
+Next, we traverse the prefix sum array $s$. For each element $s[i]$, we can find the smallest index $j$ that satisfies $s[j] \geq s[i] + target$ by binary search. If $j \leq n$, it means that there exists a subarray that satisfies the condition, and we can update the answer, i.e., $ans = min(ans, j - i)$.
+
+Finally, if $ans \leq n$, it means that there exists a subarray that satisfies the condition, return $ans$, otherwise return $0$.
+
+The time complexity is $O(n \times \log n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the array $nums$.
+
+**Solution 2: Two Pointers**
+
+We can use two pointers $j$ and $i$ to maintain a window, where the sum of all elements in the window is less than $target$. Initially, $j = 0$, and the answer $ans = n + 1$, where $n$ is the length of the array $nums$.
+
+Next, the pointer $i$ starts to move to the right from $0$, moving one step each time. We add the element corresponding to the pointer $i$ to the window and update the sum of the elements in the window. If the sum of the elements in the window is greater than or equal to $target$, it means that the current subarray satisfies the condition, and we can update the answer, i.e., $ans = \min(ans, i - j + 1)$. Then we continuously remove the element $nums[j]$ from the window until the sum of the elements in the window is less than $target$, and then repeat the above process.
+
+Finally, if $ans \leq n$, it means that there exists a subarray that satisfies the condition, return $ans$, otherwise return $0$.
+
+The time complexity is $O(n)$, and the space complexity is $O(1)$. Here, $n$ is the length of the array $nums$.
 
 <!-- tabs:start -->
 

solution/0300-0399/0367.Valid Perfect Square/README_EN.md

@@ -36,9 +36,9 @@
 
 ## Solutions
 
-**Method 1: Binary search**
+**Solution 1: Binary search**
 
-**Method 2: Math trick**
+**Solution 2: Math trick**
 
 This is a math problem：
 

solution/0600-0699/0619.Biggest Single Number/README_EN.md

@@ -85,7 +85,7 @@ We can first group the `MyNumbers` table by `num` and count the number of occurr
 
 **Solution 2: Grouping and `CASE` Expression**
 
-Similar to Method 1, we can first group the `MyNumbers` table by `num` and count the number of occurrences of each number. Then, we can use a `CASE` expression to find the numbers that appear only once, sort them in descending order by number, and take the first one.
+Similar to Solution 1, we can first group the `MyNumbers` table by `num` and count the number of occurrences of each number. Then, we can use a `CASE` expression to find the numbers that appear only once, sort them in descending order by number, and take the first one.
 
 <!-- tabs:start -->
 

solution/0600-0699/0658.Find K Closest Elements/README_EN.md

@@ -33,9 +33,9 @@
 
 ## Solutions
 
-**Method 1: Sort**
+**Solution 1: Sort**
 
-**Method 2: Binary search**
+**Solution 2: Binary search**
 
 <!-- tabs:start -->
 

solution/1000-1099/1099.Two Sum Less Than K/README_EN.md

@@ -46,7 +46,7 @@ The time complexity is $O(n \times \log n)$, and the space complexity is $O(\log
 
 **Solution 2: Sorting + Two Pointers**
 
-Similar to Method 1, we can first sort the array $nums$, and initialize the answer as $-1$.
+Similar to Solution 1, we can first sort the array $nums$, and initialize the answer as $-1$.
 
 Next, we use two pointers $i$ and $j$ to point to the left and right ends of the array, respectively. Each time we judge whether $s = nums[i] + nums[j]$ is less than $k$. If it is less than $k$, then we can update the answer, i.e., $ans = \max(ans, s)$, and move $i$ one step to the right, otherwise move $j$ one step to the left.
 

solution/1100-1199/1123.Lowest Common Ancestor of Deepest Leaves/README_EN.md

@@ -54,6 +54,17 @@ Note that nodes 6, 0, and 8 are also leaf nodes, but the depth of them is 2, but
 
 ## Solutions
 
+**Solution 1: DFS**
+
+We design a function `dfs(root)` that returns a tuple `(l, d)`, where `l` is the deepest common ancestor of node `root`, and `d` is the depth of node `root`. The execution logic of the function `dfs(root)` is as follows:
+
+-   If `root` is null, return the tuple `(None, 0)`;
+-   Otherwise, we recursively call `dfs(root.left)` and `dfs(root.right)`, obtaining tuples `(l, d1)` and `(r, d2)`. If `d1 > d2`, the deepest common ancestor of `root` is `l`, and the depth is `d1 + 1`; if `d1 < d2`, the deepest common ancestor of `root` is `r`, and the depth is `d2 + 1`; if `d1 = d2`, the deepest common ancestor of `root` is `root`, and the depth is `d1 + 1`.
+
+In the main function, we call `dfs(root)` and return the first element of its return value to get the deepest common ancestor node.
+
+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 -->
 
 ### **Python3**

solution/1100-1199/1124.Longest Well-Performing Interval/README.md

@@ -50,7 +50,7 @@
 接下来，我们遍历数组 `hours`，对于每个下标 $i$：
 
 -   如果 $hours[i] \gt 8$，我们就让 $s$ 加 $1$，否则减 $1$。
--   如果 $s$ 大于 $0$，说明从下标 $0$ 到当前下标的这一段，满足「表现良好的时间段」，我们更新结果 $ans = i + 1$。否则，如果 $s - 1$ 在哈希表 $pos$ 中，记 $j = pos[s - 1]$，说明从下标 $j + 1$ 到当前下标 $i$ 的这一段，满足「表现良好的时间段」，我们更新结果 $ans = max(ans, i - j)$。
+-   如果 $s$ 大于 $0$，说明从下标 $0$ 到当前下标的这一段，满足「表现良好的时间段」，我们更新结果 $ans = i + 1$。否则，如果 $s - 1$ 在哈希表 $pos$ 中，记 $j = pos[s - 1]$，说明从下标 $j + 1$ 到当前下标 $i$ 的这一段，满足「表现良好的时间段」，我们更新结果 $ans = \max(ans, i - j)$。
 -   然后，如果 $s$ 不在哈希表 $pos$ 中，我们就记录 $pos[s] = i$。
 
 遍历结束后，返回答案即可。