feat: add solutions to lc problems

No.0021,0027,0031,0032,0036

Author: yanglbme

solution/0000-0099/0021.Merge Two Sorted Lists/README.md

@@ -47,9 +47,22 @@
 
 **方法一：递归**
 
+我们先判断链表 $l_1$ 和 $l_2$ 是否为空，若其中一个为空，则返回另一个链表。否则，我们比较 $l_1$ 和 $l_2$ 的头节点：
+
+-   若 $l_1$ 的头节点的值小于等于 $l_2$ 的头节点的值，则递归调用函数 $mergeTwoLists(l_1.next, l_2)$，并将 $l_1$ 的头节点与返回的链表头节点相连，返回 $l_1$ 的头节点。
+-   否则，递归调用函数 $mergeTwoLists(l_1, l_2.next)$，并将 $l_2$ 的头节点与返回的链表头节点相连，返回 $l_2$ 的头节点。
+
+时间复杂度 $O(m + n)$，空间复杂度 $O(m + n)$。其中 $m$ 和 $n$ 分别为两个链表的长度。
+
 **方法二：迭代**
 
-迭代遍历两链表，比较节点值 val 的大小，进行节点串联，得到最终链表。
+我们也可以用迭代的方式来实现两个排序链表的合并。
+
+我们先定义一个虚拟头节点 $dummy$，然后循环遍历两个链表，比较两个链表的头节点，将较小的节点添加到 $dummy$ 的末尾，直到其中一个链表为空，然后将另一个链表的剩余部分添加到 $dummy$ 的末尾。
+
+最后返回 $dummy.next$ 即可。
+
+时间复杂度 $O(m + n)$，其中 $m$ 和 $n$ 分别为两个链表的长度。忽略答案链表的空间消耗，空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
@@ -414,8 +427,6 @@ public class Solution {
 
 ### **TypeScript**
 
-递归：
-
 ```ts
 /**
  * Definition for singly-linked list.
@@ -446,8 +457,6 @@ function mergeTwoLists(
 }
 ```
 
-循环：
-
 ```ts
 /**
  * Definition for singly-linked list.
@@ -484,8 +493,6 @@ function mergeTwoLists(
 
 ### **Rust**
 
-递归：
-
 ```rust
 // Definition for singly-linked list.
 // #[derive(PartialEq, Eq, Clone, Debug)]
@@ -526,8 +533,6 @@ impl Solution {
 }
 ```
 
-循环：
-
 ```rust
 // Definition for singly-linked list.
 // #[derive(PartialEq, Eq, Clone, Debug)]

solution/0000-0099/0021.Merge Two Sorted Lists/README_EN.md

@@ -403,8 +403,6 @@ public class Solution {
 
 ### **TypeScript**
 
-Recursion：
-
 ```ts
 /**
  * Definition for singly-linked list.
@@ -435,8 +433,6 @@ function mergeTwoLists(
 }
 ```
 
-Loop：
-
 ```ts
 /**
  * Definition for singly-linked list.
@@ -473,8 +469,6 @@ function mergeTwoLists(
 
 ### **Rust**
 
-Recursion：
-
 ```rust
 // Definition for singly-linked list.
 // #[derive(PartialEq, Eq, Clone, Debug)]
@@ -515,8 +509,6 @@ impl Solution {
 }
 ```
 
-Loop：
-
 ```rust
 // Definition for singly-linked list.
 // #[derive(PartialEq, Eq, Clone, Debug)]

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

@@ -65,6 +65,16 @@ It does not matter what you leave beyond the returned k (hence they are undersco
 
 ## Solutions
 
+**Approach 1: One Pass**
+
+We use the variable $k$ to record the number of elements that are not equal to $val$.
+
+Traverse the array $nums$, if the current element $x$ is not equal to $val$, then assign $x$ to $nums[k]$, and increment $k$ by $1$.
+
+Finally, return $k$.
+
+The time complexity is $O(n)$ and the space complexity is $O(1)$, where $n$ is the length of the array $nums$.
+
 <!-- tabs:start -->
 
 ### **Python3**

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

@@ -62,7 +62,7 @@
 
 **方法一：两次遍历**
 
-从后往前遍历数组，找到第一个下降的位置 $i$，即 $nums[i] \lt nums[i + 1]$。
+我们先从后往前遍历数组，找到第一个下降的位置 $i$，即 $nums[i] \lt nums[i + 1]$。
 
 然后从后往前遍历数组，找到第一个大于 $nums[i]$ 的位置 $j$，即 $nums[j] \gt nums[i]$。交换 $nums[i]$ 和 $nums[j]$，然后将 $nums[i + 1]$ 到 $nums[n - 1]$ 的元素反转，即可得到下一个排列。
 

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

@@ -54,6 +54,14 @@
 
 ## Solutions
 
+**Approach 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]$.
+
+Then traverse the array from back to front again and find the first position $j$ where $nums[j] \gt nums[i]$. Swap $nums[i]$ and $nums[j]$, and then reverse the elements from $nums[i + 1]$ to $nums[n - 1]$, the next permutation can be obtained.
+
+The time complexity is $O(n)$ and the space complexity is $O(1)$. Where $n$ is the length of the array.
+
 <!-- tabs:start -->
 
 ### **Python3**

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

@@ -40,6 +40,33 @@
 
 ## Solutions
 
+**Approach 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])$.
+
+When $i \lt 2$, the length of the string is less than $2$, and there is no valid parentheses, so $f[i] = 0$.
+
+When $i \ge 2$, we consider the length of the longest valid parentheses that ends with $s[i-1]$, that is, $f[i]$:
+
+-   If $s[i-1]$ is a left parenthesis, then the length of the longest valid parentheses that ends with $s[i-1]$ must be $0$, so $f[i] = 0$.
+-   If $s[i-1]$ is a right parenthesis, there are the following two cases:
+    -   If $s[i-2]$ is a left parenthesis, then the length of the longest valid parentheses that ends with $s[i-1]$ is $f[i-2] + 2$.
+    -   If $s[i-2]$ is a right parenthesis, then the length of the longest valid parentheses that ends with $s[i-1]$ is $f[i-1] + 2$, but we also need to consider whether $s[i-f[i-1]-2]$ is a left parenthesis. If it is a left parenthesis, then the length of the longest valid parentheses that ends with $s[i-1]$ is $f[i-1] + 2 + f[i-f[i-1]-2]$.
+
+Therefore, we can get the state transition equation:
+
+$$
+\begin{cases}
+f[i] = 0, & \text{if } s[i-1] = '(',\\
+f[i] = f[i-2] + 2, & \text{if } s[i-1] = ')' \text{ and } s[i-2] = '(',\\
+f[i] = f[i-1] + 2 + f[i-f[i-1]-2], & \text{if } s[i-1] = ')' \text{ and } s[i-2] = ')' \text{ and } s[i-f[i-1]-2] = '(',\\
+\end{cases}
+$$
+
+Finally, we only need to return $max(f)$.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$, where $n$ is the length of the string.
+
 <!-- tabs:start -->
 
 ### **Python3**

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

@@ -64,6 +64,18 @@
 
 ## Solutions
 
+**Approach 1: Traversal once**
+
+The valid sudoku satisfies the following three conditions:
+
+-   The digits are not repeated in each row;
+-   The digits are not repeated in each column;
+-   The digits are not repeated in each $3 \times 3$ box.
+
+Traverse the sudoku, for each digit, check whether the row, column and $3 \times 3$ box it is in have appeared the digit. If it is, return `false`. If the traversal is over, return `true`.
+
+The time complexity is $O(C)$ and the space complexity is $O(C)$, where $C$ is the number of empty spaces in the sudoku. In this question, $C=81$.
+
 <!-- tabs:start -->
 
 ### **Python3**