feat: add solutions to lc problems: No.2542+ (#2153)

Author: yanglbme

solution/2500-2599/2542.Maximum Subsequence Score/README_EN.md

@@ -53,6 +53,12 @@ Choosing index 2 is optimal: nums1[2] * nums2[2] = 3 * 10 = 30 is the maximum po
 
 ## Solutions
 
+**Solution 1: Sorting + Priority Queue (Min Heap)**
+
+Sort nums2 and nums1 in descending order according to nums2, then traverse from front to back, maintaining a min heap. The heap stores elements from nums1, and the number of elements in the heap does not exceed $k$. At the same time, maintain a variable $s$ representing the sum of the elements in the heap, and continuously update the answer during the traversal process.
+
+The time complexity is $O(n \times \log n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the array nums1.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2500-2599/2543.Check if Point Is Reachable/README.md

@@ -57,7 +57,7 @@
 
 只要 $x$ 或 $y$ 是偶数，我们就将其除以 $2$，直到 $x$ 和 $y$ 均为奇数。此时，若 $x \neq y$，不妨设 $x \gt y$，那么 $\frac{x+y}{2} \lt x$。由于 $x+y$ 是偶数，我们可以通过操作从 $(x, y)$ 移动到 $(x+y, y)$，再移动到 $(\frac{x+y}{2}, y)$。也就是说，我们总能让 $x$ 和 $y$ 不断变小。循环结束时，如果 $x=y=1$，说明可以到达。
 
-时间复杂度 $O(\log(min(targetX, targetY)))$，空间复杂度 $O(1)$。
+时间复杂度 $O(\log(\min(targetX, targetY)))$，空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 

solution/2500-2599/2543.Check if Point Is Reachable/README_EN.md

@@ -43,6 +43,18 @@
 
 ## Solutions
 
+**Solution 1: Mathematics**
+
+We notice that the first two types of moves do not change the greatest common divisor (gcd) of the horizontal and vertical coordinates, while the last two types of moves can multiply the gcd of the horizontal and vertical coordinates by a power of $2$. In other words, the final gcd of the horizontal and vertical coordinates must be a power of $2$. If the gcd is not a power of $2$, then it is impossible to reach.
+
+Next, we prove that any $(x, y)$ that satisfies $gcd(x, y)=2^k$ can be reached.
+
+We reverse the direction of movement, that is, move from the end point back. Then $(x, y)$ can move to $(x, x+y)$, $(x+y, y)$, $(\frac{x}{2}, y)$, and $(x, \frac{y}{2})$.
+
+As long as $x$ or $y$ is even, we divide it by $2$ until both $x$ and $y$ are odd. At this point, if $x \neq y$, without loss of generality, let $x \gt y$, then $\frac{x+y}{2} \lt x$. Since $x+y$ is even, we can move from $(x, y)$ to $(x+y, y)$, and then to $(\frac{x+y}{2}, y)$ through operations. That is to say, we can always make $x$ and $y$ continuously decrease. When the loop ends, if $x=y=1$, it means it can be reached.
+
+The time complexity is $O(\log(\min(targetX, targetY)))$, and the space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2500-2599/2544.Alternating Digit Sum/README_EN.md

@@ -56,6 +56,14 @@
 
 ## Solutions
 
+**Solution 1: Simulation**
+
+We can directly simulate the process as described in the problem.
+
+We define an initial symbol $sign=1$. Starting from the most significant digit, we take out one digit $x$ each time, multiply it by $sign$, add the result to the answer, then negate $sign$, and continue to process the next digit until all digits are processed.
+
+The time complexity is $O(\log n)$, and the space complexity is $O(\log n)$. Here, $n$ is the given number.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2500-2599/2545.Sort the Students by Their Kth Score/README.md

@@ -58,7 +58,7 @@
 
 **方法一：排序**
 
-将 `score` 按照第 $k$ 列的分数从大到小排序，然后返回即可。
+我们将 `score` 按照第 $k$ 列的分数从大到小排序，然后返回即可。
 
 时间复杂度 $O(m \times \log m)$，空间复杂度 $O(1)$。其中 $m$ 为 `score` 的行数。
 

solution/2500-2599/2545.Sort the Students by Their Kth Score/README_EN.md

@@ -46,6 +46,12 @@
 
 ## Solutions
 
+**Solution 1: Sorting**
+
+We sort score in descending order based on the scores in the $k^{th}$ column, and then return it.
+
+The time complexity is $O(m \times \log m)$, and the space complexity is $O(1)$. Here, $m$ is the number of rows in score.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2500-2599/2546.Apply Bitwise Operations to Make Strings Equal/README.md

@@ -52,9 +52,9 @@
 
 **方法一：脑筋急转弯**
 
-注意到 $1$ 其实是数字转换的“工具”，因此只要两个字符串中都有 $1$ 或者都没有 $1$，那么就可以通过操作使得两个字符串相等。
+我们注意到 $1$ 其实是数字转换的“工具”，因此只要两个字符串中都有 $1$ 或者都没有 $1$，那么就可以通过操作使得两个字符串相等。
 
-时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为字符串的长度。
+时间复杂度 $O(n)$，其中 $n$ 为字符串的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 

solution/2500-2599/2546.Apply Bitwise Operations to Make Strings Equal/README_EN.md

@@ -46,6 +46,12 @@ Since we can make s equal to target, we return true.
 
 ## Solutions
 
+**Solution 1: Lateral Thinking**
+
+We notice that $1$ is actually a "tool" for number conversion. Therefore, as long as both strings either have $1$ or neither have $1$, we can make the two strings equal through operations.
+
+The time complexity is $O(n)$, where $n$ is the length of the string. The space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2500-2599/2547.Minimum Cost to Split an Array/README.md

@@ -87,7 +87,7 @@
 
 过程中，我们可以使用记忆化搜索，即使用一个数组 $f$ 记忆化函数 $dfs(i)$ 的返回值，避免重复计算。
 
-时间复杂度 $O(n^2)$，空间复杂度 $O(n)$。其中 $n$ 为数组 `nums` 的长度。
+时间复杂度 $O(n^2)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $nums$ 的长度。
 
 <!-- tabs:start -->
 

solution/2500-2599/2547.Minimum Cost to Split an Array/README_EN.md

@@ -77,6 +77,18 @@ The cost of the split is 10. It can be shown that this is the minimum possible c
 
 ## Solutions
 
+**Solution 1: Memoization Search**
+
+We design a function $dfs(i)$, which represents the minimum cost of splitting from index $i$. So the answer is $dfs(0)$.
+
+The calculation process of the function $dfs(i)$ is as follows:
+
+If $i \ge n$, it means that the splitting has reached the end of the array, and $0$ is returned at this time.
+Otherwise, we enumerate the end $j$ of the subarray. During the process, we use an array or hash table cnt to count the number of times each number appears in the subarray, and use a variable one to count the number of numbers in the subarray that appear once. So the importance of the subarray is $k + j - i + 1 - one$, and the cost of splitting is $k + j - i + 1 - one + dfs(j + 1)$. We enumerate all $j$ and take the minimum value as the return value of $dfs(i)$.
+During the process, we can use memoization search, that is, use an array $f$ to memorize the return value of the function $dfs(i)$ to avoid repeated calculations.
+
+The time complexity is $O(n^2)$, and the space complexity is $O(n)$. Where $n$ is the length of the array $nums$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2500-2599/2548.Maximum Price to Fill a Bag/README.md

@@ -59,7 +59,7 @@
 
 **方法一：贪心 + 排序**
 
-将物品按照单位价格从大到小排序，然后依次取出物品，直到背包装满。
+我们将物品按照单位价格从大到小排序，然后依次取出物品，直到背包装满。
 
 若最后背包未装满，则返回 $-1$，否则返回总价格。
 

solution/2500-2599/2548.Maximum Price to Fill a Bag/README_EN.md

@@ -51,6 +51,14 @@ It can be proved that 55.0 is the maximum total price that we can achieve.
 
 ## Solutions
 
+**Solution 1: Greedy + Sorting**
+
+We sort the items in descending order by unit price, and then take out the items one by one until the backpack is full.
+
+If the backpack is not full in the end, return $-1$, otherwise return the total price.
+
+The time complexity is $O(n \times \log n)$, and the space complexity is $O(\log n)$, where $n$ is the number of items.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2500-2599/2549.Count Distinct Numbers on Board/README_EN.md

@@ -51,6 +51,14 @@ After a billion days, the only two distinct numbers on the board are 2 and 3.
 
 ## Solutions
 
+**Solution 1: Lateral Thinking**
+
+Since every operation on the number $n$ on the desktop will also cause the number $n-1$ to appear on the desktop, the final numbers on the desktop are $[2,...n]$, that is, $n-1$ numbers.
+
+Note that $n$ could be $1$, so it needs to be specially judged.
+
+The time complexity is $O(1)$, and the space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2500-2599/2550.Count Collisions of Monkeys on a Polygon/README.md

@@ -58,11 +58,11 @@
 
 **方法一：数学（快速幂）**
 
-每一只猴子都有两种移动方式，即顺时针或逆时针。因此，一共有 $2^n$ 种移动方式。不碰撞的移动方式只有两种，即所有猴子都顺时针移动或所有猴子都逆时针移动。因此，碰撞的移动方式有 $2^n - 2$ 种。
+根据题目描述，每一只猴子都有两种移动方式，即顺时针或逆时针。因此，一共有 $2^n$ 种移动方式。不碰撞的移动方式只有两种，即所有猴子都顺时针移动或所有猴子都逆时针移动。因此，碰撞的移动方式有 $2^n - 2$ 种。
 
 我们可以用快速幂求出 $2^n$ 的值，然后用 $2^n - 2$ 求出碰撞的移动方式数，最后对 $10^9 + 7$ 取余即可。
 
-时间复杂度为 $O(\log n)$，空间复杂度为 $O(1)$。其中 $n$ 为猴子的数量。
+时间复杂度 $O(\log n)$，其中 $n$ 为猴子的数量。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 

solution/2500-2599/2550.Count Collisions of Monkeys on a Polygon/README_EN.md

@@ -49,6 +49,14 @@ It can be shown 6 total movements result in a collision.
 
 ## Solutions
 
+**Solution 1: Mathematics (Fast Power)**
+
+According to the problem description, each monkey has two ways of moving, either clockwise or counterclockwise. Therefore, there are a total of $2^n$ ways to move. The non-collision ways of moving are only two, that is, all monkeys move clockwise or all monkeys move counterclockwise. Therefore, the number of collision ways of moving is $2^n - 2$.
+
+We can use fast power to calculate the value of $2^n$, then use $2^n - 2$ to calculate the number of collision ways of moving, and finally take the remainder of $10^9 + 7$.
+
+The time complexity is $O(\log n)$, where $n$ is the number of monkeys. The space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2500-2599/2551.Put Marbles in Bags/README_EN.md

@@ -49,6 +49,14 @@ Since both the maximal and minimal score are the same, we return 0.
 
 ## Solutions
 
+**Solution 1: Problem Transformation + Sorting**
+
+We can transform the problem into: dividing the array `weights` into $k$ consecutive subarrays, that is, we need to find $k-1$ splitting points, each splitting point's cost is the sum of the elements on the left and right of the splitting point. The difference between the sum of the costs of the largest $k-1$ splitting points and the smallest $k-1$ splitting points is the answer.
+
+Therefore, we can process the array `weights` and transform it into an array `arr` of length $n-1$, where `arr[i] = weights[i] + weights[i+1]`. Then we sort the array `arr`, and finally calculate the difference between the sum of the costs of the largest $k-1$ splitting points and the smallest $k-1$ splitting points.
+
+The time complexity is $O(n \times \log n)$, and the space complexity is $O(n)$. Where $n$ is the length of the array `weights`.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2500-2599/2552.Count Increasing Quadruplets/README_EN.md

@@ -44,6 +44,19 @@ There are no other quadruplets, so we return 2.
 
 ## Solutions
 
+**Solution 1: Enumeration + Preprocessing**
+
+We can enumerate $j$ and $k$ in the quadruplet, then the problem is transformed into, for the current $j$ and $k$:
+
+-   Count how many $l$ satisfy $l > k$ and $nums[l] > nums[j]$;
+-   Count how many $i$ satisfy $i < j$ and $nums[i] < nums[k]$.
+
+We can use two two-dimensional arrays $f$ and $g$ to record these two pieces of information. Where $f[j][k]$ represents how many $l$ satisfy $l > k$ and $nums[l] > nums[j]$, and $g[j][k]$ represents how many $i$ satisfy $i < j$ and $nums[i] < nums[k]$.
+
+Therefore, the answer is the sum of all $f[j][k] \times g[j][k]$.
+
+The time complexity is $O(n^2)$, and the space complexity is $O(n^2)$. Where $n$ is the length of the array.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2500-2599/2553.Separate the Digits in an Array/README.md

@@ -53,7 +53,7 @@ answer = [7,1,3,9] 。
 
 将数组中的每个数字进行数位分割，然后将分割后的数字依次放入答案数组中。
 
-时间复杂度 $O(n \times \log_{10} M)$，空间复杂度 $O(n \times \log_{10} M)$，其中 $n$ 为数组 `nums` 的长度，而 $M$ 为数组 `nums` 中的最大值。
+时间复杂度 $O(n \times \log_{10} M)$，空间复杂度 $O(n \times \log_{10} M)$，其中 $n$ 为数组 $nums$ 的长度，而 $M$ 为数组 $nums$ 中的最大值。
 
 <!-- tabs:start -->
 

solution/2500-2599/2553.Separate the Digits in an Array/README_EN.md

@@ -45,6 +45,12 @@ answer = [7,1,3,9].
 
 ## Solutions
 
+**Solution 1: Simulation**
+
+Split each number in the array into digits, then put the split numbers into the answer array in order.
+
+The time complexity is $O(n \times \log_{10} M)$, and the space complexity is $O(n \times \log_{10} M)$. Where $n$ is the length of the array $nums$, and $M$ is the maximum value in the array $nums$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2500-2599/2554.Maximum Number of Integers to Choose From a Range I/README.md

@@ -76,7 +76,9 @@
 
 时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 `banned` 的长度。
 
-相似题目：[2557. 从一个范围内选择最多整数 II](/solution/2500-2599/2557.Maximum%20Number%20of%20Integers%20to%20Choose%20From%20a%20Range%20II/README.md)
+相似题目：
+
+-   [2557. 从一个范围内选择最多整数 II](/solution/2500-2599/2557.Maximum%20Number%20of%20Integers%20to%20Choose%20From%20a%20Range%20II/README.md)
 
 <!-- tabs:start -->
 

solution/2500-2599/2554.Maximum Number of Integers to Choose From a Range I/README_EN.md

@@ -53,6 +53,30 @@ They are from the range [1, 7], all did not appear in banned, and their sum is 2
 
 ## Solutions
 
+**Solution 1: Greedy + Enumeration**
+
+We use the variable $s$ to represent the sum of the currently selected integers, and the variable $ans$ to represent the number of currently selected integers. We convert the array `banned` into a hash table for easy determination of whether a certain integer is not selectable.
+
+Next, we start enumerating the integer $i$ from $1$. If $s + i \leq maxSum$ and $i$ is not in `banned`, then we can select the integer $i$, and add $i$ and $1$ to $s$ and $ans$ respectively.
+
+Finally, we return $ans$.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$. Where $n$ is the given integer.
+
+**Solution 2: Greedy + Binary Search**
+
+If $n$ is very large, the enumeration in Method One will time out.
+
+We can add $0$ and $n + 1$ to the array `banned`, deduplicate the array `banned`, remove elements greater than $n+1$, and then sort it.
+
+Next, we enumerate every two adjacent elements $i$ and $j$ in the array `banned`. The range of selectable integers is $[i + 1, j - 1]$. We use binary search to enumerate the number of elements we can select in this range, find the maximum number of selectable elements, and then add it to $ans$. At the same time, we subtract the sum of these elements from `maxSum`. If `maxSum` is less than $0$, we break the loop. Return the answer.
+
+The time complexity is $O(n \times \log n)$, and the space complexity is $O(n)$. Where $n$ is the length of the array `banned`.
+
+Similar problems:
+
+-   [2557. Maximum Number of Integers to Choose From a Range II](/solution/2500-2599/2557.Maximum%20Number%20of%20Integers%20to%20Choose%20From%20a%20Range%20II/README.md)
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2500-2599/2555.Maximize Win From Two Segments/README_EN.md

@@ -52,6 +52,16 @@
 
 ## Solutions
 
+**Solution 1: Dynamic Programming + Binary Search**
+
+We define $f[i]$ as the maximum number of prizes that can be obtained by selecting a segment of length $k$ from the first $i$ prizes. Initially, $f[0] = 0$. We define the answer variable as $ans = 0$.
+
+Next, we enumerate the position $x$ of each prize, and use binary search to find the leftmost prize index $j$ such that $prizePositions[j] \geq x - k$. At this point, we update the answer $ans = \max(ans, f[j] + i - j)$, and update $f[i] = \max(f[i - 1], i - j)$.
+
+Finally, we return $ans$.
+
+The time complexity is $O(n \times \log n)$, and the space complexity is $O(n)$. Where $n$ is the number of prizes.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2500-2599/2556.Disconnect Path in a Binary Matrix by at Most One Flip/README_EN.md

@@ -43,6 +43,16 @@
 
 ## Solutions
 
+**Solution 1: Two DFS Traversals**
+
+First, we perform a DFS traversal to determine whether there is a path from $(0, 0)$ to $(m - 1, n - 1)$, and we denote the result as $a$. During the DFS process, we set the value of the visited cells to $0$ to prevent revisiting.
+
+Next, we set the values of $(0, 0)$ and $(m - 1, n - 1)$ to $1$, and perform another DFS traversal to determine whether there is a path from $(0, 0)$ to $(m - 1, n - 1)$, and we denote the result as $b$. During the DFS process, we set the value of the visited cells to $0$ to avoid revisiting.
+
+Finally, if both $a$ and $b$ are `true`, we return `false`, otherwise, we return `true`.
+
+The time complexity is $O(m \times n)$, and the space complexity is $O(m \times n)$. Where $m$ and $n$ are the number of rows and columns of the matrix, respectively.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2500-2599/2557.Maximum Number of Integers to Choose From a Range II/README_EN.md

@@ -45,6 +45,14 @@ All these integers are in the range [1, 7], all do not appear in banned, and the
 
 ## Solutions
 
+**Solution 1: Deduplication + Sorting + Binary Search**
+
+We can add $0$ and $n + 1$ to the array `banned`, then deduplicate and sort the array `banned`.
+
+Next, we enumerate every two adjacent elements $i$ and $j$ in the array `banned`. The range of selectable integers is $[i + 1, j - 1]$. We use binary search to enumerate the number of elements we can select in this range, find the maximum number of selectable elements, and then add it to $ans$. At the same time, we subtract the sum of these elements from `maxSum`. If `maxSum` is less than $0$, we break the loop. Return the answer.
+
+The time complexity is $O(n \times \log n)$, and the space complexity is $O(n)$. Where $n$ is the length of the array `banned`.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2500-2599/2559.Count Vowel Strings in Ranges/README_EN.md

@@ -46,6 +46,24 @@ We return [2,3,0].
 
 ## Solutions
 
+**Solution 1: Preprocessing + Binary Search**
+
+We can preprocess all the indices of the strings that start and end with a vowel, and record them in order in the array $nums$.
+
+Next, we iterate through each query $(l, r)$, and use binary search to find the first index $i$ in $nums$ that is greater than or equal to $l$, and the first index $j$ that is greater than $r$. Therefore, the answer to the current query is $j - i$.
+
+The time complexity is $O(n + m \times \log n)$, and the space complexity is $O(n)$. Where $n$ and $m$ are the lengths of the arrays $words$ and $queries$, respectively.
+
+**Solution 2: Prefix Sum**
+
+We can create a prefix sum array $s$ of length $n+1$, where $s[i]$ represents the number of strings that start and end with a vowel in the first $i$ strings of the array $words$. Initially, $s[0] = 0$.
+
+Next, we iterate through the array $words$. If the current string starts and ends with a vowel, then $s[i+1] = s[i] + 1$, otherwise $s[i+1] = s[i]$.
+
+Finally, we iterate through each query $(l, r)$. Therefore, the answer to the current query is $s[r+1] - s[l]$.
+
+The time complexity is $O(n + m)$, and the space complexity is $O(n)$. Where $n$ and $m$ are the lengths of the arrays $words$ and $queries$, respectively.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2500-2599/2560.House Robber IV/README.md

@@ -59,7 +59,7 @@
 
 题目求的是窃贼的最小窃取能力，我们可以二分枚举窃贼的窃取能力，对于枚举的能力 $x$，我们可以通过贪心的方式判断窃贼是否能够窃取至少 $k$ 间房屋，具体地，我们从左到右遍历数组，对于当前遍历到的房屋 $i$，如果 $nums[i] \leq x$ 且 $i$ 与上一个窃取的房屋的下标之差大于 $1$，则窃贼可以窃取房屋 $i$，否则窃贼不能窃取房屋 $i$。累计窃取的房屋数，如果窃取的房屋数大于等于 $k$，则说明窃贼可以窃取至少 $k$ 间房屋，此时窃贼的窃取能力 $x$ 可能是最小的，否则窃贼的窃取能力 $x$ 不是最小的。
 
-时间复杂度 $O(n \times \log m)$，空间复杂度 $O(1)$。其中 $n$ 和 $m$ 分别是数组 `nums` 的长度和数组 `nums` 中的最大值。
+时间复杂度 $O(n \times \log m)$，空间复杂度 $O(1)$。其中 $n$ 和 $m$ 分别是数组 $nums$ 的长度和数组 $nums$ 中的最大值。
 
 <!-- tabs:start -->