feat: update lc problems (doocs#2301)

Author: yanglbme

solution/0300-0399/0321.Create Maximum Number/README.md

@@ -14,7 +14,8 @@
 
 <p><strong>示例&nbsp;1:</strong></p>
 
-<pre><strong>输入:</strong>
+<pre>
+<strong>输入:</strong>
 nums1 = <code>[3, 4, 6, 5]</code>
 nums2 = <code>[9, 1, 2, 5, 8, 3]</code>
 k = <code>5</code>
@@ -23,7 +24,8 @@ k = <code>5</code>
 
 <p><strong>示例 2:</strong></p>
 
-<pre><strong>输入:</strong>
+<pre>
+<strong>输入:</strong>
 nums1 = <code>[6, 7]</code>
 nums2 = <code>[6, 0, 4]</code>
 k = <code>5</code>
@@ -32,12 +34,24 @@ k = <code>5</code>
 
 <p><strong>示例 3:</strong></p>
 
-<pre><strong>输入:</strong>
+<pre>
+<strong>输入:</strong>
 nums1 = <code>[3, 9]</code>
 nums2 = <code>[8, 9]</code>
 k = <code>3</code>
 <strong>输出:</strong>
-<code>[9, 8, 9]</code></pre>
+<code>[9, 8, 9]</code>
+</pre>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>m == nums1.length</code></li>
+	<li><code>n == nums2.length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 500</code></li>
+	<li><code>0 &lt;= nums1[i], nums2[i] &lt;= 9</code></li>
+	<li><code>1 &lt;= k &lt;= m + n</code></li>
+</ul>
 
 ## 解法
 

solution/0800-0899/0899.Orderly Queue/README.md

@@ -8,7 +8,7 @@
 
 <p>给定一个字符串 <code>s</code> 和一个整数 <code>k</code>&nbsp;。你可以从 <code>s</code> 的前 <code>k</code> 个字母中选择一个，并把它加到字符串的末尾。</p>
 
-<p>返回 <em>在应用上述步骤的任意数量的移动后，字典上最小的字符串&nbsp;</em>。</p>
+<p>返回 <em>在应用上述步骤的任意数量的移动后，字典序最小的字符串&nbsp;</em>。</p>
 
 <p>&nbsp;</p>
 

solution/1300-1399/1386.Cinema Seat Allocation/README.md

@@ -6,34 +6,37 @@
 
 <!-- 这里写题目描述 -->
 
-<p><img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/1300-1399/1386.Cinema%20Seat%20Allocation/images/cinema_seats_1.png" style="height: 149px; width: 400px;"></p>
+<p><img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/1300-1399/1386.Cinema%20Seat%20Allocation/images/cinema_seats_1.png" style="height: 149px; width: 400px;" /></p>
 
 <p>如上图所示，电影院的观影厅中有 <code>n</code>&nbsp;行座位，行编号从 1&nbsp;到 <code>n</code>&nbsp;，且每一行内总共有 10 个座位，列编号从 1 到 10 。</p>
 
-<p>给你数组&nbsp;<code>reservedSeats</code>&nbsp;，包含所有已经被预约了的座位。比如说，<code>researvedSeats[i]=[3,8]</code>&nbsp;，它表示第&nbsp;<strong>3</strong>&nbsp;行第&nbsp;<strong>8</strong>&nbsp;个座位被预约了。</p>
+<p>给你数组&nbsp;<code>reservedSeats</code>&nbsp;，包含所有已经被预约了的座位。比如说，<code>reservedSeats[i]=[3,8]</code>&nbsp;，它表示第&nbsp;<strong>3</strong>&nbsp;行第&nbsp;<strong>8</strong>&nbsp;个座位被预约了。</p>
 
 <p>请你返回&nbsp;<strong>最多能安排多少个 4 人家庭</strong>&nbsp;。4 人家庭要占据&nbsp;<strong>同一行内连续&nbsp;</strong>的 4 个座位。隔着过道的座位（比方说 [3,3] 和 [3,4]）不是连续的座位，但是如果你可以将 4 人家庭拆成过道两边各坐 2 人，这样子是允许的。</p>
 
 <p>&nbsp;</p>
 
 <p><strong>示例 1：</strong></p>
 
-<p><img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/1300-1399/1386.Cinema%20Seat%20Allocation/images/cinema_seats_3.png" style="height: 96px; width: 400px;"></p>
+<p><img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/1300-1399/1386.Cinema%20Seat%20Allocation/images/cinema_seats_3.png" style="height: 96px; width: 400px;" /></p>
 
-<pre><strong>输入：</strong>n = 3, reservedSeats = [[1,2],[1,3],[1,8],[2,6],[3,1],[3,10]]
+<pre>
+<strong>输入：</strong>n = 3, reservedSeats = [[1,2],[1,3],[1,8],[2,6],[3,1],[3,10]]
 <strong>输出：</strong>4
 <strong>解释：</strong>上图所示是最优的安排方案，总共可以安排 4 个家庭。蓝色的叉表示被预约的座位，橙色的连续座位表示一个 4 人家庭。
 </pre>
 
 <p><strong>示例 2：</strong></p>
 
-<pre><strong>输入：</strong>n = 2, reservedSeats = [[2,1],[1,8],[2,6]]
+<pre>
+<strong>输入：</strong>n = 2, reservedSeats = [[2,1],[1,8],[2,6]]
 <strong>输出：</strong>2
 </pre>
 
 <p><strong>示例 3：</strong></p>
 
-<pre><strong>输入：</strong>n = 4, reservedSeats = [[4,3],[1,4],[4,6],[1,7]]
+<pre>
+<strong>输入：</strong>n = 4, reservedSeats = [[4,3],[1,4],[4,6],[1,7]]
 <strong>输出：</strong>4
 </pre>
 

solution/1600-1699/1652.Defuse the Bomb/README.md

@@ -61,23 +61,23 @@
 
 ### 方法一：模拟
 
-定义答案数组 `ans`，长度为 $n$，初始时所有元素都为 $0$。根据题意，若 $k$ 为 $0$，直接返回 `ans`。
+我们定义一个长度为 $n$ 的答案数组 $ans$，初始时所有元素都为 $0$。根据题意，若 $k$ 为 $0$，直接返回 $ans$。
 
 否则，遍历每个位置 $i$：
 
 若 $k$ 为正数，那么 $i$ 位置的值为 $i$ 位置后 $k$ 个位置的值之和，即：
 
 $$
-ans[i] = \sum_{j=i+1}^{i+k} code[j\mod{n}]
+ans[i] = \sum_{j=i+1}^{i+k} code[j \bmod n]
 $$
 
 若 $k$ 为负数，那么 $i$ 位置的值为 $i$ 位置前 $|k|$ 个位置的值之和，即：
 
 $$
-ans[i] = \sum_{j=i+k}^{i-1} code[(j+n)\mod{n}]
+ans[i] = \sum_{j=i+k}^{i-1} code[(j+n) \bmod n]
 $$
 
-时间复杂度 $O(n\times|k|)$，忽略答案的空间消耗，空间复杂度 $O(1)$。
+时间复杂度 $O(n \times |k|)$，忽略答案的空间消耗，空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
@@ -209,7 +209,7 @@ function decrypt(code: number[], k: number): number[] {
 
 在方法一中，对于每个位置 $i$，都需要遍历 $k$ 个位置，有很多重复计算的操作。我们可以利用前缀和来优化。
 
-我们将 `code` 数组复制一份（可以不用执行复制操作，直接通过循环遍历取模实现），得到两倍长度的数组，对其求前缀和，得到长度为 $2\times n + 1$ 的前缀和数组 $s$。
+我们将 `code` 数组复制一份（可以不用执行复制操作，直接通过循环遍历取模实现），得到两倍长度的数组，对其求前缀和，得到长度为 $2 \times n + 1$ 的前缀和数组 $s$。
 
 若 $k$ 为正数，那么 $i$ 位置的值为 $i$ 位置后 $k$ 个位置的值之和，即 $ans[i] = s[i + k + 1] - s[i + 1]$。
 

solution/1600-1699/1652.Defuse the Bomb/README_EN.md

@@ -55,7 +55,25 @@
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Simulation
+
+We define an answer array `ans` of length `n`, initially all elements are `0`. According to the problem, if `k` is `0`, return `ans` directly.
+
+Otherwise, we traverse each position `i`:
+
+-   If `k` is a positive number, then the value at position `i` is the sum of the values at the `k` positions after position `i`, that is:
+
+$$
+ans[i] = \sum_{j=i+1}^{i+k} code[j \bmod n]
+$$
+
+-   If `k` is a negative number, then the value at position `i` is the sum of the values at the `|k|` positions before position `i`, that is:
+
+$$
+ans[i] = \sum_{j=i+k}^{i-1} code[(j+n) \bmod n]
+$$
+
+The time complexity is $O(n \times |k|)$, ignoring the space consumption of the answer, the space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
@@ -183,7 +201,17 @@ function decrypt(code: number[], k: number): number[] {
 
 <!-- tabs:end -->
 
-### Solution 2
+### Solution 2: Prefix Sum
+
+In Solution 1, for each position $i$, we need to traverse $k$ positions, which involves a lot of repeated calculations. We can optimize this by using prefix sums.
+
+We duplicate the `code` array (this can be achieved without actually duplicating the array, but by cyclically traversing with modulo operation), resulting in an array of twice the length. We then calculate the prefix sum of this array, resulting in a prefix sum array $s$ of length $2 \times n + 1$.
+
+If $k$ is a positive number, then the value at position $i$ is the sum of the values at the $k$ positions after position $i$, i.e., $ans[i] = s[i + k + 1] - s[i + 1]$.
+
+If $k$ is a negative number, then the value at position $i$ is the sum of the values at the $|k|$ positions before position $i$, i.e., $ans[i] = s[i + n] - s[i + k + n]$.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the `code` array.
 
 <!-- tabs:start -->
 

solution/1600-1699/1653.Minimum Deletions to Make String Balanced/README.md

@@ -65,7 +65,7 @@ $$
 
 我们注意到，状态转移方程中只与前一个状态以及变量 $b$ 有关，因此我们可以仅用一个答案变量 $ans$ 维护当前的 $f[i]$，并不需要开辟数组 $f$。
 
-时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为字符串 $s$ 的长度。
+时间复杂度 $O(n)$，其中 $n$ 为字符串 $s$ 的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 

solution/1600-1699/1653.Minimum Deletions to Make String Balanced/README_EN.md

@@ -39,7 +39,29 @@ Delete the characters at 0-indexed positions 3 and 6 (&quot;aab<u>a</u>bb<u>a</u
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Dynamic Programming
+
+We define $f[i]$ as the minimum number of characters to be deleted in the first $i$ characters to make the string balanced. Initially, $f[0]=0$. The answer is $f[n]$.
+
+We traverse the string $s$, maintaining a variable $b$, which represents the number of character 'b' in the characters before the current position.
+
+-   If the current character is 'b', it does not affect the balance of the first $i$ characters, so $f[i]=f[i-1]$, then we update $b \leftarrow b+1$.
+-   If the current character is 'a', we can choose to delete the current character, so $f[i]=f[i-1]+1$; or we can choose to delete the previous character 'b', so $f[i]=b$. Therefore, we take the minimum of the two, that is, $f[i]=\min(f[i-1]+1,b)$.
+
+In summary, we can get the state transition equation:
+
+$$
+f[i]=\begin{cases}
+f[i-1], & s[i-1]='b'\\
+\min(f[i-1]+1,b), & s[i-1]='a'
+\end{cases}
+$$
+
+The final answer is $f[n]$.
+
+We notice that the state transition equation is only related to the previous state and the variable $b$, so we can just use an answer variable $ans$ to maintain the current $f[i]$, and there is no need to allocate an array $f$.
+
+The time complexity is $O(n)$, where $n$ is the length of the string $s$. The space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
@@ -135,7 +157,13 @@ function minimumDeletions(s: string): number {
 
 <!-- tabs:end -->
 
-### Solution 2
+### Solution 2: Enumeration + Prefix Sum
+
+We can enumerate each position $i$ in the string $s$, dividing the string $s$ into two parts, namely $s[0,..,i-1]$ and $s[i+1,..n-1]$. To make the string balanced, the number of characters we need to delete at the current position $i$ is the number of character 'b' in $s[0,..,i-1]$ plus the number of character 'a' in $s[i+1,..n-1]$.
+
+Therefore, we maintain two variables $lb$ and $ra$ to represent the number of character 'b' in $s[0,..,i-1]$ and the number of character 'a' in $s[i+1,..n-1]$ respectively. The number of characters we need to delete is $lb+ra$. During the enumeration process, we update the variables $lb$ and $ra$.
+
+The time complexity is $O(n)$, and the space complexity is $O(1)$. Here, $n$ is the length of the string $s$.
 
 <!-- tabs:start -->
 

solution/1600-1699/1654.Minimum Jumps to Reach Home/README_EN.md

@@ -56,7 +56,26 @@
 
 ## Solutions
 
-### Solution 1
+### Solution 1: BFS
+
+We can use the position and jumping direction of the flea as the state, and use BFS to search for the shortest path. The key point of this problem is to determine the right boundary, that is, how far the flea can jump.
+
+If $a \geq b$, that is, the distance to jump forward is greater than the distance to jump backward, then if the flea is in a position greater than $x+b$, it can no longer jump forward, because the flea cannot jump backward consecutively. If it continues to jump forward, it will never be able to jump to the position $x$. Therefore, if $a \geq b$, the right boundary can be $x+b$.
+
+If $a < b$, that is, the distance to jump forward is less than the distance to jump backward, then if the position of the flea minus $b$ exceeds $2000$, choose to jump backward, otherwise jump forward. Therefore, if $a < b$, the right boundary does not exceed $6000$.
+
+In summary, we can set the right boundary to $6000$.
+
+Next, we use BFS to search for the shortest path. We use a queue, initially adding the position and jumping direction of the flea as the state to the queue. Each time we take a state from the queue, if the position of this state is equal to $x$, then we have found a path from the initial state to the target state, and we can return the current number of steps. Otherwise, we add the next state of the current state to the queue. There are two cases for the next state:
+
+-   Jump forward, the jumping direction is $1$;
+-   When the current jumping direction is $1$, jump backward, the jumping direction is $0$.
+
+Note that we need to judge whether the next state is legal, that is, the position of the next state does not exceed the right boundary, is not in the forbidden position, and has not been visited.
+
+If the queue is empty, it means that the target position cannot be reached, return $-1$.
+
+The time complexity is $O(M)$, and the space complexity is $O(M)$. Here, $M$ is the right boundary, and in this problem, $M \leq 6000$.
 
 <!-- tabs:start -->
 

solution/1600-1699/1655.Distribute Repeating Integers/README_EN.md

@@ -54,7 +54,21 @@
 
 ## Solutions
 
-### Solution 1
+### Solution 1: State Compression Dynamic Programming + Subset Enumeration
+
+First, we count the occurrence of each number in the array `nums`, and record it in the hash table `cnt`. Then we store the values in the hash table into the array `arr`. We denote the length of the array `arr` as `n`.
+
+Note that the length of the array `quantity` does not exceed 10, so we can use a binary number to represent a subset of `quantity`. That is, the number `j` represents a subset of `quantity`, where the `i`-th bit of the binary representation of `j` is `1` means the `i`-th number in `quantity` is selected, and `0` means the `i`-th number is not selected.
+
+We can preprocess an array `s`, where `s[j]` represents the sum of all numbers in the subset `j` of `quantity`.
+
+Next, we define `f[i][j]` to represent whether the numbers in `arr[0,..i-1]` can be successfully allocated to the subset `j` of `quantity`, where `i` ranges from `[0,..n-1]`, and `j` ranges from `[0,2^m-1]`, where `m` is the length of `quantity`.
+
+Considering `f[i][j]`, if there exists a subset `k` in `j` such that `s[k] <= arr[i]`, and `f[i-1][j XOR k]` is true, then `f[i][j]` is true, otherwise `f[i][j]` is false.
+
+The answer is `f[n-1][2^m-1]`.
+
+The time complexity is `O(n * 3^m)`, and the space complexity is `O(n * 2^m)`. Here, `n` is the number of different integers in the array `nums`, and `m` is the length of the array `quantity`.
 
 <!-- tabs:start -->
 

solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/README_EN.md

@@ -43,7 +43,17 @@
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Hash Table + Prefix Sum
+
+We can transform the problem into finding the maximum length of a continuous subarray in the middle, such that the sum of the subarray is $x = sum(nums) - x$.
+
+Define a hash table `vis`, where `vis[s]` represents the smallest index with a prefix sum of $s$.
+
+Traverse the array `nums`. For each element $nums[i]$, we first add $nums[i]$ to the prefix sum $s$. If $s$ does not exist in the hash table, we add it to the hash table, and its value is the current index $i$. Then we check whether $s - x$ exists in the hash table. If it does, it means that there exists an index $j$ such that the sum of $nums[j + 1,..i]$ is $x$. At this time, we update the minimum value of the answer, that is, $ans = min(ans, n - (i - j))$.
+
+At the end of the traversal, if no subarray meets the condition, return $-1$, otherwise return $ans$.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the array `nums`.
 
 <!-- tabs:start -->
 
@@ -218,7 +228,15 @@ int minOperations(int* nums, int numsSize, int x) {
 
 <!-- tabs:end -->
 
-### Solution 2
+### Solution 2: Two Pointers
+
+Similar to Solution 1, we need to find a subarray such that the sum of the subarray is $x = sum(nums) - x$.
+
+Define two pointers $j$ and $i$, initially $i = j = 0$. Then we move the pointer $i$ to the right, add $nums[i]$ to the prefix sum $s$. If $s > x$, then we move the pointer $j$ to the right in a loop, and subtract $nums[j]$ from the prefix sum $s$, until $s \le x$. If $s = x$, we can update the minimum value of the answer, that is, $ans = min(ans, n - (i - j + 1))$. Continue to move the pointer $i$ to the right, and repeat the above process.
+
+Finally, if no subarray meets the condition, return $-1$, otherwise return $ans$.
+
+The time complexity is $O(n)$, and the space complexity is $O(1)$. Here, $n$ is the length of the array `nums`.
 
 <!-- tabs:start -->