feat: add solutions for lc problems (#5004)

Author: yanglbme

solution/3800-3899/3827.Count Monobit Integers/README.md

@@ -66,7 +66,13 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3800-3899/3827.Co
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：模拟
+
+根据题目描述，单比特整数，要么是 $0$，要么其二进制表示中所有位都是 $1$。
+
+因此，我们首先将 $0$ 计入答案中，然后从 $1$ 开始，依次生成二进制表示中所有位都是 $1$ 的整数，直到该整数大于 $n$ 为止。
+
+时间复杂度 $O(\log n)$，空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
@@ -79,7 +85,7 @@ class Solution:
         i = 1
         while x <= n:
             ans += 1
-            x += (1 << i)
+            x += 1 << i
             i += 1
         return ans
 ```

solution/3800-3899/3827.Count Monobit Integers/README_EN.md

@@ -64,7 +64,13 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3800-3899/3827.Co
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Simulation
+
+According to the problem description, a Monobit integer is either $0$, or its binary representation consists of all $1$s.
+
+Therefore, we first include $0$ in the answer, then starting from $1$, we sequentially generate integers whose binary representations consist of all $1$s, until the integer exceeds $n$.
+
+The time complexity is $O(\log n)$ and the space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
@@ -77,7 +83,7 @@ class Solution:
         i = 1
         while x <= n:
             ans += 1
-            x += (1 << i)
+            x += 1 << i
             i += 1
         return ans
 ```

solution/3800-3899/3827.Count Monobit Integers/Solution.py

@@ -4,6 +4,6 @@ def countMonobit(self, n: int) -> int:
         i = 1
         while x <= n:
             ans += 1
-            x += (1 << i)
+            x += 1 << i
             i += 1
         return ans

solution/3800-3899/3828.Final Element After Subarray Deletions/README.md

@@ -75,7 +75,13 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3800-3899/3828.Fi
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：脑筋急转弯
+
+由于 Alice 先手，Alice 可以选择移除除第一个元素和最后一个元素之外的所有元素，那么答案至少为 $\max(nums[0], nums[n - 1])$。
+
+而对于 $n = 1,2,..n-2$ 的情况，即便 Alice 想要保留这中间的某个元素，Bob 也可以选择移除它，因此答案至多为 $\max(nums[0], nums[n - 1])$。
+
+时间复杂度 $O(1)$，空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 

solution/3800-3899/3828.Final Element After Subarray Deletions/README_EN.md

@@ -73,7 +73,15 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3800-3899/3828.Fi
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Brain Teaser
+
+Since Alice goes first, Alice can choose to remove all elements except the first and last elements, so the answer is at least $\max(nums[0], nums[n - 1])$.
+
+For the cases of elements at indices $1, 2, ..., n-2$ (the middle elements), even if Alice wants to keep any of these middle elements, Bob can choose to remove it, so the answer is at most $\max(nums[0], nums[n - 1])$.
+
+Therefore, the answer is exactly $\max(nums[0], nums[n - 1])$.
+
+The time complexity is $O(1)$ and the space complexity is $O(1)$.
 
 <!-- tabs:start -->
 

solution/3800-3899/3829.Design Ride Sharing System/README.md

@@ -87,7 +87,20 @@ rideSharingSystem.matchDriverWithRider(); // 返回 [-1, -1]</div>
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：有序集合 + 哈希表
+
+我们使用两个有序集合 $\textit{riders}$ 和 $\textit{drivers}$ 分别存储等待的乘客和空闲的司机。其中，每个元素为一个二元组 $(t, \textit{id})$，表示该乘客/司机的 ID 以及其加入系统的时间戳 $t$。时间戳 $t$ 用于区分先后顺序，初始时 $t = 0$，每次添加乘客或司机时，$t$ 自增 $1$。
+
+此外，我们使用哈希表 $\textit{d}$ 存储每个乘客的 ID 和其时间戳的映射关系，方便在取消乘客请求时进行查找。
+
+具体地：
+
+- 在添加乘客时，我们将 $(t, \textit{riderId})$ 添加到 $\textit{riders}$ 中，并将 $\textit{d}[\textit{riderId}] = t$，然后将 $t$ 自增 $1$。
+- 在添加司机时，我们将 $(t, \textit{driverId})$ 添加到 $\textit{drivers}$ 中，然后将 $t$ 自增 $1$。
+- 在匹配司机和乘客时，如果 $\textit{riders}$ 或 $\textit{drivers}$ 为空，则返回 $[-1, -1]$。否则，我们分别取出 $\textit{riders}$ 和 $\textit{drivers}$ 中时间戳最小的元素 $(t_r, \textit{riderId})$ 和 $(t_d, \textit{driverId})$，将它们从各自的集合中移除，并返回 $[\textit{driverId}, \textit{riderId}]$。
+- 在取消乘客请求时，我们通过 $\textit{d}$ 查找该乘客的时间戳 $t$，然后将 $(t, \textit{riderId})$ 从 $\textit{riders}$ 中移除。
+
+时间复杂度为每次操作 $O(\log n)$，其中 $n$ 是当前乘客或司机的数量。空间复杂度为 $O(n)$。
 
 <!-- tabs:start -->
 

solution/3800-3899/3829.Design Ride Sharing System/README_EN.md

@@ -85,7 +85,20 @@ rideSharingSystem.matchDriverWithRider(); // returns [-1, -1]</div>
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Sorted Set + Hash Table
+
+We use two sorted sets $\textit{riders}$ and $\textit{drivers}$ to store waiting riders and available drivers respectively. Each element is a tuple $(t, \textit{id})$, representing the ID of the rider/driver and their timestamp $t$ when they joined the system. The timestamp $t$ is used to distinguish the order of arrival. Initially, $t = 0$, and each time a rider or driver is added, $t$ is incremented by $1$.
+
+Additionally, we use a hash table $\textit{d}$ to store the mapping between each rider's ID and their timestamp, which facilitates lookup when canceling a rider's request.
+
+Specifically:
+
+- When adding a rider, we add $(t, \textit{riderId})$ to $\textit{riders}$, set $\textit{d}[\textit{riderId}] = t$, and then increment $t$ by $1$.
+- When adding a driver, we add $(t, \textit{driverId})$ to $\textit{drivers}$ and then increment $t$ by $1$.
+- When matching a driver with a rider, if either $\textit{riders}$ or $\textit{drivers}$ is empty, we return $[-1, -1]$. Otherwise, we remove the elements with the smallest timestamps from both $\textit{riders}$ and $\textit{drivers}$, namely $(t_r, \textit{riderId})$ and $(t_d, \textit{driverId})$, and return $[\textit{driverId}, \textit{riderId}]$.
+- When canceling a rider's request, we look up the rider's timestamp $t$ through $\textit{d}$, and then remove $(t, \textit{riderId})$ from $\textit{riders}$.
+
+The time complexity is $O(\log n)$ per operation, where $n$ is the current number of riders or drivers. The space complexity is $O(n)$.
 
 <!-- tabs:start -->
 

solution/3800-3899/3830.Longest Alternating Subarray After Removing At Most One Element/README.md

@@ -96,7 +96,17 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3800-3899/3830.Lo
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：前后缀分解 + 枚举
+
+我们用两个数组 $l_1$ 和 $l_2$ 分别表示以位置 $i$ 结尾且最后一次比较为“<”和“>”的最长交替子数组的长度。同理，我们用 $r_1$ 和 $r_2$ 分别表示以位置 $i$ 开头且第一次比较为“<”和“>”的最长交替子数组的长度。
+
+我们可以通过一次从左到右的遍历计算出 $l_1$ 和 $l_2$，再通过一次从右到左的遍历计算出 $r_1$ 和 $r_2$。
+
+接下来，我们初始化答案为 $\max(\max(l_1), \max(l_2))$，表示不移除任何元素的情况下的最长交替子数组长度。
+
+然后，我们枚举要移除的元素位置 $i$，如果移除位置 $i$ 后，位置 $i-1$ 和位置 $i+1$ 仍然可以构成交替关系，那么我们可以将 $l_1[i-1]$ 和 $r_1[i+1]$（或 $l_2[i-1]$ 和 $r_2[i+1]$）相加，更新答案。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。
 
 <!-- tabs:start -->
 

solution/3800-3899/3830.Longest Alternating Subarray After Removing At Most One Element/README_EN.md

@@ -94,7 +94,17 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3800-3899/3830.Lo
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Prefix-Suffix Decomposition + Enumeration
+
+We use two arrays $l_1$ and $l_2$ to represent the length of the longest alternating subarray ending at position $i$ with the last comparison being "<" and ">", respectively. Similarly, we use $r_1$ and $r_2$ to represent the length of the longest alternating subarray starting at position $i$ with the first comparison being "<" and ">", respectively.
+
+We can compute $l_1$ and $l_2$ through a single left-to-right traversal, and then compute $r_1$ and $r_2$ through a single right-to-left traversal.
+
+Next, we initialize the answer as $\max(\max(l_1), \max(l_2))$, which represents the length of the longest alternating subarray without removing any elements.
+
+Then, we enumerate the position $i$ of the element to be removed. If after removing position $i$, positions $i-1$ and $i+1$ can still form an alternating relationship, we can add $l_1[i-1]$ and $r_1[i+1]$ (or $l_2[i-1]$ and $r_2[i+1]$) together to update the answer.
+
+The time complexity is $O(n)$ and the space complexity is $O(n)$.
 
 <!-- tabs:start -->