feat: add solutions to lc problems: No.0001~0007

Author: yanglbme

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

@@ -57,9 +57,9 @@
 
 **方法一：哈希表**
 
-我们可以用哈希表（字典） $m$ 存放数组值以及对应的下标。
+我们可以用哈希表 $m$ 存放数组值以及对应的下标。
 
-遍历数组 `nums`，当发现 `target - nums[i]` 在哈希表中，说明找到了目标值，返回 `target - nums[i]` 的下标和 `i` 即可。
+遍历数组 `nums`，当发现 `target - nums[i]` 在哈希表中，说明找到了目标值，返回 `target - nums[i]` 的下标以及 $i$ 即可。
 
 时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是数组 `nums` 的长度。
 

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

@@ -48,6 +48,14 @@
 
 ## Solutions
 
+**Approach 1: Hash Table**
+
+We can use the hash table $m$ to store the array value and the corresponding subscript.
+
+Traverse the array `nums`, when you find `target - nums[i]` in the hash table, it means that the target value is found, and the index of `target - nums[i]` and $i$ are returned.
+
+The time complexity is $O(n)$ and the space complexity is $O(n)$. Where $n$ is the length of the array `nums`.
+
 <!-- tabs:start -->
 
 ### **Python3**

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

@@ -52,9 +52,13 @@
 
 **方法一：模拟**
 
-同时遍历两个链表 `l1`, `l2`，对应节点值相加，进位记为 `carry`。当 `l1`, `l2` 同时遍历结束，并且 `carry` 为 `0` 时，结束遍历。
+我们同时遍历两个链表 $l_1$ 和 $l_2$，并使用变量 $carry$ 表示当前是否有进位。
 
-时间复杂度 $O(\max(m, n))$，其中 $m$, $n$ 分别表示两个链表的长度。忽略结果链表的空间消耗，空间复杂度 $O(1)$。
+每次遍历时，我们取出对应链表的当前位，计算它们与进位 $carry$ 的和，然后更新进位的值，最后将当前位的值加入答案链表。如果两个链表都遍历完了，并且进位为 $0$ 时，遍历结束。
+
+最后我们返回答案链表的头节点即可。
+
+时间复杂度 $O(max(m, n))$，其中 $m$ 和 $n$ 分别为两个链表的长度。我们需要遍历两个链表的全部位置，而处理每个位置只需要 $O(1)$ 的时间。忽略答案的空间消耗，空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 

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

@@ -42,6 +42,16 @@
 
 ## Solutions
 
+**Approach 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.
+
+Each time we traverse, we take out the current bit of the corresponding linked list, calculate the sum with the carry $carry$, and then update the value of the carry. Then we add the current bit to the answer linked list. If both linked lists are traversed, and the carry is $0$, the traversal ends.
+
+Finally, we return the head node of the answer linked list.
+
+The time complexity is $O(max (m, n))$, where $m$ and $n$ are the lengths of the two linked lists. We need to traverse the entire position of the two linked lists, and each position only needs $O(1)$ time. Ignoring the space consumption of the answer, the space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

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

@@ -42,6 +42,27 @@ Notice that the answer must be a substring, "pwke" is a subsequence an
 
 ## Solutions
 
