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**