feat: add solutions to lc problems (doocs#2089)

Author: yanglbme

solution/2300-2399/2300.Successful Pairs of Spells and Potions/README_EN.md

@@ -48,6 +48,12 @@ Thus, [2,0,2] is returned.
 
 ## Solutions
 
+**Solution 1: Sorting + Binary Search**
+
+We can sort the potion array, then traverse the spell array. For each spell $v$, we use binary search to find the first potion that is greater than or equal to $\frac{success}{v}$. We mark its index as $i$. The length of the potion array minus $i$ is the number of potions that can successfully combine with this spell.
+
+The time complexity is $O((m + n) \times \log m)$, and the space complexity is $O(\log n)$. Here, $m$ and $n$ are the lengths of the potion array and the spell array, respectively.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2300-2399/2301.Match Substring After Replacement/README_EN.md

@@ -58,6 +58,22 @@ Now sub = "l33tb" is a substring of s, so we return true.
 
 ## Solutions
 
+**Solution 1: Hash Table + Enumeration**
+
+First, we use a hash table $d$ to record the set of characters that each character can be replaced with.
+
+Then we enumerate all substrings of length $sub$ in $s$, and judge whether the string $sub$ can be obtained by replacement. If it can, return `true`, otherwise enumerate the next substring.
+
+At the end of the enumeration, it means that $sub$ cannot be obtained by replacing any substring in $s$, so return `false`.
+
+The time complexity is $O(m \times n)$, and the space complexity is $O(C^2)$. Here, $m$ and $n$ are the lengths of the strings $s$ and $sub$ respectively, and $C$ is the size of the character set.
+
+**Solution 2: Array + Enumeration**
+
+Since the character set only contains uppercase and lowercase English letters and numbers, we can directly use a $128 \times 128$ array $d$ to record the set of characters that each character can be replaced with.
+
+The time complexity is $O(m \times n)$, and the space complexity is $O(C^2)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2300-2399/2302.Count Subarrays With Score Less Than K/README.md

@@ -60,17 +60,17 @@
 
 **方法一：前缀和 + 二分查找**
 
-我们先计算出数组 `nums` 的前缀和数组 $s$，其中 $s[i]$ 表示数组 `nums` 前 $i$ 个元素的和。
+我们先计算出数组 $nums$ 的前缀和数组 $s$，其中 $s[i]$ 表示数组 $nums$ 前 $i$ 个元素的和。
 
-接下来，我们枚举数组 `nums` 每个元素作为子数组的最后一个元素，对于每个元素，我们可以通过二分查找的方式找到最大的长度 $l$，使得 $s[i] - s[i - l] \times l < k$。那么以该元素为最后一个元素的子数组个数即为 $l$，我们将所有的 $l$ 相加即为答案。
+接下来，我们枚举数组 $nums$ 每个元素作为子数组的最后一个元素，对于每个元素，我们可以通过二分查找的方式找到最大的长度 $l$，使得 $s[i] - s[i - l] \times l < k$。那么以该元素为最后一个元素的子数组个数即为 $l$，我们将所有的 $l$ 相加即为答案。
 
-时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 `nums` 的长度。
+时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $nums$ 的长度。
 
 **方法二：双指针**
 
 我们可以使用双指针的方式，维护一个滑动窗口，使得窗口内的元素和小于 $k$。那么以当前元素为最后一个元素的子数组个数即为窗口的长度，我们将所有的窗口长度相加即为答案。
 
-时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为数组 `nums` 的长度。
+时间复杂度 $O(n)$，其中 $n$ 为数组 $nums$ 的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 

solution/2300-2399/2302.Count Subarrays With Score Less Than K/README_EN.md

@@ -52,6 +52,20 @@ Thus, there are 5 subarrays having scores less than 5.
 
 ## Solutions
 
+**Solution 1: Prefix Sum + Binary Search**
+
+First, we calculate the prefix sum array $s$ of the array $nums$, where $s[i]$ represents the sum of the first $i$ elements of the array $nums$.
+
+Next, we enumerate each element of the array $nums$ as the last element of the subarray. For each element, we can find the maximum length $l$ such that $s[i] - s[i - l] \times l < k$ by binary search. The number of subarrays with this element as the last element is $l$, and we add all $l$ to get the answer.
+
+The time complexity is $O(n \times \log n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the array $nums$.
+
+**Solution 2: Two Pointers**
+
+We can use two pointers to maintain a sliding window, so that the sum of the elements in the window is less than $k$. The number of subarrays with the current element as the last element is the length of the window, and we add all window lengths to get the answer.
+
+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/2300-2399/2303.Calculate Amount Paid in Taxes/README.md

@@ -70,9 +70,9 @@
 
 **方法一：模拟**
 
-遍历 `brackets`，对于每个税级，计算该税级的税额，然后累加即可。
+我们遍历 `brackets`，对于每个税级，计算该税级的税额，然后累加即可。
 
-时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为 `brackets` 的长度。
+时间复杂度 $O(n)$，其中 $n$ 为 `brackets` 的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 

solution/2300-2399/2303.Calculate Amount Paid in Taxes/README_EN.md

@@ -64,6 +64,12 @@ You have no income to tax, so you have to pay a total of 0 in taxes.
 
 ## Solutions
 
+**Solution 1: Simulation**
+
+We traverse `brackets`, and for each tax bracket, we calculate the tax amount for that bracket, then accumulate it.
+
+The time complexity is $O(n)$, where $n$ is the length of `brackets`. The space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2300-2399/2305.Fair Distribution of Cookies/README_EN.md

@@ -47,6 +47,14 @@ It can be shown that there is no distribution with an unfairness less than 7.
 
 ## Solutions
 
+**Solution 1: Backtracking + Pruning**
+
+First, we sort the array $cookies$ in descending order (to reduce the number of searches), and then create an array $cnt$ of length $k$ to store the number of cookies each child gets. Also, we use a variable $ans$ to maintain the current minimum degree of unfairness, initialized to a very large value.
+
+Next, we start from the first snack pack. For the current snack pack $i$, we enumerate each child $j$. If the cookies $cookies[i]$ in the current snack pack are given to child $j$, making the degree of unfairness greater than or equal to $ans$, or the number of cookies the current child already has is the same as the previous child, then we don't need to consider giving the cookies in the current snack pack to child $j$, just skip it (pruning). Otherwise, we give the cookies $cookies[i]$ in the current snack pack to child $j$, and then continue to consider the next snack pack. When we have considered all the snack packs, we update the value of $ans$, then backtrack to the previous snack pack, and continue to enumerate which child to give the cookies in the current snack pack to.
+
+Finally, we return $ans$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2300-2399/2309.Greatest English Letter in Upper and Lower Case/README.md

@@ -70,7 +70,7 @@
 
 接下来我们只要获取 $mask$ 的二进制表示中最高位的 $1$ 的位置，将其转换为对应的大写字母即可。如果所有二进制位都不为 $1$，说明不存在大小写同时出现的字母，返回空字符串。
 
-时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 是字符串 $s$ 的长度。
+时间复杂度 $O(n)$，其中 $n$ 是字符串 $s$ 的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 

solution/2300-2399/2309.Greatest English Letter in Upper and Lower Case/README_EN.md

@@ -47,6 +47,24 @@ There is no letter that appears in both lower and upper case.
 
 ## Solutions
 
+**Solution 1: Hash Table + Enumeration**
+
+First, we use a hash table $ss$ to record all the letters that appear in the string $s$. Then we start enumerating from the last letter of the uppercase alphabet. If both the uppercase and lowercase forms of the current letter are in $ss$, we return that letter.
+
+At the end of the enumeration, if no letter that meets the conditions is found, we return an empty string.
+
+The time complexity is $O(n)$, and the space complexity is $O(C)$. Here, $n$ and $C$ are the length of the string $s$ and the size of the character set, respectively.
+
+**Solution 2: Bit Manipulation (Space Optimization)**
+
+We can use two integers $mask1$ and $mask2$ to record the lowercase and uppercase letters that appear in the string $s$, respectively. The $i$-th bit of $mask1$ indicates whether the $i$-th lowercase letter appears, and the $i$-th bit of $mask2$ indicates whether the $i$-th uppercase letter appears.
+
+Then we perform a bitwise AND operation on $mask1$ and $mask2$. The $i$-th bit of the resulting $mask$ indicates whether the $i$-th letter appears in both uppercase and lowercase.
+
+Next, we just need to get the position of the highest $1$ in the binary representation of $mask$, and convert it to the corresponding uppercase letter. If all binary bits are not $1$, it means that there is no letter that appears in both uppercase and lowercase, so we return an empty string.
+
+The time complexity is $O(n)$, where $n$ is the length of the string $s$. The space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2400-2499/2400.Number of Ways to Reach a Position After Exactly k Steps/README_EN.md

@@ -41,6 +41,23 @@ It can be proven that no other way is possible, so we return 3.</pre>
 
 ## Solutions
 
+**Solution 1: Memorization Search**
+
+We design a function $dfs(i, j)$, which represents the number of ways to reach the target position when the current position is $i$ distance from the target position and there are $j$ steps left. The answer is $dfs(abs(startPos - endPos), k)$.
+
+The calculation method of the function $dfs(i, j)$ is as follows:
+
+-   If $i \gt j$ or $j \lt 0$, it means that the current distance from the target position is greater than the remaining steps, or the remaining steps are negative. In this case, it is impossible to reach the target position, so return $0$;
+-   If $j = 0$, it means that there are no steps left. At this time, only when the current distance from the target position is $0$ can the target position be reached, otherwise it is impossible to reach the target position. Return $1$ or $0$;
+-   Otherwise, the current distance from the target position is $i$, and there are $j$ steps left. There are two ways to reach the target position:
+    -   Move one step to the left, the current distance from the target position is $i + 1$, and there are $j - 1$ steps left. The number of methods is $dfs(i + 1, j - 1)$;
+    -   Move one step to the right, the current distance from the target position is $abs(i - 1)$, and there are $j - 1$ steps left. The number of methods is $dfs(abs(i - 1), j - 1)$;
+-   Finally, return the result of the sum of the two methods modulo $10^9 + 7$.
+
+To avoid repeated calculations, we use memorization search, that is, we use a two-dimensional array $f$ to record the result of the function $dfs(i, j)$. When the function $dfs(i, j)$ is called, if $f[i][j]$ is not $-1$, return $f[i][j]$ directly, otherwise calculate the value of $f[i][j]$, and return $f[i][j]$.
+
+The time complexity is $O(k^2)$, and the space complexity is $O(k^2)$. Here, $k$ is the number of steps given in the problem.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2400-2499/2401.Longest Nice Subarray/README_EN.md

@@ -44,6 +44,22 @@ It can be proven that no longer nice subarray can be obtained, so we return 3.</
 
 ## Solutions
 
+**Solution 1: Two Pointers**
+
+We define a variable $mask$ to record the bitwise OR result of the elements in the current subarray, initially $mask = 0$. Also, we use two pointers $j$ and $i$ to point to the left and right endpoints of the current subarray, initially $i = j = 0$.
+
+Next, we traverse the array $nums$ from left to right. For each element $x$ we encounter:
+
+We perform a bitwise AND operation between it and $mask$. If the result is not $0$, it means that $x$ and at least one element in $mask$ have a binary representation where a certain bit is $1$, and the corresponding bit in the other element's binary representation is $0$. Such pairs of elements cannot satisfy the problem's requirements, so we need to move $j$ to the right until the bitwise AND result of $x$ and $mask$ is $0$.
+
+At this point, we have found a subarray that satisfies the problem's requirements. Its length is $i - j + 1$. We compare it with the length of the current longest elegant subarray. If it is longer than the current longest elegant subarray, we update the length of the longest elegant subarray.
+
+Then we perform a bitwise OR operation between $mask$ and $x$, and continue to the next element.
+
+Finally, the length of the longest elegant subarray we obtain is the answer.
+
+The time complexity is $O(n)$, and the space complexity is $O(1)$. Here, $n$ is the length of the array $nums$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2400-2499/2402.Meeting Rooms III/README.md

@@ -71,17 +71,19 @@
 
 **方法一：优先队列（小根堆）**
 
-定义两个优先队列，分别表示空闲会议室、使用中的会议室。其中：空闲会议室 `idle` 依据**下标**排序；而使用中的会议室 `busy` 依据**结束时间、下标**排序。
+我们定义两个优先队列，分别表示空闲会议室、使用中的会议室。其中：空闲会议室 `idle` 依据**下标**排序；而使用中的会议室 `busy` 依据**结束时间、下标**排序。
 
 先对会议按照开始时间排序，然后遍历会议，对于每个会议：
 
 -   若有使用中的会议室小于当前等于会议的开始时间，将其加入到空闲会议室队列 `idle` 中；
 -   若当前有空闲会议室，那么在空闲队列 `idle` 中取出权重最小的会议室，将其加入使用中的队列 `busy` 中；
 -   若当前没有空闲会议室，那么在使用队列 `busy` 中找出最早结束时间且下标最小的会议室，重新加入使用中的队列 `busy` 中。
 
-时间复杂度 $O(m\log m)$，其中 $m$ 为会议数量。
+时间复杂度 $O(m \times \log m)$，其中 $m$ 为会议数量。
 
-相似题目：[1882. 使用服务器处理任务](/solution/1800-1899/1882.Process%20Tasks%20Using%20Servers/README.md)
+相似题目：
+
+-   [1882. 使用服务器处理任务](/solution/1800-1899/1882.Process%20Tasks%20Using%20Servers/README.md)
 
 <!-- tabs:start -->
 

solution/2400-2499/2402.Meeting Rooms III/README_EN.md

@@ -65,6 +65,22 @@ Room 0 held 1 meeting while rooms 1 and 2 each held 2 meetings, so we return 1.
 
 ## Solutions
 
+**Solution 1: Priority Queue (Min Heap)**
+
+We define two priority queues, representing idle meeting rooms and busy meeting rooms, respectively. Among them: the idle meeting rooms `idle` are sorted according to **index**; while the busy meeting rooms `busy` are sorted according to **end time, index**.
+
+First, sort the meetings by start time, then traverse the meetings. For each meeting:
+
+-   If there is a busy meeting room that is less than or equal to the start time of the current meeting, add it to the idle meeting room queue `idle`.
+-   If there are currently idle meeting rooms, take out the meeting room with the smallest weight from the idle queue `idle` and add it to the busy queue `busy`.
+-   If there are currently no idle meeting rooms, find the meeting room with the earliest end time and smallest index in the busy queue `busy`, and re-add it to the busy queue `busy`.
+
+The time complexity is $O(m \times \log m)$, where $m$ is the number of meetings.
+
+Similar problems:
+
+-   [1882. Process Tasks Using Servers](/solution/1800-1899/1882.Process%20Tasks%20Using%20Servers/README_EN.md)
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2400-2499/2403.Minimum Time to Kill All Monsters/README.md

@@ -79,13 +79,13 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-**方法一：状态压缩 + 记忆化搜索/动态规划**
+**方法一：状态压缩 + 记忆化搜索或动态规划**
 
-由于打怪才能增加每天法力的收益 `gain`，不同的打怪顺序对结果有影响，需要枚举。注意到题目的数据范围较小，考虑使用状态压缩动态规划求解。
+由于打怪才能增加每天法力的收益 $gain$，不同的打怪顺序对结果有影响，需要枚举。注意到题目的数据范围较小，考虑使用状态压缩动态规划求解。
 
-我们定义状态 `mask` 表示当前已经打怪的情况，其二进制中的 `1` 表示已经被打倒的怪物，`0` 表示未被打倒的怪物。
+我们定义状态 $mask$ 表示当前已经打怪的情况，其二进制中的 $1$ 表示已经被打倒的怪物，而 $0$ 表示未被打倒的怪物。
 
-时间复杂度 $O(n\times 2^n)$，空间复杂度 $O(2^n)$。其中 $n$ 是怪物数量。
+时间复杂度 $O(n \times 2^n)$，空间复杂度 $O(2^n)$。其中 $n$ 是怪物数量。
 
 <!-- tabs:start -->
 

solution/2400-2499/2403.Minimum Time to Kill All Monsters/README_EN.md

@@ -69,6 +69,14 @@ It can be proven that 6 is the minimum number of days needed.
 
 ## Solutions
 
+**Solution 1: State Compression + Memorization Search or Dynamic Programming**
+
+Since defeating monsters can increase the daily magic power gain $gain$, the order of defeating monsters affects the result, so we need to enumerate. Noting that the data range of the problem is small, we consider using state compression dynamic programming to solve it.
+
+We define a state $mask$ to represent the current situation of defeating monsters. In its binary representation, $1$ represents the monsters that have been defeated, and $0$ represents the monsters that have not been defeated.
+
+The time complexity is $O(n \times 2^n)$, and the space complexity is $O(2^n)$. Here, $n$ is the number of monsters.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2400-2499/2404.Most Frequent Even Element/README_EN.md

@@ -44,6 +44,12 @@ We return the smallest one, which is 2.</pre>
 
 ## Solutions
 
+**Solution 1: Hash Table**
+
+We use a hash table $cnt$ to count the occurrence of all even elements, and then find the even element with the highest occurrence and the smallest value.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the array.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2400-2499/2405.Optimal Partition of String/README.md

@@ -52,7 +52,7 @@
 
 过程中，可以用哈希表记录当前子字符串的所有字符，空间复杂度 $O(n)$；也可以使用一个数字，用位运算的方式记录字符，空间复杂度 $O(1)$。
 
-时间复杂度 $O(n)$。其中 $n$ 是字符串 `s` 的长度。
+时间复杂度 $O(n)$。其中 $n$ 是字符串 $s$ 的长度。
 
 <!-- tabs:start -->
 

solution/2400-2499/2405.Optimal Partition of String/README_EN.md

@@ -40,6 +40,14 @@ It can be shown that 4 is the minimum number of substrings needed.
 
 ## Solutions
 
+**Solution 1: Greedy**
+
+According to the problem, each substring should be as long as possible and contain unique characters. We just need to partition greedily.
+
+During the process, we can use a hash table to record all characters in the current substring, with a space complexity of $O(n)$; or we can use a number to record characters using bitwise operations, with a space complexity of $O(1)$.
+
+The time complexity is $O(n)$, where $n$ is the length of the string $s$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2400-2499/2406.Divide Intervals Into Minimum Number of Groups/README.md

@@ -51,12 +51,14 @@
 
 **方法一：贪心 + 优先队列（小根堆）**
 
-先将区间按左端点排序，用小根堆维护每组的最右端点（堆顶是所有组的最右端点的最小值）。遍历每个区间：
+我们先将区间按左端点排序，用小根堆维护每组的最右端点（堆顶是所有组的最右端点的最小值）。
+
+接下来，我们遍历每个区间：
 
 -   若当前区间左端点大于堆顶元素，说明当前区间可以加入到堆顶元素所在的组中，我们直接弹出堆顶元素，然后将当前区间的右端点放入堆中；
 -   否则，说明当前没有组能容纳当前区间，那么我们就新建一个组，将当前区间的右端点放入堆中。
 
-时间复杂度 $O(n\log n)$。其中 $n$ 是数组 `intervals` 的长度。
+时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 是数组 `intervals` 的长度。
 
 <!-- tabs:start -->