+**Approach 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`.
+
+For each character $s[j]$ in the string `s`, we call it $c$. If $c$ exists in the window $s[i..j-1]$, we move $i$ to the right until $s[i..j-1]$ does not contain `c`. Then we add `c` to the hash table. At this time, the window $s[i..j]$ does not contain repeated elements, and we update the maximum value of `ans`.
+
+Finally, return `ans`.
+
+The time complexity is $O(n)$, where $n$ represents the length of the string `s`.
+
+Two pointers algorithm template:
+
+```java
+for (int i = 0, j = 0; i < n; ++i) {
+    while (j < i && check(j, i)) {
+        ++j;
+    }
+    // logic of specific problem
+}
+```
+
 <!-- tabs:start -->
 
 ### **Python3**

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

@@ -32,7 +32,20 @@
 
 ## Solutions
 
-Dynamic programming.
+**Approach 1: Dynamic Programming**
+
+Set $dp[i][j]$ to indicate whether the string $s[i..j]$ is a palindrome.
+
+- When $j - i \lt 2$, that is, the string length is `2`, as long as $s[i] == s[j]$, then $dp[i][j]$ is `true`.
+- When $j - i \ge 2$, there is $dp[i][j] = dp[i + 1][j - 1] \cap s[i] == s[j]$.
+
+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**
+
+We can enumerate the palindrome center, spread to both sides, and find the longest palindrome.
+
+The time complexity is $O(n^2)$ and the space complexity is $O(1)$. Where $n$ is the length of the string $s$.
 
 <!-- tabs:start -->
 

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

@@ -58,6 +58,14 @@ P     I
 
 ## Solutions
 
+**Approach 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.
+
+We traverse the string $s$ from left to right. Each time we traverse a character $c$, we append it to $g[i]$. If at this time $i=0$ or $i=numRows-1$, it means that the current character is at the turning point of the $Z$-shaped arrangement. We reverse the value of $k$, that is, $k=-k$. Next, we update the value of $i$ to $i+k$, that is, move up or down one row. Continue to traverse the next character until the string $s$ is traversed. We return the string that all rows in $g$ are concatenated.
+
+Time complexity $O(n)$, space complexity $O(n)$, where $n$ is the length of the string $s$.
+
 <!-- tabs:start -->
 
 ### **Python3**

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

@@ -39,9 +39,27 @@
 
 ## Solutions
 
-**Approach 1: Pop and Push Digits & Check before Overflow**
+**Approach 1: Mathematical**
 
-Time complexity $O(log|x|)$, Space complexity $O(1)$.
+Let $mi$ and $mx$ be $-2^{31}$ and $2^{31} - 1$ respectively. The reversed result $ans$ needs to satisfy $mi \le ans \le mx$.
+
+We can get the last digit $y$ of $x$ by repeatedly taking the remainder of $x$ by $10$, and then add $y$ to the end of $ans$. Before adding $y$, we need to determine whether $ans$ will overflow. That is, whether $ans \times 10 + y$ is within the range $[mi, mx]$.
+
+If $x \gt 0$, then $ans \times 10 + y \leq mx$ should be satisfied. That is, $ans \times 10 + y \leq \left \lfloor \frac{mx}{10} \right \rfloor \times 10 + 7$. Rearrange to get $(ans - \left \lfloor \frac{mx}{10} \right \rfloor) \times 10 \leq 7 - y$.
+
+The following conditions need to be satisfied for the above inequality to hold:
+
+-   When $ans \lt \left \lfloor \frac{mx}{10} \right \rfloor$, the inequality obviously holds;
+-   When $ans = \left \lfloor \frac{mx}{10} \right \rfloor$, the necessary and sufficient conditions for the above inequality to hold are $y \leq 7$. If $ans = \left \lfloor \frac{mx}{10} \right \rfloor$ and can still continue to add digits, it means that the current digit is the most significant digit. Therefore, $y$ must be less than or equal to $2$, so the inequality must hold;
+-   When $ans \gt \left \lfloor \frac{mx}{10} \right \rfloor$, the inequality obviously does not hold.
+
+Therefore, when $x \gt 0$, the necessary and sufficient conditions for the inequality to hold are $ans \leq \left \lfloor \frac{mx}{10} \right \rfloor$.
+
+Similarly, when $x \lt 0$, the necessary and sufficient conditions for the inequality to hold are $ans \geq \left \lfloor \frac{mi}{10} \right \rfloor$.
+
+Therefore, we can determine whether $ans$ will overflow by determining whether $ans$ is within the range $[\left \lfloor \frac{mi}{10} \right \rfloor, \left \lfloor \frac{mx}{10} \right \rfloor]$. If so, return $0$. Otherwise, add $y$ to the end of $ans$, and then remove the last digit of $x$, that is, $x \gets \left \lfloor \frac{x}{10} \right \rfloor$.
+
+Time complexity $O(\log |x|)$, where $|x|$ is the absolute value of $x$. Space complexity $O(1)$.
 
 <!-- tabs:start -->