feat: add solutions to lc problems: No.1844+ (doocs#2128)

Author: yanglbme

solution/1800-1899/1844.Replace All Digits with Characters/README_EN.md

@@ -49,6 +49,14 @@
 
 ## Solutions
 
+**Solution 1: Simulation**
+
+Traverse the string, for characters at odd indices, replace them with the character that is a certain number of positions after the previous character.
+
+Finally, return the replaced string.
+
+The time complexity is $O(n)$, where $n$ is the length of the string $s$. Ignoring the space consumption of the answer, the space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1800-1899/1845.Seat Reservation Manager/README_EN.md

@@ -49,6 +49,18 @@ seatManager.unreserve(5); // Unreserve seat 5, so now the available seats are [5
 
 ## Solutions
 
+**Solution 1: Priority Queue (Min Heap)**
+
+We can use a priority queue (min heap) to maintain the smallest number of reservable seats.
+
+Initially, put all seat numbers into the priority queue.
+
+When the `reserve` method is called, take out the smallest number from the priority queue, which is the smallest number of reservable seats.
+
+When the `unreserve` method is called, put the seat number back into the priority queue.
+
+The time complexity is $O(n \times \log n)$, and the space complexity is $O(n)$. Where $n$ is the number of seats.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1800-1899/1846.Maximum Element After Decreasing and Rearranging/README.md

@@ -71,6 +71,14 @@ arr 中最大元素为 3 。
 
 **方法一：排序 + 贪心**
 
+我们先对数组进行排序，然后将数组的第一个元素设置为 $1$。
+
+接下来，我们从第二个元素开始遍历数组，如果当前元素与前一个元素的差值大于 $1$，我们就贪心地将当前元素减小为前一个元素加 $1$。
+
+最后，我们返回数组中的最大元素。
+
+时间复杂度 $O(n \times \log n)$，空间复杂度 $O(\log n)$。其中 $n$ 为数组长度。
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1800-1899/1846.Maximum Element After Decreasing and Rearranging/README_EN.md

@@ -63,6 +63,16 @@ The largest element in <code>arr is 3.</code>
 
 ## Solutions
 
+**Solution 1: Sorting + Greedy Algorithm**
+
+First, we sort the array and then set the first element of the array to $1$.
+
+Next, we start traversing the array from the second element. If the difference between the current element and the previous one is more than $1$, we greedily reduce the current element to the previous element plus $1$.
+
+Finally, we return the maximum element in the array.
+
+The time complexity is $O(n \times \log n)$, and the space complexity is $O(\log n)$. Where $n$ is the length of the array.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1800-1899/1847.Closest Room/README_EN.md

@@ -52,6 +52,16 @@ Query = [2,5]: Room number 3 is the only room with a size of at least 5. The ans
 
 ## Solutions
 
+**Solution 1: Offline Query + Ordered Set + Binary Search**
+
+We notice that the order of queries does not affect the answer, and the problem involves the size relationship of room areas. Therefore, we can sort the queries in ascending order of minimum area, so that we can process each query from small to large. Also, we sort the rooms in ascending order of area.
+
+Next, we create an ordered list and add all room numbers to the ordered list.
+
+Then, we process each query from small to large. For each query, we first remove all rooms with an area less than or equal to the current query's minimum area from the ordered list. Then, in the remaining rooms, we use binary search to find the room number closest to the current query. If there is no such room, we return $-1$.
+
+The time complexity is $O(n \times \log n + k \times \log k)$, and the space complexity is $O(n + k)$. Where $n$ and $k$ are the number of rooms and queries, respectively.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1800-1899/1848.Minimum Distance to the Target Element/README.md

@@ -55,9 +55,9 @@
 
 **方法一：一次遍历**
 
-遍历数组，找到所有等于 `target` 的下标，然后计算 `abs(i - start)`，取最小值即可。
+遍历数组，找到所有等于 $target$ 的下标，然后计算 $|i - start|$，取最小值即可。
 
-时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为数组 `nums` 的长度。
+时间复杂度 $O(n)$，其中 $n$ 为数组 $nums$ 的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 

solution/1800-1899/1848.Minimum Distance to the Target Element/README_EN.md

@@ -47,6 +47,12 @@
 
 ## Solutions
 
+**Solution 1: Single Pass**
+
+Traverse the array, find all indices equal to $target$, then calculate $|i - start|$, and take the minimum value.
+
+The time complexity is $O(n)$, where $n$ is the length of the array $nums$. The space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1800-1899/1849.Splitting a String Into Descending Consecutive Values/README_EN.md

@@ -53,6 +53,12 @@ The values are in descending order with adjacent values differing by 1.
 
 ## Solutions
 
+**Solution 1: DFS (Depth-First Search)**
+
+Starting from the first character of the string, enumerate all possible split positions. Check if the split substring meets the requirements of the problem. If it does, continue to recursively check whether the remaining substring meets the requirements, until the entire string is traversed.
+
+The time complexity is $O(n^2)$, and the space complexity is $O(n)$. Where $n$ is the length of the string.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1800-1899/1851.Minimum Interval to Include Each Query/README_EN.md

@@ -48,6 +48,22 @@
 
 ## Solutions
 
+**Solution 1: Sorting + Offline Query + Priority Queue (Min Heap)**
+
+We notice that the order of queries does not affect the answer, and the intervals involved do not change. Therefore, we consider sorting all queries in ascending order, and sorting all intervals in ascending order of the left endpoint.
+
+We use a priority queue (min heap) $pq$ to maintain all current intervals. Each element in the queue is a pair $(v, r)$, representing an interval with length $v$ and right endpoint $r$. Initially, the priority queue is empty. In addition, we define a pointer $i$ that points to the current interval being traversed, and initially $i=0$.
+
+We traverse each query $(x, j)$ in ascending order and perform the following operations:
+
+-   If the pointer $i$ has not traversed all intervals, and the left endpoint of the current interval $[a, b]$ is less than or equal to $x$, then we add this interval to the priority queue and move the pointer $i$ one step forward. Repeat this process.
+-   If the priority queue is not empty, and the right endpoint of the heap top element is less than $x$, then we pop the heap top element. Repeat this process.
+-   At this point, if the priority queue is not empty, then the heap top element is the smallest interval containing $x$. We add its length $v$ to the answer array $ans$.
+
+After the above process is over, we return the answer array $ans$.
+
+The time complexity is $O(n \times \log n + m \times \log m)$, and the space complexity is $O(n + m)$. Where $n$ and $m$ are the lengths of the arrays `intervals` and `queries` respectively.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1800-1899/1852.Distinct Numbers in Each Subarray/README_EN.md

@@ -44,6 +44,12 @@
 
 ## Solutions
 
+**Solution 1: Sliding Window + Hash Table/Array**
+
+Use an array or hash table to record the occurrence of numbers in each subarray of size $k$. Then traverse the array, update the hash table each time, and record the number of types of numbers in the current window.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$. Where $n$ is the length of the array.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1800-1899/1854.Maximum Population Year/README_EN.md

@@ -38,6 +38,14 @@ The earlier year between them is 1960.</pre>
 
 ## Solutions
 
+**Solution 1: Difference Array**
+
+We notice that the range of years is $[1950,..2050]$. Therefore, we can map these years to an array $d$ of length $101$, where the index of the array represents the value of the year minus $1950$.
+
+Next, we traverse $logs$. For each person, we increment $d[birth_i - 1950]$ by $1$ and decrement $d[death_i - 1950]$ by $1$. Finally, we traverse the array $d$, find the maximum value of the prefix sum, which is the year with the most population, and add $1950$ to get the answer.
+
+The time complexity is $O(n)$, and the space complexity is $O(C)$. Where $n$ is the length of the array $logs$, and $C$ is the range size of the years, i.e., $2050 - 1950 + 1 = 101$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1800-1899/1855.Maximum Distance Between a Pair of Values/README.md

@@ -59,17 +59,17 @@
 
 **方法一：二分查找**
 
-假设 `nums1`、`nums2` 的长度分别为 $m$ 和 $n$。
+假设 $nums1$, $nums2$ 的长度分别为 $m$ 和 $n$。
 
-遍历数组 `nums1`，对于每个数字 `nums1[i]`，二分查找 `nums2` 在 $[i,n)$ 范围内的数字，找到**最后一个**大于等于 `nums1[i]` 的位置 $j$，计算此位置与 $i$ 的距离，并更新最大距离值 `ans`。
+遍历数组 $nums1$，对于每个数字 $nums1[i]$，二分查找 $nums2$ 在 $[i,n)$ 范围内的数字，找到**最后一个**大于等于 $nums1[i]$ 的位置 $j$，计算此位置与 $i$ 的距离，并更新最大距离值 $ans$。
 
-时间复杂度 $O(m\log n)$，其中 $m$ 和 $n$ 分别为 `nums1` 和 `nums2` 的长度。
+时间复杂度 $O(m \times \log n)$，其中 $m$ 和 $n$ 分别为 $nums1$ 和 $nums2$ 的长度。空间复杂度 $O(1)$。
 
 **方法二：双指针**
 
-在方法一中，我们只利用到 `nums2` 是非递增数组这一条件，实际上，`nums1` 也是非递增数组，我们可以用双指针 $i$ 和 $j$ 来遍历 `nums1` 和 `nums2`。
+在方法一中，我们只利用到 $nums2$ 是非递增数组这一条件，实际上，$nums1$ 也是非递增数组，我们可以用双指针 $i$ 和 $j$ 来遍历 $nums1$ 和 $nums2$。
 
-时间复杂度 $O(m+n)$。
+时间复杂度 $O(m+n)$，其中 $m$ 和 $n$ 分别为 $nums1$ 和 $nums2$ 的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 

solution/1800-1899/1855.Maximum Distance Between a Pair of Values/README_EN.md

@@ -51,7 +51,13 @@ The maximum distance is 2 with pair (2,4).
 
 ## Solutions
 
-Binary search.
+**Solution 1: Binary Search**
+
+Assume the lengths of $nums1$ and $nums2$ are $m$ and $n$ respectively.
+
+Traverse array $nums1$, for each number $nums1[i]$, perform a binary search for numbers in $nums2$ in the range $[i,n)$, find the **last** position $j$ that is greater than or equal to $nums1[i]$, calculate the distance between this position and $i$, and update the maximum distance value $ans$.
+
+The time complexity is $O(m \times \log n)$, where $m$ and $n$ are the lengths of $nums1$ and $nums2$ respectively. The space complexity is $O(1)$.
 
 <!-- tabs:start -->
 

solution/1800-1899/1856.Maximum Subarray Min-Product/README_EN.md

@@ -54,6 +54,16 @@
 
 ## Solutions
 
+**Solution 1: Monotonic Stack + Prefix Sum**
+
+We can enumerate each element $nums[i]$ as the minimum value of the subarray, and find the left and right boundaries $left[i]$ and $right[i]$ of the subarray. Where $left[i]$ represents the first position strictly less than $nums[i]$ on the left side of $i$, and $right[i]$ represents the first position less than or equal to $nums[i]$ on the right side of $i$.
+
+To conveniently calculate the sum of the subarray, we can preprocess the prefix sum array $s$, where $s[i]$ represents the sum of the first $i$ elements of $nums$.
+
+Then the minimum product with $nums[i]$ as the minimum value of the subarray is $nums[i] \times (s[right[i]] - s[left[i] + 1])$. We can enumerate each element $nums[i]$, find the minimum product with $nums[i]$ as the minimum value of the subarray, and then take the maximum value.
+
+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**