feat: update lc problems (#5116)

Author: yanglbme

solution/0600-0699/0602.Friend Requests II Who Has the Most Friends/README.md

@@ -76,7 +76,9 @@ RequestAccepted 表：
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：合并 + 分组
+
+我们可以将 `requester_id` 和 `accepter_id` 两列合并成一列，表示每个人的好友关系。然后对合并后的结果进行分组统计，找出拥有最多好友的人和好友数目。
 
 <!-- tabs:start -->
 

solution/0600-0699/0602.Friend Requests II Who Has the Most Friends/README_EN.md

@@ -42,7 +42,7 @@ This table contains the ID of the user who sent the request, the ID of the user
 <p><strong class="example">Example 1:</strong></p>
 
 <pre>
-<strong>Input:</strong> 
+<strong>Input:</strong>
 RequestAccepted table:
 +--------------+-------------+-------------+
 | requester_id | accepter_id | accept_date |
@@ -52,13 +52,13 @@ RequestAccepted table:
 | 2            | 3           | 2016/06/08  |
 | 3            | 4           | 2016/06/09  |
 +--------------+-------------+-------------+
-<strong>Output:</strong> 
+<strong>Output:</strong>
 +----+-----+
 | id | num |
 +----+-----+
 | 3  | 3   |
 +----+-----+
-<strong>Explanation:</strong> 
+<strong>Explanation:</strong>
 The person with id 3 is a friend of people 1, 2, and 4, so he has three friends in total, which is the most number than any others.
 </pre>
 
@@ -71,7 +71,9 @@ The person with id 3 is a friend of people 1, 2, and 4, so he has three friends
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Union All + Group By
+
+We can merge the `requester_id` and `accepter_id` columns into a single column, representing each person's friend relationships. Then we group the merged result and count, finding the person with the most friends and the number of friends.
 
 <!-- tabs:start -->
 

solution/0600-0699/0609.Find Duplicate File in System/README.md

@@ -85,13 +85,13 @@ tags:
 
 ### 方法一：哈希表
 
-我们创建哈希表 `d`，其中键是文件内容，值是具有相同内容的文件路径列表。
+我们创建一个哈希表 $d$，其中键是文件内容，值是具有相同内容的文件路径列表。
 
-遍历 `paths`，我们处理出每个文件的路径和内容，然后将其添加到哈希表 `d` 中。
+接下来，我们遍历 $\textit{paths}$，对于每个路径，我们将其分割成目录路径和文件信息。对于每个文件信息，我们提取出文件名和文件内容，并将文件路径添加到哈希表 $d$ 中对应文件内容的列表中。
 
-最后，我们返回哈希表 `d` 中所有具有多个文件路径的值。
+最后，我们返回哈希表 $d$ 中所有具有多个文件路径的值。
 
-时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为 `paths` 的长度。
+时间复杂度为 $O(n)$，空间复杂度为 $O(n)$，其中 $n$ 是 $\textit{paths}$ 的长度。
 
 <!-- tabs:start -->
 

solution/0600-0699/0609.Find Duplicate File in System/README_EN.md

@@ -73,7 +73,15 @@ tags:
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Hash Table
+
+We create a hash table $d$, where the key is the file content and the value is a list of file paths with the same content.
+
+Next, we iterate over $\textit{paths}$. For each path, we split it into the directory path and file information. For each file entry, we extract the file name and file content, and append the file path to the corresponding list in hash table $d$.
+
+Finally, we return all values in hash table $d$ that have more than one file path.
+
+The time complexity is $O(n)$ and the space complexity is $O(n)$, where $n$ is the length of $\textit{paths}$.
 
 <!-- tabs:start -->
 

solution/0600-0699/0630.Course Schedule III/README_EN.md

@@ -31,11 +31,11 @@ tags:
 <pre>
 <strong>Input:</strong> courses = [[100,200],[200,1300],[1000,1250],[2000,3200]]
 <strong>Output:</strong> 3
-Explanation: 
+Explanation:
 There are totally 4 courses, but you can take 3 courses at most:
 First, take the 1<sup>st</sup> course, it costs 100 days so you will finish it on the 100<sup>th</sup> day, and ready to take the next course on the 101<sup>st</sup> day.
-Second, take the 3<sup>rd</sup> course, it costs 1000 days so you will finish it on the 1100<sup>th</sup> day, and ready to take the next course on the 1101<sup>st</sup> day. 
-Third, take the 2<sup>nd</sup> course, it costs 200 days so you will finish it on the 1300<sup>th</sup> day. 
+Second, take the 3<sup>rd</sup> course, it costs 1000 days so you will finish it on the 1100<sup>th</sup> day, and ready to take the next course on the 1101<sup>st</sup> day.
+Third, take the 2<sup>nd</sup> course, it costs 200 days so you will finish it on the 1300<sup>th</sup> day.
 The 4<sup>th</sup> course cannot be taken now, since you will finish it on the 3300<sup>th</sup> day, which exceeds the closed date.
 </pre>
 
@@ -67,7 +67,15 @@ The 4<sup>th</sup> course cannot be taken now, since you will finish it on the 3
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Greedy + Priority Queue (Max-Heap)
+
+We can sort the courses in ascending order by their end time, and each time select the course with the earliest deadline to take.
+
+If the total time $s$ of the selected courses exceeds the end time $last$ of the current course, we remove the course with the longest duration from the previously selected courses, until the constraint of the current course's end time is satisfied. Here we use a priority queue (max-heap) $pq$ to maintain the durations of the currently selected courses, and each time we pop the course with the longest duration from the priority queue to remove it.
+
+Finally, the number of elements in the priority queue is the maximum number of courses we can take.
+
+The time complexity is $O(n \times \log n)$ and the space complexity is $O(n)$, where $n$ is the number of courses.
 
 <!-- tabs:start -->
 

solution/0600-0699/0640.Solve the Equation/README_EN.md

@@ -60,7 +60,18 @@ tags:
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Mathematics
+
+We split the $equation$ by the equal sign `"="` into left and right expressions, and compute the coefficient of `"x"` (denoted $x_i$) and the constant value (denoted $y_i$) for each side.
+
+The equation is then transformed into: $x_1 \times x + y_1 = x_2 \times x + y_2$.
+
+- When $x_1 = x_2$: if $y_1 \neq y_2$, there is no solution; if $y_1 = y_2$, there are infinite solutions.
+- When $x_1 \neq x_2$: there is a unique solution $x = \frac{y_2 - y_1}{x_1 - x_2}$.
+
+Similar problems:
+
+- [592. Fraction Addition and Subtraction](https://github.com/doocs/leetcode/blob/main/solution/0500-0599/0592.Fraction%20Addition%20and%20Subtraction/README_EN.md)
 
 <!-- tabs:start -->
 

solution/0600-0699/0641.Design Circular Deque/README.md

@@ -77,16 +77,25 @@ circularDeque.getFront();				// 返回 4
 
 ### 方法一：数组
 
-利用循环数组，实现循环双端队列。
+我们可以使用一个数组来实现循环双端队列。我们维护一个指向队头的指针 $\textit{front}$ 和一个表示队列中元素个数的变量 $\textit{size}$，以及一个表示队列容量的变量 $\textit{capacity}$。我们使用一个数组 $\textit{q}$ 来存储队列中的元素。
 
-基本元素有：
+调用 $\textit{insertFront}$ 时，首先检查队列是否已满，如果已满则返回 $\text{false}$。如果队列不为空，则将 $\textit{front}$ 向前移动一个位置（使用模运算实现循环），然后将新元素插入到 $\textit{front}$ 位置，并将 $\textit{size}$ 加 1。
 
-- front：队头元素的下标
-- size：队列中元素的个数
-- capacity：队列的容量
-- q：循环数组，存储队列中的元素
+调用 $\textit{insertLast}$ 时，首先检查队列是否已满，如果已满则返回 $\text{false}$。如果队列不为空，则计算新元素应该插入的位置（使用 $\textit{front}$ 和 $\textit{size}$ 计算），将新元素插入到该位置，并将 $\textit{size}$ 加 1。
 
-时间复杂度 $O(1)$，空间复杂度 $O(k)$。其中 $k$ 是队列的容量。
+调用 $\textit{deleteFront}$ 时，首先检查队列是否为空，如果为空则返回 $\text{false}$。如果队列不为空，则将 $\textit{front}$ 向后移动一个位置（使用模运算实现循环），并将 $\textit{size}$ 减 1。
+
+调用 $\textit{deleteLast}$ 时，首先检查队列是否为空，如果为空则返回 $\text{false}$。如果队列不为空，则将 $\textit{size}$ 减 1。
+
+调用 $\textit{getFront}$ 时，首先检查队列是否为空，如果为空则返回 $-1$。如果队列不为空，则返回 $\textit{q}[\textit{front}]$。
+
+调用 $\textit{getRear}$ 时，首先检查队列是否为空，如果为空则返回 $-1$。如果队列不为空，则计算队尾元素的位置（使用 $\textit{front}$ 和 $\textit{size}$ 计算），并返回该位置的元素。
+
+调用 $\textit{isEmpty}$ 时，检查 $\textit{size}$ 是否为 $0$。
+
+调用 $\textit{isFull}$ 时，检查 $\textit{size}$ 是否等于 $\textit{capacity}$。
+
+以上操作的时间复杂度均为 $O(1)$，空间复杂度为 $O(k)$，其中 $k$ 是队列的容量。
 
 <!-- tabs:start -->
 

solution/0600-0699/0641.Design Circular Deque/README_EN.md

@@ -73,7 +73,27 @@ myCircularDeque.getFront();     // return 4
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Array
+
+We can use an array to implement the circular deque. We maintain a pointer $\textit{front}$ pointing to the front of the queue, a variable $\textit{size}$ representing the number of elements in the queue, and a variable $\textit{capacity}$ representing the queue's capacity. We use an array $\textit{q}$ to store the elements.
+
+When $\textit{insertFront}$ is called, we first check if the queue is full; if so, return $\text{false}$. Otherwise, we move $\textit{front}$ one position forward (using modular arithmetic for circular wrapping), insert the new element at $\textit{front}$, and increment $\textit{size}$ by 1.
+
+When $\textit{insertLast}$ is called, we first check if the queue is full; if so, return $\text{false}$. Otherwise, we compute the insertion position (using $\textit{front}$ and $\textit{size}$), insert the new element there, and increment $\textit{size}$ by 1.
+
+When $\textit{deleteFront}$ is called, we first check if the queue is empty; if so, return $\text{false}$. Otherwise, we move $\textit{front}$ one position backward (using modular arithmetic for circular wrapping) and decrement $\textit{size}$ by 1.
+
+When $\textit{deleteLast}$ is called, we first check if the queue is empty; if so, return $\text{false}$. Otherwise, we decrement $\textit{size}$ by 1.
+
+When $\textit{getFront}$ is called, we first check if the queue is empty; if so, return $-1$. Otherwise, we return $\textit{q}[\textit{front}]$.
+
+When $\textit{getRear}$ is called, we first check if the queue is empty; if so, return $-1$. Otherwise, we compute the position of the rear element (using $\textit{front}$ and $\textit{size}$) and return the element at that position.
+
+When $\textit{isEmpty}$ is called, we check whether $\textit{size}$ equals $0$.
+
+When $\textit{isFull}$ is called, we check whether $\textit{size}$ equals $\textit{capacity}$.
+
+All operations above have a time complexity of $O(1)$ and a space complexity of $O(k)$, where $k$ is the capacity of the deque.
 
 <!-- tabs:start -->