= vec![1; i + 1];
- for j in 1..i {
- new_vec[j] = cur_vec[j - 1] + cur_vec[j];
+ let mut f = vec![vec![1]];
+ for i in 1..num_rows {
+ let mut g = vec![1];
+ for j in 1..f[i as usize - 1].len() {
+ g.push(f[i as usize - 1][j - 1] + f[i as usize - 1][j]);
}
- cur_vec = new_vec.clone();
- ret_vec.push(new_vec);
+ g.push(1);
+ f.push(g);
}
-
- ret_vec
+ f
}
}
diff --git a/solution/0100-0199/0118.Pascal's Triangle/Solution.ts b/solution/0100-0199/0118.Pascal's Triangle/Solution.ts
index 91203940b7925..09857ec026b01 100644
--- a/solution/0100-0199/0118.Pascal's Triangle/Solution.ts
+++ b/solution/0100-0199/0118.Pascal's Triangle/Solution.ts
@@ -2,8 +2,8 @@ function generate(numRows: number): number[][] {
const f: number[][] = [[1]];
for (let i = 0; i < numRows - 1; ++i) {
const g: number[] = [1];
- for (let j = 0; j < f[i].length - 1; ++j) {
- g.push(f[i][j] + f[i][j + 1]);
+ for (let j = 1; j < f[i].length; ++j) {
+ g.push(f[i][j - 1] + f[i][j]);
}
g.push(1);
f.push(g);
diff --git a/solution/0100-0199/0135.Candy/README.md b/solution/0100-0199/0135.Candy/README.md
index 94d99c0474c76..198e8dc5b90b2 100644
--- a/solution/0100-0199/0135.Candy/README.md
+++ b/solution/0100-0199/0135.Candy/README.md
@@ -23,7 +23,7 @@ tags:
- 每个孩子至少分配到
1 个糖果。
- - 相邻两个孩子评分更高的孩子会获得更多的糖果。
+ - 相邻两个孩子中，评分更高的那个会获得更多的糖果。
请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。
diff --git a/solution/0100-0199/0190.Reverse Bits/README.md b/solution/0100-0199/0190.Reverse Bits/README.md
index e151edf982a68..9bcaffac01ee3 100644
--- a/solution/0100-0199/0190.Reverse Bits/README.md
+++ b/solution/0100-0199/0190.Reverse Bits/README.md
@@ -23,33 +23,72 @@ tags:
- 请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。
- - 在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在 示例 2 中，输入表示有符号整数
-3，输出表示有符号整数 -1073741825。
+ - 在 Java 中，编译器使用二进制补码记法来表示有符号整数。
-示例 1：
-
-
-输入：n = 00000010100101000001111010011100
-输出：964176192 (00111001011110000010100101000000)
-解释：输入的二进制串 00000010100101000001111010011100 表示无符号整数 43261596，
- 因此返回 964176192，其二进制表示形式为 00111001011110000010100101000000。
-
-示例 2：
-
-
-输入：n = 11111111111111111111111111111101
-输出：3221225471 (10111111111111111111111111111111)
-解释：输入的二进制串 11111111111111111111111111111101 表示无符号整数 4294967293，
- 因此返回 3221225471 其二进制表示形式为 10111111111111111111111111111111 。
+示例 1：
+
+
+
输入：n = 43261596
+
+
输出：964176192
+
+
解释：
+
+
+
+
+ | 整数 |
+ 二进制 |
+
+
+ | 43261596 |
+ 00000010100101000001111010011100 |
+
+
+ | 964176192 |
+ 00111001011110000010100101000000 |
+
+
+
+
示例 2：
+
+
+
输入：n = 2147483644
+
+
输出：1073741822
+
+
解释：
+
+
+
+
+ | 整数 |
+ 二进制 |
+
+
+ | 2147483644 |
+ 01111111111111111111111111111100 |
+
+
+ | 1073741822 |
+ 00111111111111111111111111111110 |
+
+
+
+
提示：
- - 输入是一个长度为
32 的二进制字符串
+ 0 <= n <= 231 - 2n 为偶数
diff --git a/solution/0100-0199/0190.Reverse Bits/README_EN.md b/solution/0100-0199/0190.Reverse Bits/README_EN.md
index c9cb6f63778a4..9463a8ca49e00 100644
--- a/solution/0100-0199/0190.Reverse Bits/README_EN.md
+++ b/solution/0100-0199/0190.Reverse Bits/README_EN.md
@@ -23,31 +23,70 @@ tags:
- Note that in some languages, such as Java, there is no unsigned integer type. In this case, both input and output will be given as a signed integer type. They should not affect your implementation, as the integer's internal binary representation is the same, whether it is signed or unsigned.
- - In Java, the compiler represents the signed integers using 2's complement notation. Therefore, in Example 2 above, the input represents the signed integer
-3 and the output represents the signed integer -1073741825.
+ - In Java, the compiler represents the signed integers using 2's complement notation.
Example 1:
-
-Input: n = 00000010100101000001111010011100
-Output: 964176192 (00111001011110000010100101000000)
-Explanation: The input binary string 00000010100101000001111010011100 represents the unsigned integer 43261596, so return 964176192 which its binary representation is 00111001011110000010100101000000.
-
+
+
Input: n = 43261596
+
+
Output: 964176192
+
+
Explanation:
+
+
+
+
+ | Integer |
+ Binary |
+
+
+ | 43261596 |
+ 00000010100101000001111010011100 |
+
+
+ | 964176192 |
+ 00111001011110000010100101000000 |
+
+
+
+
Example 2:
-
-Input: n = 11111111111111111111111111111101
-Output: 3221225471 (10111111111111111111111111111111)
-Explanation: The input binary string 11111111111111111111111111111101 represents the unsigned integer 4294967293, so return 3221225471 which its binary representation is 10111111111111111111111111111111.
-
+
+
Input: n = 2147483644
+
+
Output: 1073741822
+
+
Explanation:
+
+
+
+
+ | Integer |
+ Binary |
+
+
+ | 2147483644 |
+ 01111111111111111111111111111100 |
+
+
+ | 1073741822 |
+ 00111111111111111111111111111110 |
+
+
+
+
Constraints:
- - The input must be a binary string of length
32
+ 0 <= n <= 231 - 2n is even.
diff --git a/solution/0200-0299/0231.Power of Two/README.md b/solution/0200-0299/0231.Power of Two/README.md
index 123794f747746..58c8aebfb77a2 100644
--- a/solution/0200-0299/0231.Power of Two/README.md
+++ b/solution/0200-0299/0231.Power of Two/README.md
@@ -67,7 +67,9 @@ tags:
### 方法一：位运算
-$\texttt{n\&(n-1)}$ 可将最后一个二进制形式的 $n$ 的最后一位 $1$ 移除，若移除后为 $0$，说明 $n$ 是 $2$ 的幂。
+根据位运算的性质，执行 $\texttt{n\&(n-1)}$ 可以消去二进制形式的 $n$ 的最后一位 $1$。因此，如果 $n \gt 0$，并且满足 $\texttt{n\&(n-1)}$ 结果为 $0$，则说明 $n$ 是 $2$ 的幂。
+
+时间复杂度 $O(1)$，空间复杂度 $O(1)$。
@@ -116,6 +118,16 @@ function isPowerOfTwo(n: number): boolean {
}
```
+#### Rust
+
+```rust
+impl Solution {
+ pub fn is_power_of_two(n: i32) -> bool {
+ n > 0 && (n & (n - 1)) == 0
+ }
+}
+```
+
#### JavaScript
```js
@@ -134,11 +146,11 @@ var isPowerOfTwo = function (n) {
-### 方法二：lowbit
+### 方法二：Lowbit
-$\texttt{n\&(-n)}$ 可以得到 $n$ 的最后一位 $1$ 表示的十进制数，若与 $n$ 相等，说明 $n$ 是 $2$ 的幂。
+根据 $\text{lowbit}$ 的定义，我们知道 $\text{lowbit}(x) = x \& (-x)$，可以得到 $n$ 的最后一位 $1$ 表示的十进制数。因此，如果 $n > 0$，并且满足 $\text{lowbit}(n)$ 等于 $n$，则说明 $n$ 是 $2$ 的幂。
-注意：要满足 $n$ 是 $2$ 的幂次方，需要保证 $n$ 大于 $0$。
+时间复杂度 $O(1)$，空间复杂度 $O(1)$。
@@ -183,7 +195,17 @@ func isPowerOfTwo(n int) bool {
```ts
function isPowerOfTwo(n: number): boolean {
- return n > 0 && (n & (n - 1)) === 0;
+ return n > 0 && n === (n & -n);
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+ pub fn is_power_of_two(n: i32) -> bool {
+ n > 0 && n == (n & (-n))
+ }
}
```
@@ -195,7 +217,7 @@ function isPowerOfTwo(n: number): boolean {
* @return {boolean}
*/
var isPowerOfTwo = function (n) {
- return n > 0 && n == (n & -n);
+ return n > 0 && n === (n & -n);
};
```
diff --git a/solution/0200-0299/0231.Power of Two/README_EN.md b/solution/0200-0299/0231.Power of Two/README_EN.md
index 53b22983ca354..30345d3519512 100644
--- a/solution/0200-0299/0231.Power of Two/README_EN.md
+++ b/solution/0200-0299/0231.Power of Two/README_EN.md
@@ -62,7 +62,11 @@ tags:
-### Solution 1
+### Solution 1: Bit Manipulation
+
+According to the properties of bit manipulation, executing $\texttt{n\&(n-1)}$ can eliminate the last bit $1$ in the binary form of $n$. Therefore, if $n > 0$ and $\texttt{n\&(n-1)}$ results in $0$, then $n$ is a power of $2$.
+
+The time complexity is $O(1)$, and the space complexity is $O(1)$.
@@ -111,6 +115,16 @@ function isPowerOfTwo(n: number): boolean {
}
```
+#### Rust
+
+```rust
+impl Solution {
+ pub fn is_power_of_two(n: i32) -> bool {
+ n > 0 && (n & (n - 1)) == 0
+ }
+}
+```
+
#### JavaScript
```js
@@ -129,7 +143,11 @@ var isPowerOfTwo = function (n) {
-### Solution 2
+### Solution 2: Lowbit
+
+According to the definition of $\text{lowbit}$, we know that $\text{lowbit}(x) = x \& (-x)$, which can get the decimal number represented by the last bit $1$ of $n$. Therefore, if $n > 0$ and $\text{lowbit}(n)$ equals $n$, then $n$ is a power of $2$.
+
+The time complexity is $O(1)$, and the space complexity is $O(1)$.
@@ -174,7 +192,17 @@ func isPowerOfTwo(n int) bool {
```ts
function isPowerOfTwo(n: number): boolean {
- return n > 0 && (n & (n - 1)) === 0;
+ return n > 0 && n === (n & -n);
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+ pub fn is_power_of_two(n: i32) -> bool {
+ n > 0 && n == (n & (-n))
+ }
}
```
@@ -186,7 +214,7 @@ function isPowerOfTwo(n: number): boolean {
* @return {boolean}
*/
var isPowerOfTwo = function (n) {
- return n > 0 && n == (n & -n);
+ return n > 0 && n === (n & -n);
};
```
diff --git a/solution/0200-0299/0231.Power of Two/Solution.rs b/solution/0200-0299/0231.Power of Two/Solution.rs
new file mode 100644
index 0000000000000..d07cc7d8a7e7a
--- /dev/null
+++ b/solution/0200-0299/0231.Power of Two/Solution.rs
@@ -0,0 +1,5 @@
+impl Solution {
+ pub fn is_power_of_two(n: i32) -> bool {
+ n > 0 && (n & (n - 1)) == 0
+ }
+}
diff --git a/solution/0200-0299/0231.Power of Two/Solution2.js b/solution/0200-0299/0231.Power of Two/Solution2.js
index d0b7a66d9343c..1576a49ffb8e6 100644
--- a/solution/0200-0299/0231.Power of Two/Solution2.js
+++ b/solution/0200-0299/0231.Power of Two/Solution2.js
@@ -3,5 +3,5 @@
* @return {boolean}
*/
var isPowerOfTwo = function (n) {
- return n > 0 && n == (n & -n);
+ return n > 0 && n === (n & -n);
};
diff --git a/solution/0200-0299/0231.Power of Two/Solution2.rs b/solution/0200-0299/0231.Power of Two/Solution2.rs
new file mode 100644
index 0000000000000..40010a60b63ba
--- /dev/null
+++ b/solution/0200-0299/0231.Power of Two/Solution2.rs
@@ -0,0 +1,5 @@
+impl Solution {
+ pub fn is_power_of_two(n: i32) -> bool {
+ n > 0 && n == (n & (-n))
+ }
+}
diff --git a/solution/0200-0299/0231.Power of Two/Solution2.ts b/solution/0200-0299/0231.Power of Two/Solution2.ts
index bfb580cec5184..4bdd7d6c71707 100644
--- a/solution/0200-0299/0231.Power of Two/Solution2.ts
+++ b/solution/0200-0299/0231.Power of Two/Solution2.ts
@@ -1,3 +1,3 @@
function isPowerOfTwo(n: number): boolean {
- return n > 0 && (n & (n - 1)) === 0;
+ return n > 0 && n === (n & -n);
}
diff --git a/solution/0200-0299/0282.Expression Add Operators/README.md b/solution/0200-0299/0282.Expression Add Operators/README.md
index 7c63777b267a2..c5664ca7786b9 100644
--- a/solution/0200-0299/0282.Expression Add Operators/README.md
+++ b/solution/0200-0299/0282.Expression Add Operators/README.md
@@ -18,10 +18,12 @@ tags:
-给定一个仅包含数字 0-9 的字符串 num 和一个目标值整数 target ，在 num 的数字之间添加 二元 运算符（不是一元）+、- 或 * ，返回 所有 能够得到 target 的表达式。
+给定一个仅包含数字 0-9 的字符串 num 和一个目标值整数 target ，在 num 的数字之间添加 二元 运算符（不是一元）+、- 或 * ，返回 所有 能够得到 target 的表达式。
注意，返回表达式中的操作数 不应该 包含前导零。
+注意，一个数字可以包含多个数位。
+
示例 1:
diff --git a/solution/0200-0299/0282.Expression Add Operators/README_EN.md b/solution/0200-0299/0282.Expression Add Operators/README_EN.md
index 083949924e34b..7b0d14c5eba93 100644
--- a/solution/0200-0299/0282.Expression Add Operators/README_EN.md
+++ b/solution/0200-0299/0282.Expression Add Operators/README_EN.md
@@ -22,6 +22,8 @@ tags:
Note that operands in the returned expressions should not contain leading zeros.
+Note that a number can contain multiple digits.
+
Example 1:
diff --git a/solution/0300-0399/0307.Range Sum Query - Mutable/README.md b/solution/0300-0399/0307.Range Sum Query - Mutable/README.md
index 73f33a3388a62..03d184f9857ae 100644
--- a/solution/0300-0399/0307.Range Sum Query - Mutable/README.md
+++ b/solution/0300-0399/0307.Range Sum Query - Mutable/README.md
@@ -7,6 +7,7 @@ tags:
- 树状数组
- 线段树
- 数组
+ - 分治
---
diff --git a/solution/0300-0399/0307.Range Sum Query - Mutable/README_EN.md b/solution/0300-0399/0307.Range Sum Query - Mutable/README_EN.md
index 380df451ebaaf..b9a6a0b062f3b 100644
--- a/solution/0300-0399/0307.Range Sum Query - Mutable/README_EN.md
+++ b/solution/0300-0399/0307.Range Sum Query - Mutable/README_EN.md
@@ -7,6 +7,7 @@ tags:
- Binary Indexed Tree
- Segment Tree
- Array
+ - Divide and Conquer
---
diff --git a/solution/0300-0399/0308.Range Sum Query 2D - Mutable/README.md b/solution/0300-0399/0308.Range Sum Query 2D - Mutable/README.md
index 7beaa49386445..ce09eb5f47c0d 100644
--- a/solution/0300-0399/0308.Range Sum Query 2D - Mutable/README.md
+++ b/solution/0300-0399/0308.Range Sum Query 2D - Mutable/README.md
@@ -62,13 +62,13 @@ numMatrix.sumRegion(2, 1, 4, 3); // 返回 10 (即，右侧红色矩形的和)
m == matrix.length
n == matrix[i].length
1 <= m, n <= 200
- -105 <= matrix[i][j] <= 105
+ -1000 <= matrix[i][j] <= 1000
0 <= row < m
0 <= col < n
- -105 <= val <= 105
+ -1000 <= val <= 1000
0 <= row1 <= row2 < m
0 <= col1 <= col2 < n
- 最多调用104 次 sumRegion 和 update 方法
+ 最多调用5000 次 sumRegion 和 update 方法
diff --git a/solution/0300-0399/0348.Design Tic-Tac-Toe/README.md b/solution/0300-0399/0348.Design Tic-Tac-Toe/README.md
index c3bdea5faf274..a9b134fb52acd 100644
--- a/solution/0300-0399/0348.Design Tic-Tac-Toe/README.md
+++ b/solution/0300-0399/0348.Design Tic-Tac-Toe/README.md
@@ -20,7 +20,7 @@ tags:
-请在 n × n 的棋盘上，实现一个判定井字棋（Tic-Tac-Toe）胜负的神器，判断每一次玩家落子后，是否有胜出的玩家。
+请在 n × n 的棋盘上，实现一个判定井字棋（Tic-Tac-Toe）胜负的神器，判断每一次玩家落子后，是否有胜出的玩家。
在这个井字棋游戏中，会有 2 名玩家，他们将轮流在棋盘上放置自己的棋子。
@@ -34,7 +34,8 @@ tags:
示例:
-给定棋盘边长 n = 3, 玩家 1 的棋子符号是 "X"，玩家 2 的棋子符号是 "O"。
+
+给定棋盘边长 n = 3, 玩家 1 的棋子符号是 "X"，玩家 2 的棋子符号是 "O"。
TicTacToe toe = new TicTacToe(3);
@@ -76,7 +77,17 @@ toe.move(2, 1, 1); -> 函数返回 1 (此时，玩家 1 赢得了该场比赛
-进阶:
+
提示：
+
+
+ 2 <= n <= 100- 玩家是
1 或 2。
+ 0 <= row, col < n- 每次调用
move 时 (row, col) 都是不同的。
+ - 最多调用
move n2 次。
+
+
+进阶:
您有没有可能将每一步的 move() 操作优化到比 O(n2) 更快吗?
diff --git a/solution/0300-0399/0391.Perfect Rectangle/README.md b/solution/0300-0399/0391.Perfect Rectangle/README.md
index 0292de82c3f31..aee93688ddf51 100644
--- a/solution/0300-0399/0391.Perfect Rectangle/README.md
+++ b/solution/0300-0399/0391.Perfect Rectangle/README.md
@@ -3,7 +3,10 @@ comments: true
difficulty: 困难
edit_url: https://github.com/doocs/leetcode/edit/main/solution/0300-0399/0391.Perfect%20Rectangle/README.md
tags:
+ - 几何
- 数组
+ - 哈希表
+ - 数学
- 扫描线
---
diff --git a/solution/0300-0399/0391.Perfect Rectangle/README_EN.md b/solution/0300-0399/0391.Perfect Rectangle/README_EN.md
index 6c770c7548d75..7fc5040dfe3c2 100644
--- a/solution/0300-0399/0391.Perfect Rectangle/README_EN.md
+++ b/solution/0300-0399/0391.Perfect Rectangle/README_EN.md
@@ -3,7 +3,10 @@ comments: true
difficulty: Hard
edit_url: https://github.com/doocs/leetcode/edit/main/solution/0300-0399/0391.Perfect%20Rectangle/README_EN.md
tags:
+ - Geometry
- Array
+ - Hash Table
+ - Math
- Line Sweep
---
diff --git a/solution/0300-0399/0394.Decode String/README.md b/solution/0300-0399/0394.Decode String/README.md
index 0cbd5f13b03b2..7d1e91b5d87c6 100644
--- a/solution/0300-0399/0394.Decode String/README.md
+++ b/solution/0300-0399/0394.Decode String/README.md
@@ -26,6 +26,8 @@ tags:
此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k ，例如不会出现像 3a 或 2[4] 的输入。
+测试用例保证输出的长度不会超过 105。
+
示例 1：
diff --git a/solution/0400-0499/0405.Convert a Number to Hexadecimal/README.md b/solution/0400-0499/0405.Convert a Number to Hexadecimal/README.md
index c7938f4dbc6e9..02ff376c891b7 100644
--- a/solution/0400-0499/0405.Convert a Number to Hexadecimal/README.md
+++ b/solution/0400-0499/0405.Convert a Number to Hexadecimal/README.md
@@ -5,6 +5,7 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/0400-0499/0405.Co
tags:
- 位运算
- 数学
+ - 字符串
---
diff --git a/solution/0400-0499/0405.Convert a Number to Hexadecimal/README_EN.md b/solution/0400-0499/0405.Convert a Number to Hexadecimal/README_EN.md
index d47e566ca8a25..97a155f1808e6 100644
--- a/solution/0400-0499/0405.Convert a Number to Hexadecimal/README_EN.md
+++ b/solution/0400-0499/0405.Convert a Number to Hexadecimal/README_EN.md
@@ -5,6 +5,7 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/0400-0499/0405.Co
tags:
- Bit Manipulation
- Math
+ - String
---
diff --git a/solution/0400-0499/0427.Construct Quad Tree/README.md b/solution/0400-0499/0427.Construct Quad Tree/README.md
index 561c58bac14f4..7afa044e1460a 100644
--- a/solution/0400-0499/0427.Construct Quad Tree/README.md
+++ b/solution/0400-0499/0427.Construct Quad Tree/README.md
@@ -50,7 +50,7 @@ class Node {
-如果你想了解更多关于四叉树的内容，可以参考 wiki 。
+如果你想了解更多关于四叉树的内容，可以参考 百科 。
四叉树格式：
diff --git a/solution/0400-0499/0472.Concatenated Words/README.md b/solution/0400-0499/0472.Concatenated Words/README.md
index c487d2cb51c56..31954b9e6721f 100644
--- a/solution/0400-0499/0472.Concatenated Words/README.md
+++ b/solution/0400-0499/0472.Concatenated Words/README.md
@@ -8,6 +8,7 @@ tags:
- 数组
- 字符串
- 动态规划
+ - 排序
---
diff --git a/solution/0400-0499/0472.Concatenated Words/README_EN.md b/solution/0400-0499/0472.Concatenated Words/README_EN.md
index 64039ca4901b3..5635be4155bb9 100644
--- a/solution/0400-0499/0472.Concatenated Words/README_EN.md
+++ b/solution/0400-0499/0472.Concatenated Words/README_EN.md
@@ -8,6 +8,7 @@ tags:
- Array
- String
- Dynamic Programming
+ - Sorting
---
diff --git a/solution/0400-0499/0475.Heaters/README_EN.md b/solution/0400-0499/0475.Heaters/README_EN.md
index 518ecb9eb8201..8b63f1ef8dea6 100644
--- a/solution/0400-0499/0475.Heaters/README_EN.md
+++ b/solution/0400-0499/0475.Heaters/README_EN.md
@@ -25,7 +25,7 @@ tags:
Given the positions of houses and heaters on a horizontal line, return the minimum radius standard of heaters so that those heaters could cover all houses.
-Notice that all the heaters follow your radius standard, and the warm radius will the same.
+Notice that all the heaters follow your radius standard, and the warm radius will be the same.
Example 1:
diff --git a/solution/0400-0499/0499.The Maze III/README.md b/solution/0400-0499/0499.The Maze III/README.md
index 65546e7027af0..8b82449612cf2 100644
--- a/solution/0400-0499/0499.The Maze III/README.md
+++ b/solution/0400-0499/0499.The Maze III/README.md
@@ -23,9 +23,9 @@ tags:
-由空地和墙组成的迷宫中有一个球。球可以向上（u）下（d）左（l）右（r）四个方向滚动，但在遇到墙壁前不会停止滚动。当球停下时，可以选择下一个方向。迷宫中还有一个洞，当球运动经过洞时，就会掉进洞里。
+由空地和墙组成的迷宫中有一个球。球可以向上（u）下（d）左（l）右（r）四个方向滚动，但在遇到墙壁前不会停止滚动。当球停下时，可以选择下一个方向（必须与上一个选择的方向不同）。迷宫中还有一个洞，当球运动经过洞时，就会掉进洞里。
-给定球的起始位置，目的地和迷宫，找出让球以最短距离掉进洞里的路径。 距离的定义是球从起始位置（不包括）到目的地（包括）经过的空地个数。通过'u', 'd', 'l' 和 'r'输出球的移动方向。 由于可能有多条最短路径， 请输出字典序最小的路径。如果球无法进入洞，输出"impossible"。
+给定球的起始位置，目的地和迷宫，找出让球以最短距离掉进洞里的路径。 距离的定义是球从起始位置（不包括）到目的地（包括）经过的空地个数。通过'u', 'd', 'l' 和 'r'输出球的移动方向。 由于可能有多条最短路径， 请输出字典序最小的路径。如果球无法进入洞，输出"impossible"。
迷宫由一个0和1的二维数组表示。 1表示墙壁，0表示空地。你可以假定迷宫的边缘都是墙壁。起始位置和目的地的坐标通过行号和列号给出。
@@ -33,7 +33,8 @@ tags:
示例1:
-输入 1: 迷宫由以下二维数组表示
+
+输入 1: 迷宫由以下二维数组表示
0 0 0 0 0
1 1 0 0 1
@@ -44,18 +45,19 @@ tags:
输入 2: 球的初始位置 (rowBall, colBall) = (4, 3)
输入 3: 洞的位置 (rowHole, colHole) = (0, 1)
-输出: "lul"
+输出: "lul"
解析: 有两条让球进洞的最短路径。
-第一条路径是 左 -> 上 -> 左, 记为 "lul".
-第二条路径是 上 -> 左, 记为 'ul'.
-两条路径都具有最短距离6, 但'l' < 'u'，故第一条路径字典序更小。因此输出"lul"。
-
+第一条路径是 左 -> 上 -> 左, 记为 "lul".
+第二条路径是 上 -> 左, 记为 'ul'.
+两条路径都具有最短距离6, 但'l' < 'u'，故第一条路径字典序更小。因此输出"lul"。
+
示例 2:
-输入 1: 迷宫由以下二维数组表示
+
+输入 1: 迷宫由以下二维数组表示
0 0 0 0 0
1 1 0 0 1
@@ -66,10 +68,10 @@ tags:
输入 2: 球的初始位置 (rowBall, colBall) = (4, 3)
输入 3: 洞的位置 (rowHole, colHole) = (3, 0)
-输出: "impossible"
+输出: "impossible"
示例: 球无法到达洞。
-
+
diff --git a/solution/0400-0499/0499.The Maze III/README_EN.md b/solution/0400-0499/0499.The Maze III/README_EN.md
index b1f7423cdc14e..44d79709ee175 100644
--- a/solution/0400-0499/0499.The Maze III/README_EN.md
+++ b/solution/0400-0499/0499.The Maze III/README_EN.md
@@ -23,7 +23,7 @@ tags:
-There is a ball in a maze with empty spaces (represented as 0) and walls (represented as 1). The ball can go through the empty spaces by rolling up, down, left or right, but it won't stop rolling until hitting a wall. When the ball stops, it could choose the next direction. There is also a hole in this maze. The ball will drop into the hole if it rolls onto the hole.
+There is a ball in a maze with empty spaces (represented as 0) and walls (represented as 1). The ball can go through the empty spaces by rolling up, down, left or right, but it won't stop rolling until hitting a wall. When the ball stops, it could choose the next direction (must be different from last chosen direction). There is also a hole in this maze. The ball will drop into the hole if it rolls onto the hole.
Given the m x n maze, the ball's position ball and the hole's position hole, where ball = [ballrow, ballcol] and hole = [holerow, holecol], return a string instructions of all the instructions that the ball should follow to drop in the hole with the shortest distance possible. If there are multiple valid instructions, return the lexicographically minimum one. If the ball can't drop in the hole, return "impossible".
diff --git a/solution/0500-0599/0504.Base 7/README.md b/solution/0500-0599/0504.Base 7/README.md
index 1e955a5f67ddb..4777530cac658 100644
--- a/solution/0500-0599/0504.Base 7/README.md
+++ b/solution/0500-0599/0504.Base 7/README.md
@@ -4,6 +4,7 @@ difficulty: 简单
edit_url: https://github.com/doocs/leetcode/edit/main/solution/0500-0599/0504.Base%207/README.md
tags:
- 数学
+ - 字符串
---
diff --git a/solution/0500-0599/0504.Base 7/README_EN.md b/solution/0500-0599/0504.Base 7/README_EN.md
index c769e0816a5eb..20c58cdef8dff 100644
--- a/solution/0500-0599/0504.Base 7/README_EN.md
+++ b/solution/0500-0599/0504.Base 7/README_EN.md
@@ -4,6 +4,7 @@ difficulty: Easy
edit_url: https://github.com/doocs/leetcode/edit/main/solution/0500-0599/0504.Base%207/README_EN.md
tags:
- Math
+ - String
---
diff --git a/solution/0500-0599/0544.Output Contest Matches/README.md b/solution/0500-0599/0544.Output Contest Matches/README.md
index 6a0ea9563e040..a834513118b31 100644
--- a/solution/0500-0599/0544.Output Contest Matches/README.md
+++ b/solution/0500-0599/0544.Output Contest Matches/README.md
@@ -58,7 +58,7 @@ tags:
提示：
- n == 2x，并且 x 在范围 [1,12] 内。n == 2x，并且 x 在范围 [1, 12] 内。
diff --git a/solution/0500-0599/0545.Boundary of Binary Tree/README_EN.md b/solution/0500-0599/0545.Boundary of Binary Tree/README_EN.md
index 4f10da50e84bf..b4f26e396ae40 100644
--- a/solution/0500-0599/0545.Boundary of Binary Tree/README_EN.md
+++ b/solution/0500-0599/0545.Boundary of Binary Tree/README_EN.md
@@ -24,7 +24,7 @@ tags:
- The root node's left child is in the left boundary. If the root does not have a left child, then the left boundary is empty.
- - If a node in the left boundary and has a left child, then the left child is in the left boundary.
+ - If a node is in the left boundary and has a left child, then the left child is in the left boundary.
- If a node is in the left boundary, has no left child, but has a right child, then the right child is in the left boundary.
- The leftmost leaf is not in the left boundary.
diff --git a/solution/0500-0599/0584.Find Customer Referee/README.md b/solution/0500-0599/0584.Find Customer Referee/README.md
index 5c2a099a2d835..fa63febcea511 100644
--- a/solution/0500-0599/0584.Find Customer Referee/README.md
+++ b/solution/0500-0599/0584.Find Customer Referee/README.md
@@ -29,7 +29,12 @@ tags:
在 SQL 中，id 是该表的主键列。
该表的每一行表示一个客户的 id、姓名以及推荐他们的客户的 id。
-找出那些 没有被 id = 2 的客户 推荐 的客户的姓名。
+找出以下客户的姓名：
+
+
+ - 被任何
id != 2 的用户推荐。
+ - 没有被 任何用户推荐。
+
以 任意顺序 返回结果表。
diff --git a/solution/0500-0599/0584.Find Customer Referee/README_EN.md b/solution/0500-0599/0584.Find Customer Referee/README_EN.md
index d6810684bb34e..0bd8a5c948aff 100644
--- a/solution/0500-0599/0584.Find Customer Referee/README_EN.md
+++ b/solution/0500-0599/0584.Find Customer Referee/README_EN.md
@@ -32,7 +32,12 @@ Each row of this table indicates the id of a customer, their name, and the id of
-Find the names of the customer that are not referred by the customer with id = 2.
+Find the names of the customer that are either:
+
+
+ - referred by any customer with
id != 2.
+ - not referred by any customer.
+
Return the result table in any order.
diff --git a/solution/0600-0699/0630.Course Schedule III/README.md b/solution/0600-0699/0630.Course Schedule III/README.md
index 6375a17781381..0892c7c3ea024 100644
--- a/solution/0600-0699/0630.Course Schedule III/README.md
+++ b/solution/0600-0699/0630.Course Schedule III/README.md
@@ -179,13 +179,13 @@ func (h *hp) pop() int { return heap.Pop(h).(int) }
```ts
function scheduleCourse(courses: number[][]): number {
courses.sort((a, b) => a[1] - b[1]);
- const pq = new MaxPriorityQueue();
+ const pq = new MaxPriorityQueue();
let s = 0;
for (const [duration, last] of courses) {
pq.enqueue(duration);
s += duration;
while (s > last) {
- s -= pq.dequeue().element;
+ s -= pq.dequeue();
}
}
return pq.size();
diff --git a/solution/0600-0699/0630.Course Schedule III/README_EN.md b/solution/0600-0699/0630.Course Schedule III/README_EN.md
index 635e4695af275..c62bec88ced90 100644
--- a/solution/0600-0699/0630.Course Schedule III/README_EN.md
+++ b/solution/0600-0699/0630.Course Schedule III/README_EN.md
@@ -170,13 +170,13 @@ func (h *hp) pop() int { return heap.Pop(h).(int) }
```ts
function scheduleCourse(courses: number[][]): number {
courses.sort((a, b) => a[1] - b[1]);
- const pq = new MaxPriorityQueue();
+ const pq = new MaxPriorityQueue();
let s = 0;
for (const [duration, last] of courses) {
pq.enqueue(duration);
s += duration;
while (s > last) {
- s -= pq.dequeue().element;
+ s -= pq.dequeue();
}
}
return pq.size();
diff --git a/solution/0600-0699/0630.Course Schedule III/Solution.ts b/solution/0600-0699/0630.Course Schedule III/Solution.ts
index cf53fa353f7fb..fa2048b5b649b 100644
--- a/solution/0600-0699/0630.Course Schedule III/Solution.ts
+++ b/solution/0600-0699/0630.Course Schedule III/Solution.ts
@@ -1,12 +1,12 @@
function scheduleCourse(courses: number[][]): number {
courses.sort((a, b) => a[1] - b[1]);
- const pq = new MaxPriorityQueue();
+ const pq = new MaxPriorityQueue();
let s = 0;
for (const [duration, last] of courses) {
pq.enqueue(duration);
s += duration;
while (s > last) {
- s -= pq.dequeue().element;
+ s -= pq.dequeue();
}
}
return pq.size();
diff --git a/solution/0700-0799/0778.Swim in Rising Water/README_EN.md b/solution/0700-0799/0778.Swim in Rising Water/README_EN.md
index 8212558afeb12..6f71d19110991 100644
--- a/solution/0700-0799/0778.Swim in Rising Water/README_EN.md
+++ b/solution/0700-0799/0778.Swim in Rising Water/README_EN.md
@@ -24,9 +24,11 @@ tags:
You are given an n x n integer matrix grid where each value grid[i][j] represents the elevation at that point (i, j).
-The rain starts to fall. At time t, the depth of the water everywhere is t. You can swim from a square to another 4-directionally adjacent square if and only if the elevation of both squares individually are at most t. You can swim infinite distances in zero time. Of course, you must stay within the boundaries of the grid during your swim.
+It starts raining, and water gradually rises over time. At time t, the water level is t, meaning any cell with elevation less than equal to t is submerged or reachable.
-Return the least time until you can reach the bottom right square (n - 1, n - 1) if you start at the top left square (0, 0).
+You can swim from a square to another 4-directionally adjacent square if and only if the elevation of both squares individually are at most t. You can swim infinite distances in zero time. Of course, you must stay within the boundaries of the grid during your swim.
+
+Return the minimum time until you can reach the bottom right square (n - 1, n - 1) if you start at the top left square (0, 0).
Example 1:
diff --git a/solution/0800-0899/0802.Find Eventual Safe States/README.md b/solution/0800-0899/0802.Find Eventual Safe States/README.md
index 06994079ec0b8..fe644d4423d8d 100644
--- a/solution/0800-0899/0802.Find Eventual Safe States/README.md
+++ b/solution/0800-0899/0802.Find Eventual Safe States/README.md
@@ -21,7 +21,7 @@ tags:
有一个有 n 个节点的有向图，节点按 0 到 n - 1 编号。图由一个 索引从 0 开始 的 2D 整数数组 graph表示， graph[i]是与节点 i 相邻的节点的整数数组，这意味着从节点 i 到 graph[i]中的每个节点都有一条边。
-如果一个节点没有连出的有向边，则该节点是 终端节点 。如果从该节点开始的所有可能路径都通向 终端节点 ，则该节点为 终端节点（或另一个安全节点）。
+如果一个节点没有连出的有向边，则该节点是 终端节点 。如果从该节点开始的所有可能路径都通向 终端节点（或另一个安全节点），则该节点为 安全节点。
返回一个由图中所有 安全节点 组成的数组作为答案。答案数组中的元素应当按 升序 排列。
diff --git a/solution/0800-0899/0808.Soup Servings/README.md b/solution/0800-0899/0808.Soup Servings/README.md
index d6a4fb0c35681..598b2d354b358 100644
--- a/solution/0800-0899/0808.Soup Servings/README.md
+++ b/solution/0800-0899/0808.Soup Servings/README.md
@@ -18,29 +18,36 @@ tags:
-有 A 和 B 两种类型 的汤。一开始每种类型的汤有 n 毫升。有四种分配操作：
+你有两种汤，A 和 B，每种初始为 n 毫升。在每一轮中，会随机选择以下四种操作中的一种，每种操作的概率为 0.25，且与之前的所有轮次 无关：
- - 提供
100ml 的 汤A 和 0ml 的 汤B 。
- - 提供
75ml 的 汤A 和 25ml 的 汤B 。
- - 提供
50ml 的 汤A 和 50ml 的 汤B 。
- - 提供
25ml 的 汤A 和 75ml 的 汤B 。
+ - 从汤 A 取 100 毫升，从汤 B 取 0 毫升
+ - 从汤 A 取 75 毫升，从汤 B 取 25 毫升
+ - 从汤 A 取 50 毫升，从汤 B 取 50 毫升
+ - 从汤 A 取 25 毫升，从汤 B 取 75 毫升
-当我们把汤分配给某人之后，汤就没有了。每个回合，我们将从四种概率同为 0.25 的操作中进行分配选择。如果汤的剩余量不足以完成某次操作，我们将尽可能分配。当两种类型的汤都分配完时，停止操作。
+注意：
-注意 不存在先分配 100 ml 汤B 的操作。
+
+ - 不存在从汤 A 取
0 ml 和从汤 B 取 100 ml 的操作。
+ - 汤 A 和 B 在每次操作中同时被取出。
+ - 如果一次操作要求你取出比剩余的汤更多的量，请取出该汤剩余的所有部分。
+
+
+操作过程在任何回合中任一汤被取完后立即停止。
-需要返回的值： 汤A 先分配完的概率 + 汤A和汤B 同时分配完的概率 / 2。返回值在正确答案 10-5 的范围内将被认为是正确的。
+返回汤 A 在 B 前取完的概率，加上两种汤在 同一回合 取完概率的一半。返回值在正确答案 10-5 的范围内将被认为是正确的。
示例 1:
-输入: n = 50
-输出: 0.62500
-解释:如果我们选择前两个操作，A 首先将变为空。
+输入：n = 50
+输出：0.62500
+解释：
+如果我们选择前两个操作，A 首先将变为空。
对于第三个操作，A 和 B 会同时变为空。
对于第四个操作，B 首先将变为空。
所以 A 变为空的总概率加上 A 和 B 同时变为空的概率的一半是 0.25 *(1 + 1 + 0.5 + 0)= 0.625。
@@ -49,8 +56,14 @@ tags:
示例 2:
-输入: n = 100
-输出: 0.71875
+输入：n = 100
+输出：0.71875
+解释：
+如果我们选择第一个操作，A 首先将变为空。
+如果我们选择第二个操作，A 将在执行操作 [1, 2, 3] 时变为空，然后 A 和 B 在执行操作 4 时同时变空。
+如果我们选择第三个操作，A 将在执行操作 [1, 2] 时变为空，然后 A 和 B 在执行操作 3 时同时变空。
+如果我们选择第四个操作，A 将在执行操作 1 时变为空，然后 A 和 B 在执行操作 2 时同时变空。
+所以 A 变为空的总概率加上 A 和 B 同时变为空的概率的一半是 0.71875。
@@ -58,7 +71,7 @@ tags:
提示:
- 0 <= n <= 1090 <= n <= 109
@@ -157,7 +170,7 @@ class Solution {
public:
double soupServings(int n) {
double f[200][200] = {0.0};
- function dfs = [&](int i, int j) -> double {
+ auto dfs = [&](this auto&& dfs, int i, int j) -> double {
if (i <= 0 && j <= 0) return 0.5;
if (i <= 0) return 1;
if (j <= 0) return 0;
@@ -205,7 +218,7 @@ func soupServings(n int) float64 {
```ts
function soupServings(n: number): number {
- const f = new Array(200).fill(0).map(() => new Array(200).fill(-1));
+ const f = Array.from({ length: 200 }, () => Array(200).fill(-1));
const dfs = (i: number, j: number): number => {
if (i <= 0 && j <= 0) {
return 0.5;
@@ -227,6 +240,77 @@ function soupServings(n: number): number {
}
```
+#### Rust
+
+```rust
+impl Solution {
+ pub fn soup_servings(n: i32) -> f64 {
+ if n > 4800 {
+ return 1.0;
+ }
+ Self::dfs((n + 24) / 25, (n + 24) / 25)
+ }
+
+ fn dfs(i: i32, j: i32) -> f64 {
+ static mut F: [[f64; 200]; 200] = [[0.0; 200]; 200];
+
+ unsafe {
+ if i <= 0 && j <= 0 {
+ return 0.5;
+ }
+ if i <= 0 {
+ return 1.0;
+ }
+ if j <= 0 {
+ return 0.0;
+ }
+ if F[i as usize][j as usize] > 0.0 {
+ return F[i as usize][j as usize];
+ }
+
+ let ans = 0.25 * (Self::dfs(i - 4, j) + Self::dfs(i - 3, j - 1) + Self::dfs(i - 2, j - 2) + Self::dfs(i - 1, j - 3));
+ F[i as usize][j as usize] = ans;
+ ans
+ }
+ }
+}
+```
+
+#### C#
+
+```cs
+public class Solution {
+ private double[,] f = new double[200, 200];
+
+ public double SoupServings(int n) {
+ if (n > 4800) {
+ return 1.0;
+ }
+
+ return Dfs((n + 24) / 25, (n + 24) / 25);
+ }
+
+ private double Dfs(int i, int j) {
+ if (i <= 0 && j <= 0) {
+ return 0.5;
+ }
+ if (i <= 0) {
+ return 1.0;
+ }
+ if (j <= 0) {
+ return 0.0;
+ }
+ if (f[i, j] > 0) {
+ return f[i, j];
+ }
+
+ double ans = 0.25 * (Dfs(i - 4, j) + Dfs(i - 3, j - 1) + Dfs(i - 2, j - 2) + Dfs(i - 1, j - 3));
+ f[i, j] = ans;
+ return ans;
+ }
+}
+```
+
diff --git a/solution/0800-0899/0808.Soup Servings/README_EN.md b/solution/0800-0899/0808.Soup Servings/README_EN.md
index 46661ed7c7bef..e65944861f883 100644
--- a/solution/0800-0899/0808.Soup Servings/README_EN.md
+++ b/solution/0800-0899/0808.Soup Servings/README_EN.md
@@ -18,20 +18,26 @@ tags:
-There are two types of soup: type A and type B. Initially, we have n ml of each type of soup. There are four kinds of operations:
+You have two soups, A and B, each starting with n mL. On every turn, one of the following four serving operations is chosen at random, each with probability 0.25 independent of all previous turns:
-
- - Serve
100 ml of soup A and 0 ml of soup B,
- - Serve
75 ml of soup A and 25 ml of soup B,
- - Serve
50 ml of soup A and 50 ml of soup B, and
- - Serve
25 ml of soup A and 75 ml of soup B.
-
+
+ - pour 100 mL from type A and 0 mL from type B
+ - pour 75 mL from type A and 25 mL from type B
+ - pour 50 mL from type A and 50 mL from type B
+ - pour 25 mL from type A and 75 mL from type B
+
+
+Note:
-When we serve some soup, we give it to someone, and we no longer have it. Each turn, we will choose from the four operations with an equal probability 0.25. If the remaining volume of soup is not enough to complete the operation, we will serve as much as possible. We stop once we no longer have some quantity of both types of soup.
+
+ - There is no operation that pours 0 mL from A and 100 mL from B.
+ - The amounts from A and B are poured simultaneously during the turn.
+ - If an operation asks you to pour more than you have left of a soup, pour all that remains of that soup.
+
-Note that we do not have an operation where all 100 ml's of soup B are used first.
+The process stops immediately after any turn in which one of the soups is used up.
-Return the probability that soup A will be empty first, plus half the probability that A and B become empty at the same time. Answers within 10-5 of the actual answer will be accepted.
+Return the probability that A is used up before B, plus half the probability that both soups are used up in the same turn. Answers within 10-5 of the actual answer will be accepted.
Example 1:
@@ -39,9 +45,10 @@ tags:
Input: n = 50
Output: 0.62500
-Explanation: If we choose the first two operations, A will become empty first.
-For the third operation, A and B will become empty at the same time.
-For the fourth operation, B will become empty first.
+Explanation:
+If we perform either of the first two serving operations, soup A will become empty first.
+If we perform the third operation, A and B will become empty at the same time.
+If we perform the fourth operation, B will become empty first.
So the total probability of A becoming empty first plus half the probability that A and B become empty at the same time, is 0.25 * (1 + 1 + 0.5 + 0) = 0.625.
@@ -50,6 +57,12 @@ So the total probability of A becoming empty first plus half the probability tha
Input: n = 100
Output: 0.71875
+Explanation:
+If we perform the first serving operation, soup A will become empty first.
+If we perform the second serving operations, A will become empty on performing operation [1, 2, 3], and both A and B become empty on performing operation 4.
+If we perform the third operation, A will become empty on performing operation [1, 2], and both A and B become empty on performing operation 3.
+If we perform the fourth operation, A will become empty on performing operation 1, and both A and B become empty on performing operation 2.
+So the total probability of A becoming empty first plus half the probability that A and B become empty at the same time, is 0.71875.
@@ -155,7 +168,7 @@ class Solution {
public:
double soupServings(int n) {
double f[200][200] = {0.0};
- function dfs = [&](int i, int j) -> double {
+ auto dfs = [&](this auto&& dfs, int i, int j) -> double {
if (i <= 0 && j <= 0) return 0.5;
if (i <= 0) return 1;
if (j <= 0) return 0;
@@ -203,7 +216,7 @@ func soupServings(n int) float64 {
```ts
function soupServings(n: number): number {
- const f = new Array(200).fill(0).map(() => new Array(200).fill(-1));
+ const f = Array.from({ length: 200 }, () => Array(200).fill(-1));
const dfs = (i: number, j: number): number => {
if (i <= 0 && j <= 0) {
return 0.5;
@@ -225,6 +238,77 @@ function soupServings(n: number): number {
}
```
+#### Rust
+
+```rust
+impl Solution {
+ pub fn soup_servings(n: i32) -> f64 {
+ if n > 4800 {
+ return 1.0;
+ }
+ Self::dfs((n + 24) / 25, (n + 24) / 25)
+ }
+
+ fn dfs(i: i32, j: i32) -> f64 {
+ static mut F: [[f64; 200]; 200] = [[0.0; 200]; 200];
+
+ unsafe {
+ if i <= 0 && j <= 0 {
+ return 0.5;
+ }
+ if i <= 0 {
+ return 1.0;
+ }
+ if j <= 0 {
+ return 0.0;
+ }
+ if F[i as usize][j as usize] > 0.0 {
+ return F[i as usize][j as usize];
+ }
+
+ let ans = 0.25 * (Self::dfs(i - 4, j) + Self::dfs(i - 3, j - 1) + Self::dfs(i - 2, j - 2) + Self::dfs(i - 1, j - 3));
+ F[i as usize][j as usize] = ans;
+ ans
+ }
+ }
+}
+```
+
+#### C#
+
+```cs
+public class Solution {
+ private double[,] f = new double[200, 200];
+
+ public double SoupServings(int n) {
+ if (n > 4800) {
+ return 1.0;
+ }
+
+ return Dfs((n + 24) / 25, (n + 24) / 25);
+ }
+
+ private double Dfs(int i, int j) {
+ if (i <= 0 && j <= 0) {
+ return 0.5;
+ }
+ if (i <= 0) {
+ return 1.0;
+ }
+ if (j <= 0) {
+ return 0.0;
+ }
+ if (f[i, j] > 0) {
+ return f[i, j];
+ }
+
+ double ans = 0.25 * (Dfs(i - 4, j) + Dfs(i - 3, j - 1) + Dfs(i - 2, j - 2) + Dfs(i - 1, j - 3));
+ f[i, j] = ans;
+ return ans;
+ }
+}
+```
+
diff --git a/solution/0800-0899/0808.Soup Servings/Solution.cpp b/solution/0800-0899/0808.Soup Servings/Solution.cpp
index c9553e7e3eb65..7dc8b14365c4a 100644
--- a/solution/0800-0899/0808.Soup Servings/Solution.cpp
+++ b/solution/0800-0899/0808.Soup Servings/Solution.cpp
@@ -2,7 +2,7 @@ class Solution {
public:
double soupServings(int n) {
double f[200][200] = {0.0};
- function dfs = [&](int i, int j) -> double {
+ auto dfs = [&](this auto&& dfs, int i, int j) -> double {
if (i <= 0 && j <= 0) return 0.5;
if (i <= 0) return 1;
if (j <= 0) return 0;
diff --git a/solution/0800-0899/0808.Soup Servings/Solution.cs b/solution/0800-0899/0808.Soup Servings/Solution.cs
new file mode 100644
index 0000000000000..0cbe75c41c284
--- /dev/null
+++ b/solution/0800-0899/0808.Soup Servings/Solution.cs
@@ -0,0 +1,30 @@
+public class Solution {
+ private double[,] f = new double[200, 200];
+
+ public double SoupServings(int n) {
+ if (n > 4800) {
+ return 1.0;
+ }
+
+ return Dfs((n + 24) / 25, (n + 24) / 25);
+ }
+
+ private double Dfs(int i, int j) {
+ if (i <= 0 && j <= 0) {
+ return 0.5;
+ }
+ if (i <= 0) {
+ return 1.0;
+ }
+ if (j <= 0) {
+ return 0.0;
+ }
+ if (f[i, j] > 0) {
+ return f[i, j];
+ }
+
+ double ans = 0.25 * (Dfs(i - 4, j) + Dfs(i - 3, j - 1) + Dfs(i - 2, j - 2) + Dfs(i - 1, j - 3));
+ f[i, j] = ans;
+ return ans;
+ }
+}
diff --git a/solution/0800-0899/0808.Soup Servings/Solution.rs b/solution/0800-0899/0808.Soup Servings/Solution.rs
new file mode 100644
index 0000000000000..177c2f271cd1a
--- /dev/null
+++ b/solution/0800-0899/0808.Soup Servings/Solution.rs
@@ -0,0 +1,35 @@
+impl Solution {
+ pub fn soup_servings(n: i32) -> f64 {
+ if n > 4800 {
+ return 1.0;
+ }
+ Self::dfs((n + 24) / 25, (n + 24) / 25)
+ }
+
+ fn dfs(i: i32, j: i32) -> f64 {
+ static mut F: [[f64; 200]; 200] = [[0.0; 200]; 200];
+
+ unsafe {
+ if i <= 0 && j <= 0 {
+ return 0.5;
+ }
+ if i <= 0 {
+ return 1.0;
+ }
+ if j <= 0 {
+ return 0.0;
+ }
+ if F[i as usize][j as usize] > 0.0 {
+ return F[i as usize][j as usize];
+ }
+
+ let ans = 0.25
+ * (Self::dfs(i - 4, j)
+ + Self::dfs(i - 3, j - 1)
+ + Self::dfs(i - 2, j - 2)
+ + Self::dfs(i - 1, j - 3));
+ F[i as usize][j as usize] = ans;
+ ans
+ }
+ }
+}
diff --git a/solution/0800-0899/0808.Soup Servings/Solution.ts b/solution/0800-0899/0808.Soup Servings/Solution.ts
index 4afce5c07f60f..d6e1b08085e6a 100644
--- a/solution/0800-0899/0808.Soup Servings/Solution.ts
+++ b/solution/0800-0899/0808.Soup Servings/Solution.ts
@@ -1,5 +1,5 @@
function soupServings(n: number): number {
- const f = new Array(200).fill(0).map(() => new Array(200).fill(-1));
+ const f = Array.from({ length: 200 }, () => Array(200).fill(-1));
const dfs = (i: number, j: number): number => {
if (i <= 0 && j <= 0) {
return 0.5;
diff --git a/solution/0800-0899/0853.Car Fleet/README_EN.md b/solution/0800-0899/0853.Car Fleet/README_EN.md
index 29c9d8eef5cd8..ea080f66ff7db 100644
--- a/solution/0800-0899/0853.Car Fleet/README_EN.md
+++ b/solution/0800-0899/0853.Car Fleet/README_EN.md
@@ -21,7 +21,7 @@ tags:
There are n cars at given miles away from the starting mile 0, traveling to reach the mile target.
-You are given two integer array position and speed, both of length n, where position[i] is the starting mile of the ith car and speed[i] is the speed of the ith car in miles per hour.
+You are given two integer arrays position and speed, both of length n, where position[i] is the starting mile of the ith car and speed[i] is the speed of the ith car in miles per hour.
A car cannot pass another car, but it can catch up and then travel next to it at the speed of the slower car.
diff --git a/solution/0800-0899/0854.K-Similar Strings/README.md b/solution/0800-0899/0854.K-Similar Strings/README.md
index 901f3eddf2b6e..8c3b0849eb9e6 100644
--- a/solution/0800-0899/0854.K-Similar Strings/README.md
+++ b/solution/0800-0899/0854.K-Similar Strings/README.md
@@ -4,6 +4,7 @@ difficulty: 困难
edit_url: https://github.com/doocs/leetcode/edit/main/solution/0800-0899/0854.K-Similar%20Strings/README.md
tags:
- 广度优先搜索
+ - 哈希表
- 字符串
---
diff --git a/solution/0800-0899/0854.K-Similar Strings/README_EN.md b/solution/0800-0899/0854.K-Similar Strings/README_EN.md
index 793ae5c5199ba..e900f8a5eccd5 100644
--- a/solution/0800-0899/0854.K-Similar Strings/README_EN.md
+++ b/solution/0800-0899/0854.K-Similar Strings/README_EN.md
@@ -4,6 +4,7 @@ difficulty: Hard
edit_url: https://github.com/doocs/leetcode/edit/main/solution/0800-0899/0854.K-Similar%20Strings/README_EN.md
tags:
- Breadth-First Search
+ - Hash Table
- String
---
diff --git a/solution/0800-0899/0869.Reordered Power of 2/README.md b/solution/0800-0899/0869.Reordered Power of 2/README.md
index 7f95d385979ca..2910c92032ee1 100644
--- a/solution/0800-0899/0869.Reordered Power of 2/README.md
+++ b/solution/0800-0899/0869.Reordered Power of 2/README.md
@@ -57,7 +57,15 @@ tags:
-### 方法一
+### 方法一：枚举
+
+我们可以在 $[1, 10^9]$ 的范围内枚举所有的 $2$ 的幂，判断它们的数字组成是否与给定的数字相同。
+
+定义一个函数 $f(x)$，表示数字 $x$ 的数字组成。我们可以将数字 $x$ 转换为一个长度为 $10$ 的数组，或者一个按数字大小排序的字符串。
+
+首先，我们计算给定数字 $n$ 的数字组成 $\text{target} = f(n)$。然后，我们枚举 $i$ 从 1 开始，每次将 $i$ 左移一位（相当于乘以 $2$），直到 $i$ 超过 $10^9$。对于每个 $i$，我们计算它的数字组成，并与 $\text{target}$ 进行比较。如果相同，则返回 $\text{true}$；如果枚举结束仍未找到相同的数字组成，则返回 $\text{false}$。
+
+时间复杂度 $O(\log^2 M)$，空间复杂度 $O(\log M)$。其中 $M$ 是本题的输入范围上限 ${10}^9$。
@@ -66,16 +74,17 @@ tags:
```python
class Solution:
def reorderedPowerOf2(self, n: int) -> bool:
- def convert(n):
+ def f(x: int) -> List[int]:
cnt = [0] * 10
- while n:
- n, v = divmod(n, 10)
+ while x:
+ x, v = divmod(x, 10)
cnt[v] += 1
return cnt
- i, s = 1, convert(n)
+ target = f(n)
+ i = 1
while i <= 10**9:
- if convert(i) == s:
+ if f(i) == target:
return True
i <<= 1
return False
@@ -86,19 +95,19 @@ class Solution:
```java
class Solution {
public boolean reorderedPowerOf2(int n) {
- String s = convert(n);
- for (int i = 1; i <= Math.pow(10, 9); i <<= 1) {
- if (s.equals(convert(i))) {
+ String target = f(n);
+ for (int i = 1; i <= 1000000000; i <<= 1) {
+ if (target.equals(f(i))) {
return true;
}
}
return false;
}
- private String convert(int n) {
+ private String f(int x) {
char[] cnt = new char[10];
- for (; n > 0; n /= 10) {
- cnt[n % 10]++;
+ for (; x > 0; x /= 10) {
+ cnt[x % 10]++;
}
return new String(cnt);
}
@@ -111,17 +120,23 @@ class Solution {
class Solution {
public:
bool reorderedPowerOf2(int n) {
- vector s = convert(n);
- for (int i = 1; i <= pow(10, 9); i <<= 1)
- if (s == convert(i))
+ string target = f(n);
+ for (int i = 1; i <= 1000000000; i <<= 1) {
+ if (target == f(i)) {
return true;
+ }
+ }
return false;
}
- vector convert(int n) {
- vector cnt(10);
- for (; n; n /= 10) ++cnt[n % 10];
- return cnt;
+private:
+ string f(int x) {
+ char cnt[10] = {};
+ while (x > 0) {
+ cnt[x % 10]++;
+ x /= 10;
+ }
+ return string(cnt, cnt + 10);
}
};
```
@@ -130,21 +145,72 @@ public:
```go
func reorderedPowerOf2(n int) bool {
- convert := func(n int) []byte {
- cnt := make([]byte, 10)
- for ; n > 0; n /= 10 {
- cnt[n%10]++
- }
- return cnt
- }
- s := convert(n)
- for i := 1; i <= 1e9; i <<= 1 {
- if bytes.Equal(s, convert(i)) {
+ target := f(n)
+ for i := 1; i <= 1000000000; i <<= 1 {
+ if bytes.Equal(target, f(i)) {
return true
}
}
return false
}
+
+func f(x int) []byte {
+ cnt := make([]byte, 10)
+ for x > 0 {
+ cnt[x%10]++
+ x /= 10
+ }
+ return cnt
+}
+```
+
+#### TypeScript
+
+```ts
+function reorderedPowerOf2(n: number): boolean {
+ const f = (x: number) => {
+ const cnt = Array(10).fill(0);
+ while (x > 0) {
+ cnt[x % 10]++;
+ x = (x / 10) | 0;
+ }
+ return cnt.join(',');
+ };
+ const target = f(n);
+ for (let i = 1; i <= 1_000_000_000; i <<= 1) {
+ if (target === f(i)) {
+ return true;
+ }
+ }
+ return false;
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+ pub fn reordered_power_of2(n: i32) -> bool {
+ fn f(mut x: i32) -> [u8; 10] {
+ let mut cnt = [0u8; 10];
+ while x > 0 {
+ cnt[(x % 10) as usize] += 1;
+ x /= 10;
+ }
+ cnt
+ }
+
+ let target = f(n);
+ let mut i = 1i32;
+ while i <= 1_000_000_000 {
+ if target == f(i) {
+ return true;
+ }
+ i <<= 1;
+ }
+ false
+ }
+}
```
diff --git a/solution/0800-0899/0869.Reordered Power of 2/README_EN.md b/solution/0800-0899/0869.Reordered Power of 2/README_EN.md
index eff1dc9954caf..495526d02fc3d 100644
--- a/solution/0800-0899/0869.Reordered Power of 2/README_EN.md
+++ b/solution/0800-0899/0869.Reordered Power of 2/README_EN.md
@@ -52,7 +52,15 @@ tags:
-### Solution 1
+### Solution 1: Enumeration
+
+We can enumerate all powers of 2 in the range $[1, 10^9]$ and check if their digit composition is the same as the given number.
+
+Define a function $f(x)$ that represents the digit composition of number $x$. We can convert the number $x$ into an array of length 10, or a string sorted by digit size.
+
+First, we calculate the digit composition of the given number $n$ as $\text{target} = f(n)$. Then, we enumerate $i$ starting from 1, shifting $i$ left by one bit each time (equivalent to multiplying by 2), until $i$ exceeds $10^9$. For each $i$, we calculate its digit composition and compare it with $\text{target}$. If they are the same, we return $\text{true}$; if the enumeration ends without finding the same digit composition, we return $\text{false}$.
+
+Time complexity $O(\log^2 M)$, space complexity $O(\log M)$. Where $M$ is the upper limit of the input range ${10}^9$ for this problem.
@@ -61,16 +69,17 @@ tags:
```python
class Solution:
def reorderedPowerOf2(self, n: int) -> bool:
- def convert(n):
+ def f(x: int) -> List[int]:
cnt = [0] * 10
- while n:
- n, v = divmod(n, 10)
+ while x:
+ x, v = divmod(x, 10)
cnt[v] += 1
return cnt
- i, s = 1, convert(n)
+ target = f(n)
+ i = 1
while i <= 10**9:
- if convert(i) == s:
+ if f(i) == target:
return True
i <<= 1
return False
@@ -81,19 +90,19 @@ class Solution:
```java
class Solution {
public boolean reorderedPowerOf2(int n) {
- String s = convert(n);
- for (int i = 1; i <= Math.pow(10, 9); i <<= 1) {
- if (s.equals(convert(i))) {
+ String target = f(n);
+ for (int i = 1; i <= 1000000000; i <<= 1) {
+ if (target.equals(f(i))) {
return true;
}
}
return false;
}
- private String convert(int n) {
+ private String f(int x) {
char[] cnt = new char[10];
- for (; n > 0; n /= 10) {
- cnt[n % 10]++;
+ for (; x > 0; x /= 10) {
+ cnt[x % 10]++;
}
return new String(cnt);
}
@@ -106,17 +115,23 @@ class Solution {
class Solution {
public:
bool reorderedPowerOf2(int n) {
- vector s = convert(n);
- for (int i = 1; i <= pow(10, 9); i <<= 1)
- if (s == convert(i))
+ string target = f(n);
+ for (int i = 1; i <= 1000000000; i <<= 1) {
+ if (target == f(i)) {
return true;
+ }
+ }
return false;
}
- vector convert(int n) {
- vector cnt(10);
- for (; n; n /= 10) ++cnt[n % 10];
- return cnt;
+private:
+ string f(int x) {
+ char cnt[10] = {};
+ while (x > 0) {
+ cnt[x % 10]++;
+ x /= 10;
+ }
+ return string(cnt, cnt + 10);
}
};
```
@@ -125,21 +140,72 @@ public:
```go
func reorderedPowerOf2(n int) bool {
- convert := func(n int) []byte {
- cnt := make([]byte, 10)
- for ; n > 0; n /= 10 {
- cnt[n%10]++
- }
- return cnt
- }
- s := convert(n)
- for i := 1; i <= 1e9; i <<= 1 {
- if bytes.Equal(s, convert(i)) {
+ target := f(n)
+ for i := 1; i <= 1000000000; i <<= 1 {
+ if bytes.Equal(target, f(i)) {
return true
}
}
return false
}
+
+func f(x int) []byte {
+ cnt := make([]byte, 10)
+ for x > 0 {
+ cnt[x%10]++
+ x /= 10
+ }
+ return cnt
+}
+```
+
+#### TypeScript
+
+```ts
+function reorderedPowerOf2(n: number): boolean {
+ const f = (x: number) => {
+ const cnt = Array(10).fill(0);
+ while (x > 0) {
+ cnt[x % 10]++;
+ x = (x / 10) | 0;
+ }
+ return cnt.join(',');
+ };
+ const target = f(n);
+ for (let i = 1; i <= 1_000_000_000; i <<= 1) {
+ if (target === f(i)) {
+ return true;
+ }
+ }
+ return false;
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+ pub fn reordered_power_of2(n: i32) -> bool {
+ fn f(mut x: i32) -> [u8; 10] {
+ let mut cnt = [0u8; 10];
+ while x > 0 {
+ cnt[(x % 10) as usize] += 1;
+ x /= 10;
+ }
+ cnt
+ }
+
+ let target = f(n);
+ let mut i = 1i32;
+ while i <= 1_000_000_000 {
+ if target == f(i) {
+ return true;
+ }
+ i <<= 1;
+ }
+ false
+ }
+}
```
diff --git a/solution/0800-0899/0869.Reordered Power of 2/Solution.cpp b/solution/0800-0899/0869.Reordered Power of 2/Solution.cpp
index daf92bd09b81a..16afc0f6585b4 100644
--- a/solution/0800-0899/0869.Reordered Power of 2/Solution.cpp
+++ b/solution/0800-0899/0869.Reordered Power of 2/Solution.cpp
@@ -1,16 +1,22 @@
class Solution {
public:
bool reorderedPowerOf2(int n) {
- vector s = convert(n);
- for (int i = 1; i <= pow(10, 9); i <<= 1)
- if (s == convert(i))
+ string target = f(n);
+ for (int i = 1; i <= 1000000000; i <<= 1) {
+ if (target == f(i)) {
return true;
+ }
+ }
return false;
}
- vector convert(int n) {
- vector cnt(10);
- for (; n; n /= 10) ++cnt[n % 10];
- return cnt;
+private:
+ string f(int x) {
+ char cnt[10] = {};
+ while (x > 0) {
+ cnt[x % 10]++;
+ x /= 10;
+ }
+ return string(cnt, cnt + 10);
}
-};
\ No newline at end of file
+};
diff --git a/solution/0800-0899/0869.Reordered Power of 2/Solution.go b/solution/0800-0899/0869.Reordered Power of 2/Solution.go
index 2b00c643d657d..5eef3f76a0c03 100644
--- a/solution/0800-0899/0869.Reordered Power of 2/Solution.go
+++ b/solution/0800-0899/0869.Reordered Power of 2/Solution.go
@@ -1,16 +1,18 @@
func reorderedPowerOf2(n int) bool {
- convert := func(n int) []byte {
- cnt := make([]byte, 10)
- for ; n > 0; n /= 10 {
- cnt[n%10]++
- }
- return cnt
- }
- s := convert(n)
- for i := 1; i <= 1e9; i <<= 1 {
- if bytes.Equal(s, convert(i)) {
+ target := f(n)
+ for i := 1; i <= 1000000000; i <<= 1 {
+ if bytes.Equal(target, f(i)) {
return true
}
}
return false
-}
\ No newline at end of file
+}
+
+func f(x int) []byte {
+ cnt := make([]byte, 10)
+ for x > 0 {
+ cnt[x%10]++
+ x /= 10
+ }
+ return cnt
+}
diff --git a/solution/0800-0899/0869.Reordered Power of 2/Solution.java b/solution/0800-0899/0869.Reordered Power of 2/Solution.java
index 6ff2991def5e9..bc4c8b8de5623 100644
--- a/solution/0800-0899/0869.Reordered Power of 2/Solution.java
+++ b/solution/0800-0899/0869.Reordered Power of 2/Solution.java
@@ -1,19 +1,19 @@
class Solution {
public boolean reorderedPowerOf2(int n) {
- String s = convert(n);
- for (int i = 1; i <= Math.pow(10, 9); i <<= 1) {
- if (s.equals(convert(i))) {
+ String target = f(n);
+ for (int i = 1; i <= 1000000000; i <<= 1) {
+ if (target.equals(f(i))) {
return true;
}
}
return false;
}
- private String convert(int n) {
+ private String f(int x) {
char[] cnt = new char[10];
- for (; n > 0; n /= 10) {
- cnt[n % 10]++;
+ for (; x > 0; x /= 10) {
+ cnt[x % 10]++;
}
return new String(cnt);
}
-}
\ No newline at end of file
+}
diff --git a/solution/0800-0899/0869.Reordered Power of 2/Solution.py b/solution/0800-0899/0869.Reordered Power of 2/Solution.py
index ac6992019a283..e954d484b6dc0 100644
--- a/solution/0800-0899/0869.Reordered Power of 2/Solution.py
+++ b/solution/0800-0899/0869.Reordered Power of 2/Solution.py
@@ -1,15 +1,16 @@
class Solution:
def reorderedPowerOf2(self, n: int) -> bool:
- def convert(n):
+ def f(x: int) -> List[int]:
cnt = [0] * 10
- while n:
- n, v = divmod(n, 10)
+ while x:
+ x, v = divmod(x, 10)
cnt[v] += 1
return cnt
- i, s = 1, convert(n)
+ target = f(n)
+ i = 1
while i <= 10**9:
- if convert(i) == s:
+ if f(i) == target:
return True
i <<= 1
return False
diff --git a/solution/0800-0899/0869.Reordered Power of 2/Solution.rs b/solution/0800-0899/0869.Reordered Power of 2/Solution.rs
new file mode 100644
index 0000000000000..7c25a2e39ba27
--- /dev/null
+++ b/solution/0800-0899/0869.Reordered Power of 2/Solution.rs
@@ -0,0 +1,22 @@
+impl Solution {
+ pub fn reordered_power_of2(n: i32) -> bool {
+ fn f(mut x: i32) -> [u8; 10] {
+ let mut cnt = [0u8; 10];
+ while x > 0 {
+ cnt[(x % 10) as usize] += 1;
+ x /= 10;
+ }
+ cnt
+ }
+
+ let target = f(n);
+ let mut i = 1i32;
+ while i <= 1_000_000_000 {
+ if target == f(i) {
+ return true;
+ }
+ i <<= 1;
+ }
+ false
+ }
+}
diff --git a/solution/0800-0899/0869.Reordered Power of 2/Solution.ts b/solution/0800-0899/0869.Reordered Power of 2/Solution.ts
new file mode 100644
index 0000000000000..b1085b547408b
--- /dev/null
+++ b/solution/0800-0899/0869.Reordered Power of 2/Solution.ts
@@ -0,0 +1,17 @@
+function reorderedPowerOf2(n: number): boolean {
+ const f = (x: number) => {
+ const cnt = Array(10).fill(0);
+ while (x > 0) {
+ cnt[x % 10]++;
+ x = (x / 10) | 0;
+ }
+ return cnt.join(',');
+ };
+ const target = f(n);
+ for (let i = 1; i <= 1_000_000_000; i <<= 1) {
+ if (target === f(i)) {
+ return true;
+ }
+ }
+ return false;
+}
diff --git a/solution/0800-0899/0871.Minimum Number of Refueling Stops/README.md b/solution/0800-0899/0871.Minimum Number of Refueling Stops/README.md
index 43c01e207b7c6..e1e44eb2e0170 100644
--- a/solution/0800-0899/0871.Minimum Number of Refueling Stops/README.md
+++ b/solution/0800-0899/0871.Minimum Number of Refueling Stops/README.md
@@ -206,14 +206,14 @@ func (h *hp) Pop() any {
```ts
function minRefuelStops(target: number, startFuel: number, stations: number[][]): number {
- const pq = new MaxPriorityQueue();
+ const pq = new MaxPriorityQueue();
let [ans, pre] = [0, 0];
stations.push([target, 0]);
for (const [pos, fuel] of stations) {
const dist = pos - pre;
startFuel -= dist;
while (startFuel < 0 && !pq.isEmpty()) {
- startFuel += pq.dequeue().element;
+ startFuel += pq.dequeue();
ans++;
}
if (startFuel < 0) {
diff --git a/solution/0800-0899/0871.Minimum Number of Refueling Stops/README_EN.md b/solution/0800-0899/0871.Minimum Number of Refueling Stops/README_EN.md
index 630e93b48caff..178656648518c 100644
--- a/solution/0800-0899/0871.Minimum Number of Refueling Stops/README_EN.md
+++ b/solution/0800-0899/0871.Minimum Number of Refueling Stops/README_EN.md
@@ -203,14 +203,14 @@ func (h *hp) Pop() any {
```ts
function minRefuelStops(target: number, startFuel: number, stations: number[][]): number {
- const pq = new MaxPriorityQueue();
+ const pq = new MaxPriorityQueue();
let [ans, pre] = [0, 0];
stations.push([target, 0]);
for (const [pos, fuel] of stations) {
const dist = pos - pre;
startFuel -= dist;
while (startFuel < 0 && !pq.isEmpty()) {
- startFuel += pq.dequeue().element;
+ startFuel += pq.dequeue();
ans++;
}
if (startFuel < 0) {
diff --git a/solution/0800-0899/0871.Minimum Number of Refueling Stops/Solution.ts b/solution/0800-0899/0871.Minimum Number of Refueling Stops/Solution.ts
index e4a782ed55c25..0ecdf32837785 100644
--- a/solution/0800-0899/0871.Minimum Number of Refueling Stops/Solution.ts
+++ b/solution/0800-0899/0871.Minimum Number of Refueling Stops/Solution.ts
@@ -1,12 +1,12 @@
function minRefuelStops(target: number, startFuel: number, stations: number[][]): number {
- const pq = new MaxPriorityQueue();
+ const pq = new MaxPriorityQueue();
let [ans, pre] = [0, 0];
stations.push([target, 0]);
for (const [pos, fuel] of stations) {
const dist = pos - pre;
startFuel -= dist;
while (startFuel < 0 && !pq.isEmpty()) {
- startFuel += pq.dequeue().element;
+ startFuel += pq.dequeue();
ans++;
}
if (startFuel < 0) {
diff --git a/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/README.md b/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/README.md
index 4a4ddd95f3f1f..6944d36dfbcfc 100644
--- a/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/README.md
+++ b/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/README.md
@@ -18,7 +18,7 @@ tags:
-如果序列 x1, x2, ..., x2 满足下列条件，就说它是 斐波那契式 的：
+如果序列 x1, x2, ..., xn 满足下列条件，就说它是 斐波那契式 的：
n >= 3在 n x n 的网格 grid 中，我们放置了一些与 x，y，z 三轴对齐的 1 x 1 x 1 立方体。
-每个值 v = grid[i][j] 表示 v 个正方体叠放在单元格 (i, j) 上。
+每个值 v = grid[i][j] 表示有一列 v 个正方体叠放在格子 (i, j) 上。
现在，我们查看这些立方体在 xy 、yz 和 zx 平面上的投影。
diff --git a/solution/0900-0999/0904.Fruit Into Baskets/README.md b/solution/0900-0999/0904.Fruit Into Baskets/README.md
index c8581b12fc7b1..3506ccc0ff7d7 100644
--- a/solution/0900-0999/0904.Fruit Into Baskets/README.md
+++ b/solution/0900-0999/0904.Fruit Into Baskets/README.md
@@ -83,9 +83,9 @@ tags:
### 方法一：哈希表 + 滑动窗口
-我们用哈希表 $cnt$ 维护当前窗口内的水果种类以及对应的数量，用双指针 $j$ 和 $i$ 维护窗口的左右边界。
+我们用哈希表 $\textit{cnt}$ 维护当前窗口内的水果种类以及对应的数量，用双指针 $j$ 和 $i$ 维护窗口的左右边界。
-遍历数组 `fruits`，将当前水果 $x$ 加入窗口，即 $cnt[x]++$，然后判断当前窗口内的水果种类是否超过了 $2$ 种，如果超过了 $2$ 种，就需要将窗口的左边界 $j$ 右移，直到窗口内的水果种类不超过 $2$ 种为止。然后更新答案，即 $ans = \max(ans, i - j + 1)$。
+遍历数组 $\textit{fruits}$，将当前水果 $x$ 加入窗口，即 $\textit{cnt}[x]++$，然后判断当前窗口内的水果种类是否超过了 $2$ 种，如果超过了 $2$ 种，就需要将窗口的左边界 $j$ 右移，直到窗口内的水果种类不超过 $2$ 种为止。然后更新答案，即 $\textit{ans} = \max(\textit{ans}, i - j + 1)$。
遍历结束后，即可得到最终的答案。
@@ -105,7 +105,7 @@ j i
j i
```
-时间复杂度 $O(n)$，其中 $n$ 为数组 `fruits` 的长度。空间复杂度 $O(1)$。
+时间复杂度 $O(n)$，其中 $n$ 为数组 $\textit{fruits}$ 的长度。空间复杂度 $O(1)$，因为哈希表 $\textit{cnt}$ 中的键值对数量最多为 $2$。
@@ -248,19 +248,49 @@ impl Solution {
}
```
+#### C#
+
+```cs
+public class Solution {
+ public int TotalFruit(int[] fruits) {
+ var cnt = new Dictionary();
+ int ans = 0;
+ for (int i = 0, j = 0; i < fruits.Length; ++i) {
+ int x = fruits[i];
+ if (cnt.ContainsKey(x)) {
+ cnt[x]++;
+ } else {
+ cnt[x] = 1;
+ }
+ while (cnt.Count > 2) {
+ int y = fruits[j++];
+ if (cnt.ContainsKey(y)) {
+ cnt[y]--;
+ if (cnt[y] == 0) {
+ cnt.Remove(y);
+ }
+ }
+ }
+ ans = Math.Max(ans, i - j + 1);
+ }
+ return ans;
+ }
+}
+```
+
-### 方法二：滑动窗口优化
+### 方法二：单调变长滑动窗口
在方法一中，我们发现，窗口大小会时而变大，时而变小，这就需要我们每一次更新答案。
但本题实际上求的是水果的最大数目，也就是“最大”的窗口，我们没有必要缩小窗口，只需要让窗口单调增大。于是代码就少了每次更新答案的操作，只需要在遍历结束后将此时的窗口大小作为答案返回即可。
-时间复杂度 $O(n)$，其中 $n$ 为数组 `fruits` 的长度。空间复杂度 $O(1)$。
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $\textit{fruits}$ 的长度。
@@ -395,6 +425,35 @@ impl Solution {
}
```
+#### C#
+
+```cs
+public class Solution {
+ public int TotalFruit(int[] fruits) {
+ var cnt = new Dictionary();
+ int j = 0, n = fruits.Length;
+ foreach (int x in fruits) {
+ if (cnt.ContainsKey(x)) {
+ cnt[x]++;
+ } else {
+ cnt[x] = 1;
+ }
+
+ if (cnt.Count > 2) {
+ int y = fruits[j++];
+ if (cnt.ContainsKey(y)) {
+ cnt[y]--;
+ if (cnt[y] == 0) {
+ cnt.Remove(y);
+ }
+ }
+ }
+ }
+ return n - j;
+ }
+}
+```
+
diff --git a/solution/0900-0999/0904.Fruit Into Baskets/README_EN.md b/solution/0900-0999/0904.Fruit Into Baskets/README_EN.md
index 5763c9610dc03..640aeeff53462 100644
--- a/solution/0900-0999/0904.Fruit Into Baskets/README_EN.md
+++ b/solution/0900-0999/0904.Fruit Into Baskets/README_EN.md
@@ -75,7 +75,7 @@ If we had started at the first tree, we would only pick from trees [1,2].
We use a hash table $cnt$ to maintain the types and corresponding quantities of fruits in the current window, and use two pointers $j$ and $i$ to maintain the left and right boundaries of the window.
-We traverse the `fruits` array, add the current fruit $x$ to the window, i.e., $cnt[x]++$, then judge whether the types of fruits in the current window exceed $2$. If it exceeds $2$, we need to move the left boundary $j$ of the window to the right until the types of fruits in the window do not exceed $2$. Then we update the answer, i.e., $ans = \max(ans, i - j + 1)$.
+We traverse the $\textit{fruits}$ array, add the current fruit $x$ to the window, i.e., $cnt[x]++$, then judge whether the types of fruits in the current window exceed $2$. If it exceeds $2$, we need to move the left boundary $j$ of the window to the right until the types of fruits in the window do not exceed $2$. Then we update the answer, i.e., $ans = \max(ans, i - j + 1)$.
After the traversal ends, we can get the final answer.
@@ -95,7 +95,7 @@ j i
j i
```
-The time complexity is $O(n)$, and the space complexity is $O(1)$. Here, $n$ is the length of the `fruits` array.
+The time complexity is $O(n)$, and the space complexity is $O(1)$. Here, $n$ is the length of the $\textit{fruits}$ array.
@@ -238,19 +238,49 @@ impl Solution {
}
```
+#### C#
+
+```cs
+public class Solution {
+ public int TotalFruit(int[] fruits) {
+ var cnt = new Dictionary();
+ int ans = 0;
+ for (int i = 0, j = 0; i < fruits.Length; ++i) {
+ int x = fruits[i];
+ if (cnt.ContainsKey(x)) {
+ cnt[x]++;
+ } else {
+ cnt[x] = 1;
+ }
+ while (cnt.Count > 2) {
+ int y = fruits[j++];
+ if (cnt.ContainsKey(y)) {
+ cnt[y]--;
+ if (cnt[y] == 0) {
+ cnt.Remove(y);
+ }
+ }
+ }
+ ans = Math.Max(ans, i - j + 1);
+ }
+ return ans;
+ }
+}
+```
+
-### Solution 2: Sliding Window Optimization
+### Solution 2: Monotonic Variable-Length Sliding Window
In Solution 1, we find that the window size sometimes increases and sometimes decreases, which requires us to update the answer each time.
But what this problem actually asks for is the maximum number of fruits, that is, the "largest" window. We don't need to shrink the window, we just need to let the window monotonically increase. So the code omits the operation of updating the answer each time, and only needs to return the size of the window as the answer after the traversal ends.
-The time complexity is $O(n)$, and the space complexity is $O(1)$. Here, $n$ is the length of the `fruits` array.
+The time complexity is $O(n)$, and the space complexity is $O(n)$, where $n$ is the length of the $\textit{fruits}$ array.
@@ -385,6 +415,35 @@ impl Solution {
}
```
+#### C#
+
+```cs
+public class Solution {
+ public int TotalFruit(int[] fruits) {
+ var cnt = new Dictionary();
+ int j = 0, n = fruits.Length;
+ foreach (int x in fruits) {
+ if (cnt.ContainsKey(x)) {
+ cnt[x]++;
+ } else {
+ cnt[x] = 1;
+ }
+
+ if (cnt.Count > 2) {
+ int y = fruits[j++];
+ if (cnt.ContainsKey(y)) {
+ cnt[y]--;
+ if (cnt[y] == 0) {
+ cnt.Remove(y);
+ }
+ }
+ }
+ }
+ return n - j;
+ }
+}
+```
+
diff --git a/solution/0900-0999/0904.Fruit Into Baskets/Solution.cs b/solution/0900-0999/0904.Fruit Into Baskets/Solution.cs
new file mode 100644
index 0000000000000..65977f7ae5e91
--- /dev/null
+++ b/solution/0900-0999/0904.Fruit Into Baskets/Solution.cs
@@ -0,0 +1,25 @@
+public class Solution {
+ public int TotalFruit(int[] fruits) {
+ var cnt = new Dictionary();
+ int ans = 0;
+ for (int i = 0, j = 0; i < fruits.Length; ++i) {
+ int x = fruits[i];
+ if (cnt.ContainsKey(x)) {
+ cnt[x]++;
+ } else {
+ cnt[x] = 1;
+ }
+ while (cnt.Count > 2) {
+ int y = fruits[j++];
+ if (cnt.ContainsKey(y)) {
+ cnt[y]--;
+ if (cnt[y] == 0) {
+ cnt.Remove(y);
+ }
+ }
+ }
+ ans = Math.Max(ans, i - j + 1);
+ }
+ return ans;
+ }
+}
diff --git a/solution/0900-0999/0904.Fruit Into Baskets/Solution2.cs b/solution/0900-0999/0904.Fruit Into Baskets/Solution2.cs
new file mode 100644
index 0000000000000..de08b22a3be2c
--- /dev/null
+++ b/solution/0900-0999/0904.Fruit Into Baskets/Solution2.cs
@@ -0,0 +1,24 @@
+public class Solution {
+ public int TotalFruit(int[] fruits) {
+ var cnt = new Dictionary();
+ int j = 0, n = fruits.Length;
+ foreach (int x in fruits) {
+ if (cnt.ContainsKey(x)) {
+ cnt[x]++;
+ } else {
+ cnt[x] = 1;
+ }
+
+ if (cnt.Count > 2) {
+ int y = fruits[j++];
+ if (cnt.ContainsKey(y)) {
+ cnt[y]--;
+ if (cnt[y] == 0) {
+ cnt.Remove(y);
+ }
+ }
+ }
+ }
+ return n - j;
+ }
+}
diff --git a/solution/0900-0999/0939.Minimum Area Rectangle/README.md b/solution/0900-0999/0939.Minimum Area Rectangle/README.md
index 7a98ebe927790..7925013d4fd67 100644
--- a/solution/0900-0999/0939.Minimum Area Rectangle/README.md
+++ b/solution/0900-0999/0939.Minimum Area Rectangle/README.md
@@ -20,34 +20,36 @@ tags:
-给定在 xy 平面上的一组点，确定由这些点组成的矩形的最小面积，其中矩形的边平行于 x 轴和 y 轴。
+给你一个 X-Y 平面上的点数组 points，其中 points[i] = [xi, yi]。
-如果没有任何矩形，就返回 0。
+返回由这些点形成的矩形的最小面积，矩形的边与 X 轴和 Y 轴平行。如果不存在这样的矩形，则返回 0。
-示例 1：
-
-输入：[[1,1],[1,3],[3,1],[3,3],[2,2]]
-输出：4
+示例 1：
+
+
+输入： points = [[1,1],[1,3],[3,1],[3,3],[2,2]]
+输出： 4
-示例 2：
-
-输入：[[1,1],[1,3],[3,1],[3,3],[4,1],[4,3]]
-输出：2
+示例 2：
+
+
+输入： points = [[1,1],[1,3],[3,1],[3,3],[4,1],[4,3]]
+输出： 2
提示：
-
+
1 <= points.length <= 5000 <= points[i][0] <= 400000 <= points[i][1] <= 40000- 所有的点都是不同的。
-
+
points[i].length == 20 <= xi, yi <= 4 * 104- 所有给定的点都是 唯一 的。
+
diff --git a/solution/0900-0999/0951.Flip Equivalent Binary Trees/README.md b/solution/0900-0999/0951.Flip Equivalent Binary Trees/README.md
index de294a24867bc..e59d54b3534ce 100644
--- a/solution/0900-0999/0951.Flip Equivalent Binary Trees/README.md
+++ b/solution/0900-0999/0951.Flip Equivalent Binary Trees/README.md
@@ -22,7 +22,7 @@ tags:
只要经过一定次数的翻转操作后，能使 X 等于 Y，我们就称二叉树 X 翻转 等价 于二叉树 Y。
-这些树由根节点 root1 和 root2 给出。如果两个二叉树是否是翻转 等价 的函数，则返回 true ，否则返回 false 。
+这些树由根节点 root1 和 root2 给出。如果两个二叉树是否是翻转 等价 的树，则返回 true ，否则返回 false 。
diff --git a/solution/0900-0999/0963.Minimum Area Rectangle II/README.md b/solution/0900-0999/0963.Minimum Area Rectangle II/README.md
index 4f23117a1fb07..95985de7da993 100644
--- a/solution/0900-0999/0963.Minimum Area Rectangle II/README.md
+++ b/solution/0900-0999/0963.Minimum Area Rectangle II/README.md
@@ -5,6 +5,7 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/0900-0999/0963.Mi
tags:
- 几何
- 数组
+ - 哈希表
- 数学
---
@@ -18,58 +19,48 @@ tags:
-给定在 xy 平面上的一组点，确定由这些点组成的任何矩形的最小面积，其中矩形的边不一定平行于 x 轴和 y 轴。
+给你一个 X-Y 平面上的点数组 points，其中 points[i] = [xi, yi]。
-如果没有任何矩形，就返回 0。
+返回由这些点形成的任意矩形的最小面积，矩形的边 不一定 平行于 X 轴和 Y 轴。如果不存在这样的矩形，则返回 0。
-
-
-示例 1：
-
-
-
-输入：[[1,2],[2,1],[1,0],[0,1]]
-输出：2.00000
-解释：最小面积的矩形出现在 [1,2],[2,1],[1,0],[0,1] 处，面积为 2。
-
-示例 2：
+答案只需在10-5 的误差范围内即可被视作正确答案。
-
+
-输入：[[0,1],[2,1],[1,1],[1,0],[2,0]]
-输出：1.00000
-解释：最小面积的矩形出现在 [1,0],[1,1],[2,1],[2,0] 处，面积为 1。
+示例 1：
+
+
+输入： points = [[1,2],[2,1],[1,0],[0,1]]
+输出： 2.00000
+解释： 最小面积矩形由 [1,2]、[2,1]、[1,0]、[0,1] 组成，其面积为 2。
-示例 3：
-
-
-
-输入：[[0,3],[1,2],[3,1],[1,3],[2,1]]
-输出：0
-解释：没法从这些点中组成任何矩形。
+示例 2：
+
+
+输入： points = [[0,1],[2,1],[1,1],[1,0],[2,0]]
+输出： 1.00000
+解释： 最小面积矩形由 [1,0]、[1,1]、[2,1]、[2,0] 组成，其面积为 1。
-示例 4：
-
-
-
-输入：[[3,1],[1,1],[0,1],[2,1],[3,3],[3,2],[0,2],[2,3]]
-输出：2.00000
-解释：最小面积的矩形出现在 [2,1],[2,3],[3,3],[3,1] 处，面积为 2。
+示例 3：
+
+
+输入： points = [[0,3],[1,2],[3,1],[1,3],[2,1]]
+输出： 0
+解释： 无法由这些点组成任何矩形。
提示：
-
+
1 <= points.length <= 500 <= points[i][0] <= 400000 <= points[i][1] <= 40000- 所有的点都是不同的。
- - 与真实值误差不超过
10^-5 的答案将视为正确结果。
-
+
points[i].length == 2
+ 0 <= xi, yi <= 4 * 104
+ 所有给定的点都是 唯一 的。
+
diff --git a/solution/0900-0999/0963.Minimum Area Rectangle II/README_EN.md b/solution/0900-0999/0963.Minimum Area Rectangle II/README_EN.md
index 7b5cf232735b0..ddcb75d6ec6bb 100644
--- a/solution/0900-0999/0963.Minimum Area Rectangle II/README_EN.md
+++ b/solution/0900-0999/0963.Minimum Area Rectangle II/README_EN.md
@@ -5,6 +5,7 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/0900-0999/0963.Mi
tags:
- Geometry
- Array
+ - Hash Table
- Math
---
diff --git a/solution/0900-0999/0963.Minimum Area Rectangle II/images/4c.png b/solution/0900-0999/0963.Minimum Area Rectangle II/images/4c.png
deleted file mode 100644
index 5c35a6c388000..0000000000000
Binary files a/solution/0900-0999/0963.Minimum Area Rectangle II/images/4c.png and /dev/null differ
diff --git a/solution/0900-0999/0973.K Closest Points to Origin/README.md b/solution/0900-0999/0973.K Closest Points to Origin/README.md
index c2619b2a8acc1..b11686cc6a7ac 100644
--- a/solution/0900-0999/0973.K Closest Points to Origin/README.md
+++ b/solution/0900-0999/0973.K Closest Points to Origin/README.md
@@ -259,15 +259,15 @@ func (h *hp) Pop() any { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1]; retur
```ts
function kClosest(points: number[][], k: number): number[][] {
- const maxQ = new MaxPriorityQueue();
+ const maxQ = new MaxPriorityQueue<{ point: number[]; dist: number }>(entry => entry.dist);
for (const [x, y] of points) {
const dist = x * x + y * y;
- maxQ.enqueue([x, y], dist);
+ maxQ.enqueue({ point: [x, y], dist });
if (maxQ.size() > k) {
maxQ.dequeue();
}
}
- return maxQ.toArray().map(item => item.element);
+ return maxQ.toArray().map(entry => entry.point);
}
```
diff --git a/solution/0900-0999/0973.K Closest Points to Origin/README_EN.md b/solution/0900-0999/0973.K Closest Points to Origin/README_EN.md
index 5a6704413aee5..2335041d3f46c 100644
--- a/solution/0900-0999/0973.K Closest Points to Origin/README_EN.md
+++ b/solution/0900-0999/0973.K Closest Points to Origin/README_EN.md
@@ -255,15 +255,15 @@ func (h *hp) Pop() any { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1]; retur
```ts
function kClosest(points: number[][], k: number): number[][] {
- const maxQ = new MaxPriorityQueue();
+ const maxQ = new MaxPriorityQueue<{ point: number[]; dist: number }>(entry => entry.dist);
for (const [x, y] of points) {
const dist = x * x + y * y;
- maxQ.enqueue([x, y], dist);
+ maxQ.enqueue({ point: [x, y], dist });
if (maxQ.size() > k) {
maxQ.dequeue();
}
}
- return maxQ.toArray().map(item => item.element);
+ return maxQ.toArray().map(entry => entry.point);
}
```
diff --git a/solution/0900-0999/0973.K Closest Points to Origin/Solution2.ts b/solution/0900-0999/0973.K Closest Points to Origin/Solution2.ts
index afeb1c9d648f6..9c7b62a6e4027 100644
--- a/solution/0900-0999/0973.K Closest Points to Origin/Solution2.ts
+++ b/solution/0900-0999/0973.K Closest Points to Origin/Solution2.ts
@@ -1,11 +1,11 @@
function kClosest(points: number[][], k: number): number[][] {
- const maxQ = new MaxPriorityQueue();
+ const maxQ = new MaxPriorityQueue<{ point: number[]; dist: number }>(entry => entry.dist);
for (const [x, y] of points) {
const dist = x * x + y * y;
- maxQ.enqueue([x, y], dist);
+ maxQ.enqueue({ point: [x, y], dist });
if (maxQ.size() > k) {
maxQ.dequeue();
}
}
- return maxQ.toArray().map(item => item.element);
+ return maxQ.toArray().map(entry => entry.point);
}
diff --git a/solution/0900-0999/0975.Odd Even Jump/README.md b/solution/0900-0999/0975.Odd Even Jump/README.md
index f0bbd0397fc28..5b0069344c69d 100644
--- a/solution/0900-0999/0975.Odd Even Jump/README.md
+++ b/solution/0900-0999/0975.Odd Even Jump/README.md
@@ -7,6 +7,7 @@ tags:
- 数组
- 动态规划
- 有序集合
+ - 排序
- 单调栈
---
diff --git a/solution/0900-0999/0975.Odd Even Jump/README_EN.md b/solution/0900-0999/0975.Odd Even Jump/README_EN.md
index 99f76a4a016e2..e13288bf6ea1f 100644
--- a/solution/0900-0999/0975.Odd Even Jump/README_EN.md
+++ b/solution/0900-0999/0975.Odd Even Jump/README_EN.md
@@ -7,6 +7,7 @@ tags:
- Array
- Dynamic Programming
- Ordered Set
+ - Sorting
- Monotonic Stack
---
diff --git a/solution/1000-1099/1046.Last Stone Weight/README.md b/solution/1000-1099/1046.Last Stone Weight/README.md
index 805d5787cb803..987404398de4f 100644
--- a/solution/1000-1099/1046.Last Stone Weight/README.md
+++ b/solution/1000-1099/1046.Last Stone Weight/README.md
@@ -163,18 +163,18 @@ func (h *hp) pop() int { return heap.Pop(h).(int) }
```ts
function lastStoneWeight(stones: number[]): number {
- const pq = new MaxPriorityQueue();
+ const pq = new MaxPriorityQueue();
for (const x of stones) {
pq.enqueue(x);
}
while (pq.size() > 1) {
- const y = pq.dequeue().element;
- const x = pq.dequeue().element;
+ const y = pq.dequeue();
+ const x = pq.dequeue();
if (x !== y) {
pq.enqueue(y - x);
}
}
- return pq.isEmpty() ? 0 : pq.dequeue().element;
+ return pq.isEmpty() ? 0 : pq.dequeue();
}
```
@@ -191,13 +191,13 @@ var lastStoneWeight = function (stones) {
pq.enqueue(x);
}
while (pq.size() > 1) {
- const y = pq.dequeue()['priority'];
- const x = pq.dequeue()['priority'];
+ const y = pq.dequeue();
+ const x = pq.dequeue();
if (x != y) {
pq.enqueue(y - x);
}
}
- return pq.isEmpty() ? 0 : pq.dequeue()['priority'];
+ return pq.isEmpty() ? 0 : pq.dequeue();
};
```
diff --git a/solution/1000-1099/1046.Last Stone Weight/README_EN.md b/solution/1000-1099/1046.Last Stone Weight/README_EN.md
index 4cfa4d01b3945..4c1f07348f415 100644
--- a/solution/1000-1099/1046.Last Stone Weight/README_EN.md
+++ b/solution/1000-1099/1046.Last Stone Weight/README_EN.md
@@ -165,18 +165,18 @@ func (h *hp) pop() int { return heap.Pop(h).(int) }
```ts
function lastStoneWeight(stones: number[]): number {
- const pq = new MaxPriorityQueue();
+ const pq = new MaxPriorityQueue();
for (const x of stones) {
pq.enqueue(x);
}
while (pq.size() > 1) {
- const y = pq.dequeue().element;
- const x = pq.dequeue().element;
+ const y = pq.dequeue();
+ const x = pq.dequeue();
if (x !== y) {
pq.enqueue(y - x);
}
}
- return pq.isEmpty() ? 0 : pq.dequeue().element;
+ return pq.isEmpty() ? 0 : pq.dequeue();
}
```
@@ -193,13 +193,13 @@ var lastStoneWeight = function (stones) {
pq.enqueue(x);
}
while (pq.size() > 1) {
- const y = pq.dequeue()['priority'];
- const x = pq.dequeue()['priority'];
+ const y = pq.dequeue();
+ const x = pq.dequeue();
if (x != y) {
pq.enqueue(y - x);
}
}
- return pq.isEmpty() ? 0 : pq.dequeue()['priority'];
+ return pq.isEmpty() ? 0 : pq.dequeue();
};
```
diff --git a/solution/1000-1099/1046.Last Stone Weight/Solution.js b/solution/1000-1099/1046.Last Stone Weight/Solution.js
index 2452c8e41cee7..f015b347d6ce9 100644
--- a/solution/1000-1099/1046.Last Stone Weight/Solution.js
+++ b/solution/1000-1099/1046.Last Stone Weight/Solution.js
@@ -8,11 +8,11 @@ var lastStoneWeight = function (stones) {
pq.enqueue(x);
}
while (pq.size() > 1) {
- const y = pq.dequeue()['priority'];
- const x = pq.dequeue()['priority'];
+ const y = pq.dequeue();
+ const x = pq.dequeue();
if (x != y) {
pq.enqueue(y - x);
}
}
- return pq.isEmpty() ? 0 : pq.dequeue()['priority'];
+ return pq.isEmpty() ? 0 : pq.dequeue();
};
diff --git a/solution/1000-1099/1046.Last Stone Weight/Solution.ts b/solution/1000-1099/1046.Last Stone Weight/Solution.ts
index 4224189ffb4a8..07ed9d5d66241 100644
--- a/solution/1000-1099/1046.Last Stone Weight/Solution.ts
+++ b/solution/1000-1099/1046.Last Stone Weight/Solution.ts
@@ -1,14 +1,14 @@
function lastStoneWeight(stones: number[]): number {
- const pq = new MaxPriorityQueue();
+ const pq = new MaxPriorityQueue();
for (const x of stones) {
pq.enqueue(x);
}
while (pq.size() > 1) {
- const y = pq.dequeue().element;
- const x = pq.dequeue().element;
+ const y = pq.dequeue();
+ const x = pq.dequeue();
if (x !== y) {
pq.enqueue(y - x);
}
}
- return pq.isEmpty() ? 0 : pq.dequeue().element;
+ return pq.isEmpty() ? 0 : pq.dequeue();
}
diff --git a/solution/1100-1199/1164.Product Price at a Given Date/README.md b/solution/1100-1199/1164.Product Price at a Given Date/README.md
index c030fb7d15c63..9506824a43bed 100644
--- a/solution/1100-1199/1164.Product Price at a Given Date/README.md
+++ b/solution/1100-1199/1164.Product Price at a Given Date/README.md
@@ -31,7 +31,7 @@ tags:
一开始，所有产品价格都为 10。
-编写一个解决方案，找出在 2019-08-16。
+编写一个解决方案，找出在 2019-08-16 所有产品的价格。
以 任意顺序 返回结果表。
diff --git a/solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/README.md b/solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/README.md
index 2066a078751e3..0b2e18dccc984 100644
--- a/solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/README.md
+++ b/solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/README.md
@@ -348,193 +348,151 @@ public:
```go
type Trie struct {
children map[string]*Trie
- isEnd bool
+ fid int
}
func newTrie() *Trie {
- m := map[string]*Trie{}
- return &Trie{children: m}
+ return &Trie{map[string]*Trie{}, -1}
}
-func (this *Trie) insert(w string) {
+func (this *Trie) insert(fid int, f string) {
node := this
- for _, p := range strings.Split(w, "/")[1:] {
+ ps := strings.Split(f, "/")
+ for _, p := range ps[1:] {
if _, ok := node.children[p]; !ok {
node.children[p] = newTrie()
}
- node, _ = node.children[p]
+ node = node.children[p]
}
- node.isEnd = true
+ node.fid = fid
}
-func (this *Trie) search(w string) bool {
- node := this
- for _, p := range strings.Split(w, "/")[1:] {
- if _, ok := node.children[p]; !ok {
- return false
+func (this *Trie) search() (ans []int) {
+ var dfs func(*Trie)
+ dfs = func(root *Trie) {
+ if root.fid != -1 {
+ ans = append(ans, root.fid)
+ return
}
- node, _ = node.children[p]
- if node.isEnd {
- return true
+ for _, child := range root.children {
+ dfs(child)
}
}
- return false
+ dfs(this)
+ return
}
-func removeSubfolders(folder []string) []string {
- sort.Slice(folder, func(i, j int) bool {
- return len(strings.Split(folder[i], "/")) < len(strings.Split(folder[j], "/"))
- })
+func removeSubfolders(folder []string) (ans []string) {
trie := newTrie()
- var ans []string
- for _, v := range folder {
- if !trie.search(v) {
- trie.insert(v)
- ans = append(ans, v)
- }
+ for i, f := range folder {
+ trie.insert(i, f)
}
- return ans
+ for _, i := range trie.search() {
+ ans = append(ans, folder[i])
+ }
+ return
}
```
#### TypeScript
```ts
-function removeSubfolders(folder: string[]): string[] {
- const createTrie = (): T => ({ '#': false, children: {} });
- const trie = createTrie();
+class Trie {
+ children: Record;
+ fid: number;
- for (const f of folder) {
- const path = f.split('/');
- path.shift();
+ constructor() {
+ this.children = {};
+ this.fid = -1;
+ }
- let node = trie;
- for (const p of path) {
- if (!node.children[p]) node.children[p] = createTrie();
+ insert(i: number, f: string): void {
+ let node: Trie = this;
+ const ps = f.split('/');
+ for (let j = 1; j < ps.length; ++j) {
+ const p = ps[j];
+ if (!(p in node.children)) {
+ node.children[p] = new Trie();
+ }
node = node.children[p];
}
- node['#'] = true;
+ node.fid = i;
}
- const ans: string[] = [];
- const dfs = (trie: T, path = '') => {
- if (trie['#']) {
- ans.push(path);
- return;
- }
-
- for (const key in trie.children) {
- dfs(trie.children[key], path + '/' + key);
- }
- };
-
- dfs(trie);
-
- return ans;
+ search(): number[] {
+ const ans: number[] = [];
+ const dfs = (root: Trie): void => {
+ if (root.fid !== -1) {
+ ans.push(root.fid);
+ return;
+ }
+ for (const child of Object.values(root.children)) {
+ dfs(child);
+ }
+ };
+ dfs(this);
+ return ans;
+ }
}
-type T = {
- '#': boolean;
- children: Record;
-};
+function removeSubfolders(folder: string[]): string[] {
+ const trie = new Trie();
+ for (let i = 0; i < folder.length; ++i) {
+ trie.insert(i, folder[i]);
+ }
+ return trie.search().map(i => folder[i]);
+}
```
#### JavaScript
```js
-function removeSubfolders(folder) {
- const createTrie = () => ({ '#': false, children: {} });
- const trie = createTrie();
-
- for (const f of folder) {
- const path = f.split('/');
- path.shift();
+class Trie {
+ constructor() {
+ this.children = {};
+ this.fid = -1;
+ }
- let node = trie;
- for (const p of path) {
- if (!node.children[p]) node.children[p] = createTrie();
+ insert(i, f) {
+ let node = this;
+ const ps = f.split('/');
+ for (let j = 1; j < ps.length; ++j) {
+ const p = ps[j];
+ if (!(p in node.children)) {
+ node.children[p] = new Trie();
+ }
node = node.children[p];
}
- node['#'] = true;
+ node.fid = i;
}
- const ans = [];
- const dfs = (trie, path = '') => {
- if (trie['#']) {
- ans.push(path);
- return;
- }
-
- for (const key in trie.children) {
- dfs(trie.children[key], path + '/' + key);
- }
- };
-
- dfs(trie);
-
- return ans;
-}
-```
-
-
-
-
-
-
-
-### 方法三
-
-
-
-#### Go
-
-```go
-type Trie struct {
- children map[string]*Trie
- fid int
-}
-
-func newTrie() *Trie {
- return &Trie{map[string]*Trie{}, -1}
-}
-
-func (this *Trie) insert(fid int, f string) {
- node := this
- ps := strings.Split(f, "/")
- for _, p := range ps[1:] {
- if _, ok := node.children[p]; !ok {
- node.children[p] = newTrie()
- }
- node = node.children[p]
- }
- node.fid = fid
-}
-
-func (this *Trie) search() (ans []int) {
- var dfs func(*Trie)
- dfs = func(root *Trie) {
- if root.fid != -1 {
- ans = append(ans, root.fid)
- return
- }
- for _, child := range root.children {
- dfs(child)
- }
- }
- dfs(this)
- return
+ search() {
+ const ans = [];
+ const dfs = root => {
+ if (root.fid !== -1) {
+ ans.push(root.fid);
+ return;
+ }
+ for (const child of Object.values(root.children)) {
+ dfs(child);
+ }
+ };
+ dfs(this);
+ return ans;
+ }
}
-func removeSubfolders(folder []string) (ans []string) {
- trie := newTrie()
- for i, f := range folder {
- trie.insert(i, f)
- }
- for _, i := range trie.search() {
- ans = append(ans, folder[i])
- }
- return
-}
+/**
+ * @param {string[]} folder
+ * @return {string[]}
+ */
+var removeSubfolders = function (folder) {
+ const trie = new Trie();
+ for (let i = 0; i < folder.length; ++i) {
+ trie.insert(i, folder[i]);
+ }
+ return trie.search().map(i => folder[i]);
+};
```
diff --git a/solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/README_EN.md b/solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/README_EN.md
index 6d9859eca427f..d4a4790b79abc 100644
--- a/solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/README_EN.md
+++ b/solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/README_EN.md
@@ -347,193 +347,151 @@ public:
```go
type Trie struct {
children map[string]*Trie
- isEnd bool
+ fid int
}
func newTrie() *Trie {
- m := map[string]*Trie{}
- return &Trie{children: m}
+ return &Trie{map[string]*Trie{}, -1}
}
-func (this *Trie) insert(w string) {
+func (this *Trie) insert(fid int, f string) {
node := this
- for _, p := range strings.Split(w, "/")[1:] {
+ ps := strings.Split(f, "/")
+ for _, p := range ps[1:] {
if _, ok := node.children[p]; !ok {
node.children[p] = newTrie()
}
- node, _ = node.children[p]
+ node = node.children[p]
}
- node.isEnd = true
+ node.fid = fid
}
-func (this *Trie) search(w string) bool {
- node := this
- for _, p := range strings.Split(w, "/")[1:] {
- if _, ok := node.children[p]; !ok {
- return false
+func (this *Trie) search() (ans []int) {
+ var dfs func(*Trie)
+ dfs = func(root *Trie) {
+ if root.fid != -1 {
+ ans = append(ans, root.fid)
+ return
}
- node, _ = node.children[p]
- if node.isEnd {
- return true
+ for _, child := range root.children {
+ dfs(child)
}
}
- return false
+ dfs(this)
+ return
}
-func removeSubfolders(folder []string) []string {
- sort.Slice(folder, func(i, j int) bool {
- return len(strings.Split(folder[i], "/")) < len(strings.Split(folder[j], "/"))
- })
+func removeSubfolders(folder []string) (ans []string) {
trie := newTrie()
- var ans []string
- for _, v := range folder {
- if !trie.search(v) {
- trie.insert(v)
- ans = append(ans, v)
- }
+ for i, f := range folder {
+ trie.insert(i, f)
}
- return ans
+ for _, i := range trie.search() {
+ ans = append(ans, folder[i])
+ }
+ return
}
```
#### TypeScript
```ts
-function removeSubfolders(folder: string[]): string[] {
- const createTrie = (): T => ({ '#': false, children: {} });
- const trie = createTrie();
+class Trie {
+ children: Record;
+ fid: number;
- for (const f of folder) {
- const path = f.split('/');
- path.shift();
+ constructor() {
+ this.children = {};
+ this.fid = -1;
+ }
- let node = trie;
- for (const p of path) {
- if (!node.children[p]) node.children[p] = createTrie();
+ insert(i: number, f: string): void {
+ let node: Trie = this;
+ const ps = f.split('/');
+ for (let j = 1; j < ps.length; ++j) {
+ const p = ps[j];
+ if (!(p in node.children)) {
+ node.children[p] = new Trie();
+ }
node = node.children[p];
}
- node['#'] = true;
+ node.fid = i;
}
- const ans: string[] = [];
- const dfs = (trie: T, path = '') => {
- if (trie['#']) {
- ans.push(path);
- return;
- }
-
- for (const key in trie.children) {
- dfs(trie.children[key], path + '/' + key);
- }
- };
-
- dfs(trie);
-
- return ans;
+ search(): number[] {
+ const ans: number[] = [];
+ const dfs = (root: Trie): void => {
+ if (root.fid !== -1) {
+ ans.push(root.fid);
+ return;
+ }
+ for (const child of Object.values(root.children)) {
+ dfs(child);
+ }
+ };
+ dfs(this);
+ return ans;
+ }
}
-type T = {
- '#': boolean;
- children: Record;
-};
+function removeSubfolders(folder: string[]): string[] {
+ const trie = new Trie();
+ for (let i = 0; i < folder.length; ++i) {
+ trie.insert(i, folder[i]);
+ }
+ return trie.search().map(i => folder[i]);
+}
```
#### JavaScript
```js
-function removeSubfolders(folder) {
- const createTrie = () => ({ '#': false, children: {} });
- const trie = createTrie();
-
- for (const f of folder) {
- const path = f.split('/');
- path.shift();
+class Trie {
+ constructor() {
+ this.children = {};
+ this.fid = -1;
+ }
- let node = trie;
- for (const p of path) {
- if (!node.children[p]) node.children[p] = createTrie();
+ insert(i, f) {
+ let node = this;
+ const ps = f.split('/');
+ for (let j = 1; j < ps.length; ++j) {
+ const p = ps[j];
+ if (!(p in node.children)) {
+ node.children[p] = new Trie();
+ }
node = node.children[p];
}
- node['#'] = true;
+ node.fid = i;
}
- const ans = [];
- const dfs = (trie, path = '') => {
- if (trie['#']) {
- ans.push(path);
- return;
- }
-
- for (const key in trie.children) {
- dfs(trie.children[key], path + '/' + key);
- }
- };
-
- dfs(trie);
-
- return ans;
-}
-```
-
-
-
-
-
-
-
-### Solution 3
-
-
-
-#### Go
-
-```go
-type Trie struct {
- children map[string]*Trie
- fid int
-}
-
-func newTrie() *Trie {
- return &Trie{map[string]*Trie{}, -1}
-}
-
-func (this *Trie) insert(fid int, f string) {
- node := this
- ps := strings.Split(f, "/")
- for _, p := range ps[1:] {
- if _, ok := node.children[p]; !ok {
- node.children[p] = newTrie()
- }
- node = node.children[p]
- }
- node.fid = fid
-}
-
-func (this *Trie) search() (ans []int) {
- var dfs func(*Trie)
- dfs = func(root *Trie) {
- if root.fid != -1 {
- ans = append(ans, root.fid)
- return
- }
- for _, child := range root.children {
- dfs(child)
- }
- }
- dfs(this)
- return
+ search() {
+ const ans = [];
+ const dfs = root => {
+ if (root.fid !== -1) {
+ ans.push(root.fid);
+ return;
+ }
+ for (const child of Object.values(root.children)) {
+ dfs(child);
+ }
+ };
+ dfs(this);
+ return ans;
+ }
}
-func removeSubfolders(folder []string) (ans []string) {
- trie := newTrie()
- for i, f := range folder {
- trie.insert(i, f)
- }
- for _, i := range trie.search() {
- ans = append(ans, folder[i])
- }
- return
-}
+/**
+ * @param {string[]} folder
+ * @return {string[]}
+ */
+var removeSubfolders = function (folder) {
+ const trie = new Trie();
+ for (let i = 0; i < folder.length; ++i) {
+ trie.insert(i, folder[i]);
+ }
+ return trie.search().map(i => folder[i]);
+};
```
diff --git a/solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/Solution2.go b/solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/Solution2.go
index 5f0a8f90351af..9a5f248168d9d 100644
--- a/solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/Solution2.go
+++ b/solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/Solution2.go
@@ -1,49 +1,46 @@
type Trie struct {
children map[string]*Trie
- isEnd bool
+ fid int
}
func newTrie() *Trie {
- m := map[string]*Trie{}
- return &Trie{children: m}
+ return &Trie{map[string]*Trie{}, -1}
}
-func (this *Trie) insert(w string) {
+func (this *Trie) insert(fid int, f string) {
node := this
- for _, p := range strings.Split(w, "/")[1:] {
+ ps := strings.Split(f, "/")
+ for _, p := range ps[1:] {
if _, ok := node.children[p]; !ok {
node.children[p] = newTrie()
}
- node, _ = node.children[p]
+ node = node.children[p]
}
- node.isEnd = true
+ node.fid = fid
}
-func (this *Trie) search(w string) bool {
- node := this
- for _, p := range strings.Split(w, "/")[1:] {
- if _, ok := node.children[p]; !ok {
- return false
+func (this *Trie) search() (ans []int) {
+ var dfs func(*Trie)
+ dfs = func(root *Trie) {
+ if root.fid != -1 {
+ ans = append(ans, root.fid)
+ return
}
- node, _ = node.children[p]
- if node.isEnd {
- return true
+ for _, child := range root.children {
+ dfs(child)
}
}
- return false
+ dfs(this)
+ return
}
-func removeSubfolders(folder []string) []string {
- sort.Slice(folder, func(i, j int) bool {
- return len(strings.Split(folder[i], "/")) < len(strings.Split(folder[j], "/"))
- })
+func removeSubfolders(folder []string) (ans []string) {
trie := newTrie()
- var ans []string
- for _, v := range folder {
- if !trie.search(v) {
- trie.insert(v)
- ans = append(ans, v)
- }
+ for i, f := range folder {
+ trie.insert(i, f)
+ }
+ for _, i := range trie.search() {
+ ans = append(ans, folder[i])
}
- return ans
+ return
}
\ No newline at end of file
diff --git a/solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/Solution2.js b/solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/Solution2.js
index 2c3e9e4bfca6e..4381e95c37f7f 100644
--- a/solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/Solution2.js
+++ b/solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/Solution2.js
@@ -1,32 +1,46 @@
-function removeSubfolders(folder) {
- const createTrie = () => ({ '#': false, children: {} });
- const trie = createTrie();
-
- for (const f of folder) {
- const path = f.split('/');
- path.shift();
+class Trie {
+ constructor() {
+ this.children = {};
+ this.fid = -1;
+ }
- let node = trie;
- for (const p of path) {
- if (!node.children[p]) node.children[p] = createTrie();
+ insert(i, f) {
+ let node = this;
+ const ps = f.split('/');
+ for (let j = 1; j < ps.length; ++j) {
+ const p = ps[j];
+ if (!(p in node.children)) {
+ node.children[p] = new Trie();
+ }
node = node.children[p];
}
- node['#'] = true;
+ node.fid = i;
}
- const ans = [];
- const dfs = (trie, path = '') => {
- if (trie['#']) {
- ans.push(path);
- return;
- }
-
- for (const key in trie.children) {
- dfs(trie.children[key], path + '/' + key);
- }
- };
-
- dfs(trie);
-
- return ans;
+ search() {
+ const ans = [];
+ const dfs = root => {
+ if (root.fid !== -1) {
+ ans.push(root.fid);
+ return;
+ }
+ for (const child of Object.values(root.children)) {
+ dfs(child);
+ }
+ };
+ dfs(this);
+ return ans;
+ }
}
+
+/**
+ * @param {string[]} folder
+ * @return {string[]}
+ */
+var removeSubfolders = function (folder) {
+ const trie = new Trie();
+ for (let i = 0; i < folder.length; ++i) {
+ trie.insert(i, folder[i]);
+ }
+ return trie.search().map(i => folder[i]);
+};
diff --git a/solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/Solution2.ts b/solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/Solution2.ts
index 07802228b1dc7..fd6862e4b51a4 100644
--- a/solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/Solution2.ts
+++ b/solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/Solution2.ts
@@ -1,37 +1,45 @@
-function removeSubfolders(folder: string[]): string[] {
- const createTrie = (): T => ({ '#': false, children: {} });
- const trie = createTrie();
+class Trie {
+ children: Record;
+ fid: number;
- for (const f of folder) {
- const path = f.split('/');
- path.shift();
+ constructor() {
+ this.children = {};
+ this.fid = -1;
+ }
- let node = trie;
- for (const p of path) {
- if (!node.children[p]) node.children[p] = createTrie();
+ insert(i: number, f: string): void {
+ let node: Trie = this;
+ const ps = f.split('/');
+ for (let j = 1; j < ps.length; ++j) {
+ const p = ps[j];
+ if (!(p in node.children)) {
+ node.children[p] = new Trie();
+ }
node = node.children[p];
}
- node['#'] = true;
+ node.fid = i;
}
- const ans: string[] = [];
- const dfs = (trie: T, path = '') => {
- if (trie['#']) {
- ans.push(path);
- return;
- }
-
- for (const key in trie.children) {
- dfs(trie.children[key], path + '/' + key);
- }
- };
-
- dfs(trie);
-
- return ans;
+ search(): number[] {
+ const ans: number[] = [];
+ const dfs = (root: Trie): void => {
+ if (root.fid !== -1) {
+ ans.push(root.fid);
+ return;
+ }
+ for (const child of Object.values(root.children)) {
+ dfs(child);
+ }
+ };
+ dfs(this);
+ return ans;
+ }
}
-type T = {
- '#': boolean;
- children: Record;
-};
+function removeSubfolders(folder: string[]): string[] {
+ const trie = new Trie();
+ for (let i = 0; i < folder.length; ++i) {
+ trie.insert(i, folder[i]);
+ }
+ return trie.search().map(i => folder[i]);
+}
diff --git a/solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/Solution3.go b/solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/Solution3.go
deleted file mode 100644
index 9a5f248168d9d..0000000000000
--- a/solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/Solution3.go
+++ /dev/null
@@ -1,46 +0,0 @@
-type Trie struct {
- children map[string]*Trie
- fid int
-}
-
-func newTrie() *Trie {
- return &Trie{map[string]*Trie{}, -1}
-}
-
-func (this *Trie) insert(fid int, f string) {
- node := this
- ps := strings.Split(f, "/")
- for _, p := range ps[1:] {
- if _, ok := node.children[p]; !ok {
- node.children[p] = newTrie()
- }
- node = node.children[p]
- }
- node.fid = fid
-}
-
-func (this *Trie) search() (ans []int) {
- var dfs func(*Trie)
- dfs = func(root *Trie) {
- if root.fid != -1 {
- ans = append(ans, root.fid)
- return
- }
- for _, child := range root.children {
- dfs(child)
- }
- }
- dfs(this)
- return
-}
-
-func removeSubfolders(folder []string) (ans []string) {
- trie := newTrie()
- for i, f := range folder {
- trie.insert(i, f)
- }
- for _, i := range trie.search() {
- ans = append(ans, folder[i])
- }
- return
-}
\ No newline at end of file
diff --git a/solution/1200-1299/1258.Synonymous Sentences/README.md b/solution/1200-1299/1258.Synonymous Sentences/README.md
index 2b00239e3e600..c5efea5ae8214 100644
--- a/solution/1200-1299/1258.Synonymous Sentences/README.md
+++ b/solution/1200-1299/1258.Synonymous Sentences/README.md
@@ -5,6 +5,7 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/1200-1299/1258.Sy
rating: 1847
source: 第 13 场双周赛 Q3
tags:
+ - 排序
- 并查集
- 数组
- 哈希表
diff --git a/solution/1200-1299/1258.Synonymous Sentences/README_EN.md b/solution/1200-1299/1258.Synonymous Sentences/README_EN.md
index 5e6126ae5a0c2..849c4d294e764 100644
--- a/solution/1200-1299/1258.Synonymous Sentences/README_EN.md
+++ b/solution/1200-1299/1258.Synonymous Sentences/README_EN.md
@@ -5,6 +5,7 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/1200-1299/1258.Sy
rating: 1847
source: Biweekly Contest 13 Q3
tags:
+ - Sort
- Union Find
- Array
- Hash Table
diff --git a/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/README.md b/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/README.md
index 64d18981736ca..b31a8a0daf1b6 100644
--- a/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/README.md
+++ b/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/README.md
@@ -23,38 +23,24 @@ tags:
请你返回该链表所表示数字的 十进制值 。
+最高位 在链表的头部。
+
示例 1：
-
+
-输入：head = [1,0,1]
+
+输入：head = [1,0,1]
输出：5
解释：二进制数 (101) 转化为十进制数 (5)
示例 2：
-输入：head = [0]
-输出：0
-
-
-示例 3：
-
-输入：head = [1]
-输出：1
-
-
-示例 4：
-
-输入：head = [1,0,0,1,0,0,1,1,1,0,0,0,0,0,0]
-输出：18880
-
-
-示例 5：
-
-输入：head = [0,0]
+
+输入：head = [0]
输出：0
@@ -76,11 +62,11 @@ tags:
### 方法一：遍历链表
-我们用变量 `ans` 记录当前的十进制值，初始值为 $0$。
+我们用变量 $\textit{ans}$ 记录当前的十进制值，初始值为 $0$。
-遍历链表，对于每个结点，将 `ans` 左移一位，然后再或上当前结点的值。遍历结束后，`ans` 即为十进制值。
+遍历链表，对于每个结点，将 $\textit{ans}$ 左移一位，然后再或上当前结点的值。遍历结束后，$\textit{ans}$ 即为十进制值。
-时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为链表的长度。
+时间复杂度 $O(n)$，其中 $n$ 为链表的长度。空间复杂度 $O(1)$。
@@ -212,12 +198,11 @@ function getDecimalValue(head: ListNode | null): number {
// }
// }
impl Solution {
- pub fn get_decimal_value(head: Option>) -> i32 {
+ pub fn get_decimal_value(mut head: Option>) -> i32 {
let mut ans = 0;
- let mut cur = &head;
- while let Some(node) = cur {
+ while let Some(node) = head {
ans = (ans << 1) | node.val;
- cur = &node.next;
+ head = node.next;
}
ans
}
@@ -247,6 +232,31 @@ var getDecimalValue = function (head) {
};
```
+#### C#
+
+```cs
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ * public int val;
+ * public ListNode next;
+ * public ListNode(int val=0, ListNode next=null) {
+ * this.val = val;
+ * this.next = next;
+ * }
+ * }
+ */
+public class Solution {
+ public int GetDecimalValue(ListNode head) {
+ int ans = 0;
+ for (; head != null; head = head.next) {
+ ans = ans << 1 | head.val;
+ }
+ return ans;
+ }
+}
+```
+
#### PHP
```php
@@ -267,13 +277,12 @@ class Solution {
* @return Integer
*/
function getDecimalValue($head) {
- $rs = [];
- while ($head != null) {
- array_push($rs, $head->val);
+ $ans = 0;
+ while ($head !== null) {
+ $ans = ($ans << 1) | $head->val;
$head = $head->next;
}
- $rsStr = implode($rs);
- return bindec($rsStr);
+ return $ans;
}
}
```
diff --git a/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/README_EN.md b/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/README_EN.md
index 3e49f84db6367..5d6aaab02c5ac 100644
--- a/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/README_EN.md
+++ b/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/README_EN.md
@@ -56,7 +56,13 @@ tags:
-### Solution 1
+### Solution 1: Traverse the Linked List
+
+We use a variable $\textit{ans}$ to record the current decimal value, with an initial value of $0$.
+
+Traverse the linked list. For each node, left-shift $\textit{ans}$ by one bit, then perform a bitwise OR with the current node's value. After traversal, $\textit{ans}$ is the decimal value.
+
+The time complexity is $O(n)$, where $n$ is the length of the linked list. The space complexity is $O(1)$.
@@ -188,12 +194,11 @@ function getDecimalValue(head: ListNode | null): number {
// }
// }
impl Solution {
- pub fn get_decimal_value(head: Option>) -> i32 {
+ pub fn get_decimal_value(mut head: Option>) -> i32 {
let mut ans = 0;
- let mut cur = &head;
- while let Some(node) = cur {
+ while let Some(node) = head {
ans = (ans << 1) | node.val;
- cur = &node.next;
+ head = node.next;
}
ans
}
@@ -223,6 +228,31 @@ var getDecimalValue = function (head) {
};
```
+#### C#
+
+```cs
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ * public int val;
+ * public ListNode next;
+ * public ListNode(int val=0, ListNode next=null) {
+ * this.val = val;
+ * this.next = next;
+ * }
+ * }
+ */
+public class Solution {
+ public int GetDecimalValue(ListNode head) {
+ int ans = 0;
+ for (; head != null; head = head.next) {
+ ans = ans << 1 | head.val;
+ }
+ return ans;
+ }
+}
+```
+
#### PHP
```php
@@ -243,13 +273,12 @@ class Solution {
* @return Integer
*/
function getDecimalValue($head) {
- $rs = [];
- while ($head != null) {
- array_push($rs, $head->val);
+ $ans = 0;
+ while ($head !== null) {
+ $ans = ($ans << 1) | $head->val;
$head = $head->next;
}
- $rsStr = implode($rs);
- return bindec($rsStr);
+ return $ans;
}
}
```
diff --git a/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/Solution.cs b/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/Solution.cs
new file mode 100644
index 0000000000000..bbfcf9dbff062
--- /dev/null
+++ b/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/Solution.cs
@@ -0,0 +1,20 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ * public int val;
+ * public ListNode next;
+ * public ListNode(int val=0, ListNode next=null) {
+ * this.val = val;
+ * this.next = next;
+ * }
+ * }
+ */
+public class Solution {
+ public int GetDecimalValue(ListNode head) {
+ int ans = 0;
+ for (; head != null; head = head.next) {
+ ans = ans << 1 | head.val;
+ }
+ return ans;
+ }
+}
\ No newline at end of file
diff --git a/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/Solution.php b/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/Solution.php
index 7ddaf720fe6ae..514bc47573ca4 100644
--- a/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/Solution.php
+++ b/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/Solution.php
@@ -15,12 +15,11 @@ class Solution {
* @return Integer
*/
function getDecimalValue($head) {
- $rs = [];
- while ($head != null) {
- array_push($rs, $head->val);
+ $ans = 0;
+ while ($head !== null) {
+ $ans = ($ans << 1) | $head->val;
$head = $head->next;
}
- $rsStr = implode($rs);
- return bindec($rsStr);
+ return $ans;
}
}
\ No newline at end of file
diff --git a/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/Solution.rs b/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/Solution.rs
index 7c122a66fc0df..b3f205ea5f95c 100644
--- a/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/Solution.rs
+++ b/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/Solution.rs
@@ -15,12 +15,11 @@
// }
// }
impl Solution {
- pub fn get_decimal_value(head: Option>) -> i32 {
+ pub fn get_decimal_value(mut head: Option>) -> i32 {
let mut ans = 0;
- let mut cur = &head;
- while let Some(node) = cur {
+ while let Some(node) = head {
ans = (ans << 1) | node.val;
- cur = &node.next;
+ head = node.next;
}
ans
}
diff --git a/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/README_EN.md b/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/README_EN.md
index f24de3d125ff9..9957c486820dd 100644
--- a/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/README_EN.md
+++ b/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/README_EN.md
@@ -23,7 +23,7 @@ tags:
You are given an array of events where events[i] = [startDayi, endDayi]. Every event i starts at startDayi and ends at endDayi.
-You can attend an event i at any day d where startTimei <= d <= endTimei. You can only attend one event at any time d.
+You can attend an event i at any day d where startDayi <= d <= endDayi. You can only attend one event at any time d.
Return the maximum number of events you can attend.
diff --git a/solution/1300-1399/1354.Construct Target Array With Multiple Sums/README.md b/solution/1300-1399/1354.Construct Target Array With Multiple Sums/README.md
index 67cd7338f7ab9..92d70c41f8ff3 100644
--- a/solution/1300-1399/1354.Construct Target Array With Multiple Sums/README.md
+++ b/solution/1300-1399/1354.Construct Target Array With Multiple Sums/README.md
@@ -198,14 +198,14 @@ func (hp) Push(any) {}
```ts
function isPossible(target: number[]): boolean {
- const pq = new MaxPriorityQueue();
+ const pq = new MaxPriorityQueue();
let s = 0;
for (const x of target) {
s += x;
pq.enqueue(x);
}
- while (pq.front().element > 1) {
- const mx = pq.dequeue().element;
+ while (pq.front() > 1) {
+ const mx = pq.dequeue();
const t = s - mx;
if (t < 1 || mx - t < 1) {
return false;
diff --git a/solution/1300-1399/1354.Construct Target Array With Multiple Sums/README_EN.md b/solution/1300-1399/1354.Construct Target Array With Multiple Sums/README_EN.md
index 46c3cefe4351d..1add677cba9f6 100644
--- a/solution/1300-1399/1354.Construct Target Array With Multiple Sums/README_EN.md
+++ b/solution/1300-1399/1354.Construct Target Array With Multiple Sums/README_EN.md
@@ -199,14 +199,14 @@ func (hp) Push(any) {}
```ts
function isPossible(target: number[]): boolean {
- const pq = new MaxPriorityQueue();
+ const pq = new MaxPriorityQueue();
let s = 0;
for (const x of target) {
s += x;
pq.enqueue(x);
}
- while (pq.front().element > 1) {
- const mx = pq.dequeue().element;
+ while (pq.front() > 1) {
+ const mx = pq.dequeue();
const t = s - mx;
if (t < 1 || mx - t < 1) {
return false;
diff --git a/solution/1300-1399/1354.Construct Target Array With Multiple Sums/Solution.ts b/solution/1300-1399/1354.Construct Target Array With Multiple Sums/Solution.ts
index 144be716e511b..30f3e9d27db06 100644
--- a/solution/1300-1399/1354.Construct Target Array With Multiple Sums/Solution.ts
+++ b/solution/1300-1399/1354.Construct Target Array With Multiple Sums/Solution.ts
@@ -1,12 +1,12 @@
function isPossible(target: number[]): boolean {
- const pq = new MaxPriorityQueue();
+ const pq = new MaxPriorityQueue();
let s = 0;
for (const x of target) {
s += x;
pq.enqueue(x);
}
- while (pq.front().element > 1) {
- const mx = pq.dequeue().element;
+ while (pq.front() > 1) {
+ const mx = pq.dequeue();
const t = s - mx;
if (t < 1 || mx - t < 1) {
return false;
diff --git a/solution/1500-1599/1516.Move Sub-Tree of N-Ary Tree/README.md b/solution/1500-1599/1516.Move Sub-Tree of N-Ary Tree/README.md
index f84db1a2762b3..27fb4be1e91f3 100644
--- a/solution/1500-1599/1516.Move Sub-Tree of N-Ary Tree/README.md
+++ b/solution/1500-1599/1516.Move Sub-Tree of N-Ary Tree/README.md
@@ -75,6 +75,14 @@ tags:
解释: 该示例属于第三种情况，节点 p 不在节点 q 的子树中，反之亦然。我们可以移动节点 3 及其子树，使之成为节点 8 的子节点。
+示例 4：
+
+
+输入：root = [1,null,2,3,null,4], p = 1, q = 4
+输出：[4,null,1,null,2,3]
+解释：该示例属于第一种情况，因为节点 q 在节点 p 的子树中。断开节点 4 与其父节点，并将节点 1 及其子树移动，使其成为节点 4 的子节点。
+
+
提示:
diff --git a/solution/1500-1599/1516.Move Sub-Tree of N-Ary Tree/README_EN.md b/solution/1500-1599/1516.Move Sub-Tree of N-Ary Tree/README_EN.md
index e0bb9b5768ef2..d1141fca6d308 100644
--- a/solution/1500-1599/1516.Move Sub-Tree of N-Ary Tree/README_EN.md
+++ b/solution/1500-1599/1516.Move Sub-Tree of N-Ary Tree/README_EN.md
@@ -68,6 +68,14 @@ Notice that node 4 is the last child of node 1.
Explanation: This example follows case 3 because node p is not in the sub-tree of node q and vice-versa. We can move node 3 with its sub-tree and make it as node 8's child.
+Example 4:
+
+
+Input: root = [1,null,2,3,null,4], p = 1, q = 4
+Output: [4,null,1,null,2,3]
+Explanation: This example follows case 1 because node q is in the sub-tree of node p. Disconnect 4 with its parent and move node 1 with its sub-tree and make it as node 4's child.
+
+
Constraints:
diff --git a/solution/1500-1599/1516.Move Sub-Tree of N-Ary Tree/images/untitled-diagramdrawio.png b/solution/1500-1599/1516.Move Sub-Tree of N-Ary Tree/images/untitled-diagramdrawio.png
new file mode 100644
index 0000000000000..3daaaf9e87ae7
Binary files /dev/null and b/solution/1500-1599/1516.Move Sub-Tree of N-Ary Tree/images/untitled-diagramdrawio.png differ
diff --git a/solution/1500-1599/1517.Find Users With Valid E-Mails/README.md b/solution/1500-1599/1517.Find Users With Valid E-Mails/README.md
index e69eb35820536..8ca76e3ff3e2e 100644
--- a/solution/1500-1599/1517.Find Users With Valid E-Mails/README.md
+++ b/solution/1500-1599/1517.Find Users With Valid E-Mails/README.md
@@ -37,7 +37,7 @@ user_id 是该表的主键（具有唯一值的列）。
一个有效的电子邮件具有前缀名称和域，其中：
- - 前缀 名称是一个字符串，可以包含字母（大写或小写），数字，下划线
'_' ，点 '.' 和/或破折号 '-' 。前缀名称 必须 以字母开头。
+ - 前缀 名称是一个字符串，可以包含字母（大写或小写），数字，下划线
'_' ，点 '.' 和（或）破折号 '-' 。前缀名称 必须 以字母开头。
- 域 为
'@leetcode.com' 。
diff --git a/solution/1600-1699/1695.Maximum Erasure Value/README.md b/solution/1600-1699/1695.Maximum Erasure Value/README.md
index 890ed06b4617a..e3acd494c64a7 100644
--- a/solution/1600-1699/1695.Maximum Erasure Value/README.md
+++ b/solution/1600-1699/1695.Maximum Erasure Value/README.md
@@ -61,11 +61,11 @@ tags:
### 方法一：数组或哈希表 + 前缀和
-我们用数组或哈希表 $d$ 记录每个数字最后一次出现的位置，用 $s$ 记录前缀和，用 $j$ 记录当前不重复子数组的左端点。
+我们用数组或哈希表 $\text{d}$ 记录每个数字最后一次出现的位置，用前缀和数组 $\text{s}$ 记录从起点到当前位置的和。我们用变量 $j$ 记录当前不重复子数组的左端点。
-遍历数组，对于每个数字 $v$，如果 $d[v]$ 存在，那么我们更新 $j$ 为 $max(j, d[v])$，这样就保证了当前不重复子数组不包含 $v$，然后更新答案为 $max(ans, s[i] - s[j])$，最后更新 $d[v]$ 为 $i$。
+遍历数组，对于每个数字 $v$，如果 $\text{d}[v]$ 存在，那么我们更新 $j$ 为 $\max(j, \text{d}[v])$，这样就保证了当前不重复子数组不包含 $v$。然后我们更新答案为 $\max(\text{ans}, \text{s}[i] - \text{s}[j])$，最后更新 $\text{d}[v]$ 为 $i$。
-时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $nums$ 的长度。
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $\text{nums}$ 的长度。
@@ -74,7 +74,7 @@ tags:
```python
class Solution:
def maximumUniqueSubarray(self, nums: List[int]) -> int:
- d = defaultdict(int)
+ d = [0] * (max(nums) + 1)
s = list(accumulate(nums, initial=0))
ans = j = 0
for i, v in enumerate(nums, 1):
@@ -173,21 +173,48 @@ function maximumUniqueSubarray(nums: number[]): number {
}
```
+#### Rust
+
+```rust
+impl Solution {
+ pub fn maximum_unique_subarray(nums: Vec) -> i32 {
+ let m = *nums.iter().max().unwrap() as usize;
+ let mut d = vec![0; m + 1];
+ let n = nums.len();
+
+ let mut s = vec![0; n + 1];
+ for i in 0..n {
+ s[i + 1] = s[i] + nums[i];
+ }
+
+ let mut ans = 0;
+ let mut j = 0;
+ for (i, &v) in nums.iter().enumerate().map(|(i, v)| (i + 1, v)) {
+ j = j.max(d[v as usize]);
+ ans = ans.max(s[i] - s[j]);
+ d[v as usize] = i;
+ }
+
+ ans
+ }
+}
+```
+
-### 方法二：双指针
+### 方法二：双指针（滑动窗口）
-题目实际上是让我们找出一个最长的子数组，该子数组中所有元素都不相同。我们可以用两个指针 $i$ 和 $j$ 分别指向子数组的左右边界，初始时 $i = 0$, $j = 0$。另外，我们用一个哈希表 $vis$ 记录子数组中的元素。
+题目实际上是让我们找出一个最长的子数组，该子数组中所有元素都不相同。我们可以用两个指针 $i$ 和 $j$ 分别指向子数组的左右边界，初始时 $i = 0$, $j = 0$。另外，我们用一个哈希表 $\text{vis}$ 记录子数组中的元素。
-遍历数组，对于每个数字 $x$，如果 $x$ 在 $vis$ 中，那么我们不断地将 $nums[i]$ 从 $vis$ 中移除，直到 $x$ 不在 $vis$ 中为止。这样我们就找到了一个不包含重复元素的子数组。我们将 $x$ 加入 $vis$，并更新子数组的和 $s$，然后更新答案 $ans = \max(ans, s)$。
+遍历数组，对于每个数字 $x$，如果 $x$ 在 $\text{vis}$ 中，那么我们不断地将 $\text{nums}[i]$ 从 $\text{vis}$ 中移除，直到 $x$ 不在 $\text{vis}$ 中为止。这样我们就找到了一个不包含重复元素的子数组。我们将 $x$ 加入 $\text{vis}$，并更新子数组的和 $s$，然后更新答案 $\text{ans} = \max(\text{ans}, s)$。
遍历结束后，我们就可以得到最大的子数组和。
-时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $nums$ 的长度。
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $\text{nums}$ 的长度。
@@ -292,6 +319,33 @@ function maximumUniqueSubarray(nums: number[]): number {
}
```
+#### Rust
+
+```rust
+use std::collections::HashSet;
+
+impl Solution {
+ pub fn maximum_unique_subarray(nums: Vec) -> i32 {
+ let mut vis = HashSet::new();
+ let (mut ans, mut s, mut i) = (0, 0, 0);
+
+ for &x in &nums {
+ while vis.contains(&x) {
+ let y = nums[i];
+ s -= y;
+ vis.remove(&y);
+ i += 1;
+ }
+ vis.insert(x);
+ s += x;
+ ans = ans.max(s);
+ }
+
+ ans
+ }
+}
+```
+
diff --git a/solution/1600-1699/1695.Maximum Erasure Value/README_EN.md b/solution/1600-1699/1695.Maximum Erasure Value/README_EN.md
index 4a0e89c95882b..cc20b0f8b6cfe 100644
--- a/solution/1600-1699/1695.Maximum Erasure Value/README_EN.md
+++ b/solution/1600-1699/1695.Maximum Erasure Value/README_EN.md
@@ -59,11 +59,11 @@ tags:
### Solution 1: Array or Hash Table + Prefix Sum
-We use an array or hash table $d$ to record the last occurrence of each number, use $s$ to record the prefix sum, and use $j$ to record the left endpoint of the current non-repeating subarray.
+We use an array or hash table $\text{d}$ to record the last occurrence position of each number, and use a prefix sum array $\text{s}$ to record the sum from the starting point to the current position. We use a variable $j$ to record the left endpoint of the current non-repeating subarray.
-We traverse the array, for each number $v$, if $d[v]$ exists, then we update $j$ to $max(j, d[v])$, which ensures that the current non-repeating subarray does not contain $v$. Then we update the answer to $max(ans, s[i] - s[j])$, and finally update $d[v]$ to $i$.
+We iterate through the array. For each number $v$, if $\text{d}[v]$ exists, we update $j$ to $\max(j, \text{d}[v])$, which ensures that the current non-repeating subarray does not contain $v$. Then we update the answer to $\max(\text{ans}, \text{s}[i] - \text{s}[j])$, and finally update $\text{d}[v]$ to $i$.
-The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the array $nums$.
+The time complexity is $O(n)$, and the space complexity is $O(n)$, where $n$ is the length of the array $\text{nums}$.
@@ -72,7 +72,7 @@ The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is
```python
class Solution:
def maximumUniqueSubarray(self, nums: List[int]) -> int:
- d = defaultdict(int)
+ d = [0] * (max(nums) + 1)
s = list(accumulate(nums, initial=0))
ans = j = 0
for i, v in enumerate(nums, 1):
@@ -171,21 +171,48 @@ function maximumUniqueSubarray(nums: number[]): number {
}
```
+#### Rust
+
+```rust
+impl Solution {
+ pub fn maximum_unique_subarray(nums: Vec) -> i32 {
+ let m = *nums.iter().max().unwrap() as usize;
+ let mut d = vec![0; m + 1];
+ let n = nums.len();
+
+ let mut s = vec![0; n + 1];
+ for i in 0..n {
+ s[i + 1] = s[i] + nums[i];
+ }
+
+ let mut ans = 0;
+ let mut j = 0;
+ for (i, &v) in nums.iter().enumerate().map(|(i, v)| (i + 1, v)) {
+ j = j.max(d[v as usize]);
+ ans = ans.max(s[i] - s[j]);
+ d[v as usize] = i;
+ }
+
+ ans
+ }
+}
+```
+
-### Solution 2: Two Pointers
+### Solution 2: Two Pointers (Sliding Window)
-The problem is actually asking us to find the longest subarray in which all elements are distinct. We can use two pointers $i$ and $j$ to point to the left and right boundaries of the subarray, initially $i = 0$, $j = 0$. In addition, we use a hash table $vis$ to record the elements in the subarray.
+The problem is essentially asking us to find the longest subarray where all elements are distinct. We can use two pointers $i$ and $j$ to point to the left and right boundaries of the subarray, initially $i = 0$ and $j = 0$. Additionally, we use a hash table $\text{vis}$ to record the elements in the subarray.
-We traverse the array, for each number $x$, if $x$ is in $vis$, then we continuously remove $nums[i]$ from $vis$, until $x$ is not in $vis$. In this way, we find a subarray without duplicate elements. We add $x$ to $vis$, update the sum of the subarray $s$, and then update the answer $ans = \max(ans, s)$.
+We iterate through the array. For each number $x$, if $x$ is in $\text{vis}$, we continuously remove $\text{nums}[i]$ from $\text{vis}$ until $x$ is no longer in $\text{vis}$. This way, we find a subarray that contains no duplicate elements. We add $x$ to $\text{vis}$, update the subarray sum $s$, and then update the answer $\text{ans} = \max(\text{ans}, s)$.
-After the traversal, we can get the maximum sum of the subarray.
+After the iteration, we can get the maximum subarray sum.
-The time complexity is $O(n)$, and the space complexity is $O(n)$. Where $n$ is the length of the array $nums$.
+The time complexity is $O(n)$, and the space complexity is $O(n)$, where $n$ is the length of the array $\text{nums}$.
@@ -290,6 +317,33 @@ function maximumUniqueSubarray(nums: number[]): number {
}
```
+#### Rust
+
+```rust
+use std::collections::HashSet;
+
+impl Solution {
+ pub fn maximum_unique_subarray(nums: Vec) -> i32 {
+ let mut vis = HashSet::new();
+ let (mut ans, mut s, mut i) = (0, 0, 0);
+
+ for &x in &nums {
+ while vis.contains(&x) {
+ let y = nums[i];
+ s -= y;
+ vis.remove(&y);
+ i += 1;
+ }
+ vis.insert(x);
+ s += x;
+ ans = ans.max(s);
+ }
+
+ ans
+ }
+}
+```
+
diff --git a/solution/1600-1699/1695.Maximum Erasure Value/Solution.py b/solution/1600-1699/1695.Maximum Erasure Value/Solution.py
index 07b780f3444e4..068e35bfd907b 100644
--- a/solution/1600-1699/1695.Maximum Erasure Value/Solution.py
+++ b/solution/1600-1699/1695.Maximum Erasure Value/Solution.py
@@ -1,6 +1,6 @@
class Solution:
def maximumUniqueSubarray(self, nums: List[int]) -> int:
- d = defaultdict(int)
+ d = [0] * (max(nums) + 1)
s = list(accumulate(nums, initial=0))
ans = j = 0
for i, v in enumerate(nums, 1):
diff --git a/solution/1600-1699/1695.Maximum Erasure Value/Solution.rs b/solution/1600-1699/1695.Maximum Erasure Value/Solution.rs
new file mode 100644
index 0000000000000..f9212293a0775
--- /dev/null
+++ b/solution/1600-1699/1695.Maximum Erasure Value/Solution.rs
@@ -0,0 +1,22 @@
+impl Solution {
+ pub fn maximum_unique_subarray(nums: Vec) -> i32 {
+ let m = *nums.iter().max().unwrap() as usize;
+ let mut d = vec![0; m + 1];
+ let n = nums.len();
+
+ let mut s = vec![0; n + 1];
+ for i in 0..n {
+ s[i + 1] = s[i] + nums[i];
+ }
+
+ let mut ans = 0;
+ let mut j = 0;
+ for (i, &v) in nums.iter().enumerate().map(|(i, v)| (i + 1, v)) {
+ j = j.max(d[v as usize]);
+ ans = ans.max(s[i] - s[j]);
+ d[v as usize] = i;
+ }
+
+ ans
+ }
+}
diff --git a/solution/1600-1699/1695.Maximum Erasure Value/Solution2.rs b/solution/1600-1699/1695.Maximum Erasure Value/Solution2.rs
new file mode 100644
index 0000000000000..fb90a2d2bb733
--- /dev/null
+++ b/solution/1600-1699/1695.Maximum Erasure Value/Solution2.rs
@@ -0,0 +1,22 @@
+use std::collections::HashSet;
+
+impl Solution {
+ pub fn maximum_unique_subarray(nums: Vec) -> i32 {
+ let mut vis = HashSet::new();
+ let (mut ans, mut s, mut i) = (0, 0, 0);
+
+ for &x in &nums {
+ while vis.contains(&x) {
+ let y = nums[i];
+ s -= y;
+ vis.remove(&y);
+ i += 1;
+ }
+ vis.insert(x);
+ s += x;
+ ans = ans.max(s);
+ }
+
+ ans
+ }
+}
diff --git a/solution/1700-1799/1717.Maximum Score From Removing Substrings/README.md b/solution/1700-1799/1717.Maximum Score From Removing Substrings/README.md
index e399609fa2ebd..188d7f4e4bd69 100644
--- a/solution/1700-1799/1717.Maximum Score From Removing Substrings/README.md
+++ b/solution/1700-1799/1717.Maximum Score From Removing Substrings/README.md
@@ -88,9 +88,9 @@ tags:
- 如果 $c$ 是 "a"，由于要先删除 "ab"，因此此时我们不消除该字符，只增加 $\textit{cnt1}$；
- 如果 $c$ 是 "b"，如果此时 $\textit{cnt1} > 0$，我们可以消除一个 "ab"，并增加 $x$ 分，否则我们只能增加 $\textit{cnt2}$；
-- 如果 $c$ 是其他字符，那么对于该子字符串，我们剩下了一个 $\textit{cnt2}$ 个 "b" 和 $\textit{cnt1}$ 个 "a"，我们可以消除 $\min(\textit{cnt1}, \textit{cnt2})$ 个 "ab"，并增加 $y$ 分。
+- 如果 $c$ 是其他字符，那么对于该子字符串，我们剩下了 $\textit{cnt2}$ 个 "b" 和 $\textit{cnt1}$ 个 "a"，我们可以消除 $\min(\textit{cnt1}, \textit{cnt2})$ 个 "ba"，并增加若干个 $y$ 分。
-遍历结束后，我们还需要额外处理一下剩余的 "ab"，增加若干个 $y$ 分。
+遍历结束后，我们还需要额外处理一下剩余的 "ba"，增加若干个 $y$ 分。
时间复杂度 $O(n)$，其中 $n$ 为字符串 $s$ 的长度。空间复杂度 $O(1)$。
@@ -259,6 +259,44 @@ function maximumGain(s: string, x: number, y: number): number {
}
```
+#### Rust
+
+```rust
+impl Solution {
+ pub fn maximum_gain(s: String, mut x: i32, mut y: i32) -> i32 {
+ let (mut a, mut b) = ('a', 'b');
+ if x < y {
+ std::mem::swap(&mut x, &mut y);
+ std::mem::swap(&mut a, &mut b);
+ }
+
+ let mut ans = 0;
+ let mut cnt1 = 0;
+ let mut cnt2 = 0;
+
+ for c in s.chars() {
+ if c == a {
+ cnt1 += 1;
+ } else if c == b {
+ if cnt1 > 0 {
+ ans += x;
+ cnt1 -= 1;
+ } else {
+ cnt2 += 1;
+ }
+ } else {
+ ans += cnt1.min(cnt2) * y;
+ cnt1 = 0;
+ cnt2 = 0;
+ }
+ }
+
+ ans += cnt1.min(cnt2) * y;
+ ans
+ }
+}
+```
+
#### JavaScript
```js
@@ -291,81 +329,38 @@ function maximumGain(s, x, y) {
}
```
-
-
-
-
-
-
-### Solution 2: Greedy + Stack
-
-
-
-#### TypeScript
-
-```ts
-function maximumGain(s: string, x: number, y: number): number {
- const stk: string[] = [];
- const pairs: Record = { a: 'b', b: 'a' };
- const pair = x > y ? ['a', 'b'] : ['b', 'a'];
- let str = [...s];
- let ans = 0;
- let havePairs = true;
-
- while (havePairs) {
- for (const p of pair) {
- havePairs = true;
-
- for (const ch of str) {
- if (stk.at(-1) === p && ch === pairs[p]) {
- stk.pop();
- } else stk.push(ch);
- }
+#### C#
- if (str.length === stk.length) havePairs = false;
-
- const multiplier = p === 'a' ? x : y;
- ans += (multiplier * (str.length - stk.length)) / 2;
- str = [...stk];
- stk.length = 0;
+```cs
+public class Solution {
+ public int MaximumGain(string s, int x, int y) {
+ char a = 'a', b = 'b';
+ if (x < y) {
+ (x, y) = (y, x);
+ (a, b) = (b, a);
}
- }
-
- return ans;
-}
-```
-#### JavaeScript
-
-```js
-function maximumGain(s, x, y) {
- const stk = [];
- const pairs = { a: 'b', b: 'a' };
- const pair = x > y ? ['a', 'b'] : ['b', 'a'];
- let str = [...s];
- let ans = 0;
- let havePairs = true;
-
- while (havePairs) {
- for (const p of pair) {
- havePairs = true;
-
- for (const ch of str) {
- if (stk.at(-1) === p && ch === pairs[p]) {
- stk.pop();
- } else stk.push(ch);
+ int ans = 0, cnt1 = 0, cnt2 = 0;
+ foreach (char c in s) {
+ if (c == a) {
+ cnt1++;
+ } else if (c == b) {
+ if (cnt1 > 0) {
+ ans += x;
+ cnt1--;
+ } else {
+ cnt2++;
+ }
+ } else {
+ ans += Math.Min(cnt1, cnt2) * y;
+ cnt1 = 0;
+ cnt2 = 0;
}
-
- if (str.length === stk.length) havePairs = false;
-
- const multiplier = p === 'a' ? x : y;
- ans += (multiplier * (str.length - stk.length)) / 2;
- str = [...stk];
- stk.length = 0;
}
- }
- return ans;
+ ans += Math.Min(cnt1, cnt2) * y;
+ return ans;
+ }
}
```
diff --git a/solution/1700-1799/1717.Maximum Score From Removing Substrings/README_EN.md b/solution/1700-1799/1717.Maximum Score From Removing Substrings/README_EN.md
index cd7204fd75dcf..bad524814c1b2 100644
--- a/solution/1700-1799/1717.Maximum Score From Removing Substrings/README_EN.md
+++ b/solution/1700-1799/1717.Maximum Score From Removing Substrings/README_EN.md
@@ -76,23 +76,23 @@ Total score = 5 + 4 + 5 + 5 = 19.
### Solution 1: Greedy
-Let's assume that the score of the substring "ab" is always not lower than the score of the substring "ba". If not, we can swap "a" and "b", and simultaneously swap $x$ and $y$.
+We can assume that the score of substring "ab" is always no less than the score of substring "ba". If not, we can swap "a" and "b", and simultaneously swap $x$ and $y$.
-Next, we only need to consider the case where the string contains only "a" and "b". If the string contains other characters, we can treat them as a dividing point, splitting the string into several substrings that contain only "a" and "b", and then calculate the score for each substring separately.
+Next, we only need to consider the case where the string contains only "a" and "b". If the string contains other characters, we can treat them as split points, dividing the string into several substrings that contain only "a" and "b", and then calculate the score for each substring separately.
-We observe that, for a substring containing only "a" and "b", no matter what operations are taken, in the end, there will only be one type of character left, or an empty string. Since each operation will delete one "a" and one "b" simultaneously, the total number of operations is fixed. We can greedily delete "ab" first, then "ba", to ensure the maximum score.
+We observe that for a substring containing only "a" and "b", no matter what operations we take, we will eventually be left with only one type of character, or an empty string. Since each operation removes one "a" and one "b" simultaneously, the total number of operations is fixed. We can greedily remove "ab" first, then remove "ba", which ensures the maximum score.
-Therefore, we can use two variables $\textit{cnt1}$ and $\textit{cnt2}$ to record the number of "a" and "b", respectively. Then, we traverse the string, update $\textit{cnt1}$ and $\textit{cnt2}$ based on the current character, and calculate the score.
+Therefore, we can use two variables $\textit{cnt1}$ and $\textit{cnt2}$ to record the counts of "a" and "b" respectively, then traverse the string and update $\textit{cnt1}$ and $\textit{cnt2}$ according to different cases of the current character, while calculating the score.
-For the current character $c$:
+For the current character $c$ being traversed:
-- If $c$ is "a", since we need to delete "ab" first, we do not eliminate this character at this time, only increase $\textit{cnt1}$;
-- If $c$ is "b", if $\textit{cnt1} > 0$ at this time, we can eliminate an "ab" and add $x$ points; otherwise, we can only increase $\textit{cnt2}$;
-- If $c$ is another character, then for this substring, we are left with $\textit{cnt2}$ "b" and $\textit{cnt1}$ "a", we can eliminate $\min(\textit{cnt1}, \textit{cnt2})$ "ab" and add $y$ points.
+- If $c$ is "a", since we want to remove "ab" first, we don't eliminate this character at this time, only increment $\textit{cnt1}$;
+- If $c$ is "b", if $\textit{cnt1} > 0$ at this time, we can eliminate one "ab" and add $x$ points; otherwise, we can only increment $\textit{cnt2}$;
+- If $c$ is another character, then for this substring, we have $\textit{cnt2}$ "b"s and $\textit{cnt1}$ "a"s left. We can eliminate $\min(\textit{cnt1}, \textit{cnt2})$ "ba"s and add several $y$ points.
-After the traversal is finished, we also need to additionally handle the remaining "ab", adding several $y$ points.
+After traversal, we need to handle the remaining "ba"s and add several $y$ points.
-The time complexity is $O(n)$, where $n$ is the length of the string $s$. The space complexity is $O(1)$.
+The time complexity is $O(n)$, where $n$ is the length of string $s$. The space complexity is $O(1)$.
@@ -259,6 +259,44 @@ function maximumGain(s: string, x: number, y: number): number {
}
```
+#### Rust
+
+```rust
+impl Solution {
+ pub fn maximum_gain(s: String, mut x: i32, mut y: i32) -> i32 {
+ let (mut a, mut b) = ('a', 'b');
+ if x < y {
+ std::mem::swap(&mut x, &mut y);
+ std::mem::swap(&mut a, &mut b);
+ }
+
+ let mut ans = 0;
+ let mut cnt1 = 0;
+ let mut cnt2 = 0;
+
+ for c in s.chars() {
+ if c == a {
+ cnt1 += 1;
+ } else if c == b {
+ if cnt1 > 0 {
+ ans += x;
+ cnt1 -= 1;
+ } else {
+ cnt2 += 1;
+ }
+ } else {
+ ans += cnt1.min(cnt2) * y;
+ cnt1 = 0;
+ cnt2 = 0;
+ }
+ }
+
+ ans += cnt1.min(cnt2) * y;
+ ans
+ }
+}
+```
+
#### JavaScript
```js
@@ -291,81 +329,38 @@ function maximumGain(s, x, y) {
}
```
-
-
-
-
-
-
-### Solution 2: Greedy + Stack
-
-
-
-#### TypeScript
-
-```ts
-function maximumGain(s: string, x: number, y: number): number {
- const stk: string[] = [];
- const pairs: Record = { a: 'b', b: 'a' };
- const pair = x > y ? ['a', 'b'] : ['b', 'a'];
- let str = [...s];
- let ans = 0;
- let havePairs = true;
-
- while (havePairs) {
- for (const p of pair) {
- havePairs = true;
-
- for (const ch of str) {
- if (stk.at(-1) === p && ch === pairs[p]) {
- stk.pop();
- } else stk.push(ch);
- }
+#### C#
- if (str.length === stk.length) havePairs = false;
-
- const multiplier = p === 'a' ? x : y;
- ans += (multiplier * (str.length - stk.length)) / 2;
- str = [...stk];
- stk.length = 0;
+```cs
+public class Solution {
+ public int MaximumGain(string s, int x, int y) {
+ char a = 'a', b = 'b';
+ if (x < y) {
+ (x, y) = (y, x);
+ (a, b) = (b, a);
}
- }
-
- return ans;
-}
-```
-#### JavaeScript
-
-```js
-function maximumGain(s, x, y) {
- const stk = [];
- const pairs = { a: 'b', b: 'a' };
- const pair = x > y ? ['a', 'b'] : ['b', 'a'];
- let str = [...s];
- let ans = 0;
- let havePairs = true;
-
- while (havePairs) {
- for (const p of pair) {
- havePairs = true;
-
- for (const ch of str) {
- if (stk.at(-1) === p && ch === pairs[p]) {
- stk.pop();
- } else stk.push(ch);
+ int ans = 0, cnt1 = 0, cnt2 = 0;
+ foreach (char c in s) {
+ if (c == a) {
+ cnt1++;
+ } else if (c == b) {
+ if (cnt1 > 0) {
+ ans += x;
+ cnt1--;
+ } else {
+ cnt2++;
+ }
+ } else {
+ ans += Math.Min(cnt1, cnt2) * y;
+ cnt1 = 0;
+ cnt2 = 0;
}
-
- if (str.length === stk.length) havePairs = false;
-
- const multiplier = p === 'a' ? x : y;
- ans += (multiplier * (str.length - stk.length)) / 2;
- str = [...stk];
- stk.length = 0;
}
- }
- return ans;
+ ans += Math.Min(cnt1, cnt2) * y;
+ return ans;
+ }
}
```
diff --git a/solution/1700-1799/1717.Maximum Score From Removing Substrings/Solution.cs b/solution/1700-1799/1717.Maximum Score From Removing Substrings/Solution.cs
new file mode 100644
index 0000000000000..14b0ed2e9eed1
--- /dev/null
+++ b/solution/1700-1799/1717.Maximum Score From Removing Substrings/Solution.cs
@@ -0,0 +1,30 @@
+public class Solution {
+ public int MaximumGain(string s, int x, int y) {
+ char a = 'a', b = 'b';
+ if (x < y) {
+ (x, y) = (y, x);
+ (a, b) = (b, a);
+ }
+
+ int ans = 0, cnt1 = 0, cnt2 = 0;
+ foreach (char c in s) {
+ if (c == a) {
+ cnt1++;
+ } else if (c == b) {
+ if (cnt1 > 0) {
+ ans += x;
+ cnt1--;
+ } else {
+ cnt2++;
+ }
+ } else {
+ ans += Math.Min(cnt1, cnt2) * y;
+ cnt1 = 0;
+ cnt2 = 0;
+ }
+ }
+
+ ans += Math.Min(cnt1, cnt2) * y;
+ return ans;
+ }
+}
diff --git a/solution/1700-1799/1717.Maximum Score From Removing Substrings/Solution.rs b/solution/1700-1799/1717.Maximum Score From Removing Substrings/Solution.rs
new file mode 100644
index 0000000000000..b36a061bd38bc
--- /dev/null
+++ b/solution/1700-1799/1717.Maximum Score From Removing Substrings/Solution.rs
@@ -0,0 +1,33 @@
+impl Solution {
+ pub fn maximum_gain(s: String, mut x: i32, mut y: i32) -> i32 {
+ let (mut a, mut b) = ('a', 'b');
+ if x < y {
+ std::mem::swap(&mut x, &mut y);
+ std::mem::swap(&mut a, &mut b);
+ }
+
+ let mut ans = 0;
+ let mut cnt1 = 0;
+ let mut cnt2 = 0;
+
+ for c in s.chars() {
+ if c == a {
+ cnt1 += 1;
+ } else if c == b {
+ if cnt1 > 0 {
+ ans += x;
+ cnt1 -= 1;
+ } else {
+ cnt2 += 1;
+ }
+ } else {
+ ans += cnt1.min(cnt2) * y;
+ cnt1 = 0;
+ cnt2 = 0;
+ }
+ }
+
+ ans += cnt1.min(cnt2) * y;
+ ans
+ }
+}
diff --git a/solution/1700-1799/1717.Maximum Score From Removing Substrings/Solution2.js b/solution/1700-1799/1717.Maximum Score From Removing Substrings/Solution2.js
deleted file mode 100644
index 52b060f133f78..0000000000000
--- a/solution/1700-1799/1717.Maximum Score From Removing Substrings/Solution2.js
+++ /dev/null
@@ -1,29 +0,0 @@
-function maximumGain(s, x, y) {
- const stk = [];
- const pairs = { a: 'b', b: 'a' };
- const pair = x > y ? ['a', 'b'] : ['b', 'a'];
- let str = [...s];
- let ans = 0;
- let havePairs = true;
-
- while (havePairs) {
- for (const p of pair) {
- havePairs = true;
-
- for (const ch of str) {
- if (stk.at(-1) === p && ch === pairs[p]) {
- stk.pop();
- } else stk.push(ch);
- }
-
- if (str.length === stk.length) havePairs = false;
-
- const multiplier = p === 'a' ? x : y;
- ans += (multiplier * (str.length - stk.length)) / 2;
- str = [...stk];
- stk.length = 0;
- }
- }
-
- return ans;
-}
diff --git a/solution/1700-1799/1717.Maximum Score From Removing Substrings/Solution2.ts b/solution/1700-1799/1717.Maximum Score From Removing Substrings/Solution2.ts
deleted file mode 100644
index f4ed700d88a27..0000000000000
--- a/solution/1700-1799/1717.Maximum Score From Removing Substrings/Solution2.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-function maximumGain(s: string, x: number, y: number): number {
- const stk: string[] = [];
- const pairs: Record = { a: 'b', b: 'a' };
- const pair = x > y ? ['a', 'b'] : ['b', 'a'];
- let str = [...s];
- let ans = 0;
- let havePairs = true;
-
- while (havePairs) {
- for (const p of pair) {
- havePairs = true;
-
- for (const ch of str) {
- if (stk.at(-1) === p && ch === pairs[p]) {
- stk.pop();
- } else stk.push(ch);
- }
-
- if (str.length === stk.length) havePairs = false;
-
- const multiplier = p === 'a' ? x : y;
- ans += (multiplier * (str.length - stk.length)) / 2;
- str = [...stk];
- stk.length = 0;
- }
- }
-
- return ans;
-}
diff --git a/solution/1700-1799/1752.Check if Array Is Sorted and Rotated/README.md b/solution/1700-1799/1752.Check if Array Is Sorted and Rotated/README.md
index c45eecbc8686b..35de4c68d1b42 100644
--- a/solution/1700-1799/1752.Check if Array Is Sorted and Rotated/README.md
+++ b/solution/1700-1799/1752.Check if Array Is Sorted and Rotated/README.md
@@ -34,7 +34,7 @@ tags:
输入：nums = [3,4,5,1,2]
输出：true
解释：[1,2,3,4,5] 为有序的源数组。
-可以轮转 x = 3 个位置，使新数组从值为 3 的元素开始：[3,4,5,1,2] 。
+可以轮转 x = 2 个位置，使新数组从值为 3 的元素开始：[3,4,5,1,2] 。
示例 2：
diff --git a/solution/1700-1799/1752.Check if Array Is Sorted and Rotated/README_EN.md b/solution/1700-1799/1752.Check if Array Is Sorted and Rotated/README_EN.md
index a9302e2480207..c4aaccde44fc3 100644
--- a/solution/1700-1799/1752.Check if Array Is Sorted and Rotated/README_EN.md
+++ b/solution/1700-1799/1752.Check if Array Is Sorted and Rotated/README_EN.md
@@ -31,7 +31,7 @@ tags:
Input: nums = [3,4,5,1,2]
Output: true
Explanation: [1,2,3,4,5] is the original sorted array.
-You can rotate the array by x = 3 positions to begin on the element of value 3: [3,4,5,1,2].
+You can rotate the array by x = 2 positions to begin on the element of value 3: [3,4,5,1,2].
Example 2:
@@ -51,24 +51,6 @@ You can rotate the array by x = 3 positions to begin on the element of value 3:
You can rotate the array by x = 0 positions (i.e. no rotation) to make nums.
-
-
Constraints:
diff --git a/solution/1700-1799/1761.Minimum Degree of a Connected Trio in a Graph/README.md b/solution/1700-1799/1761.Minimum Degree of a Connected Trio in a Graph/README.md
index 90006eafe2d23..46700b4c52b25 100644
--- a/solution/1700-1799/1761.Minimum Degree of a Connected Trio in a Graph/README.md
+++ b/solution/1700-1799/1761.Minimum Degree of a Connected Trio in a Graph/README.md
@@ -6,6 +6,7 @@ rating: 2005
source: 第 228 场周赛 Q4
tags:
- 图
+ - 枚举
---
diff --git a/solution/1700-1799/1761.Minimum Degree of a Connected Trio in a Graph/README_EN.md b/solution/1700-1799/1761.Minimum Degree of a Connected Trio in a Graph/README_EN.md
index 5fef7b1a02c31..6b78026063035 100644
--- a/solution/1700-1799/1761.Minimum Degree of a Connected Trio in a Graph/README_EN.md
+++ b/solution/1700-1799/1761.Minimum Degree of a Connected Trio in a Graph/README_EN.md
@@ -6,6 +6,7 @@ rating: 2005
source: Weekly Contest 228 Q4
tags:
- Graph
+ - Enumeration
---
diff --git a/solution/1700-1799/1782.Count Pairs Of Nodes/README.md b/solution/1700-1799/1782.Count Pairs Of Nodes/README.md
index 147e25290a894..10d3849c230d2 100644
--- a/solution/1700-1799/1782.Count Pairs Of Nodes/README.md
+++ b/solution/1700-1799/1782.Count Pairs Of Nodes/README.md
@@ -7,8 +7,10 @@ source: 第 47 场双周赛 Q4
tags:
- 图
- 数组
+ - 哈希表
- 双指针
- 二分查找
+ - 计数
- 排序
---
diff --git a/solution/1700-1799/1782.Count Pairs Of Nodes/README_EN.md b/solution/1700-1799/1782.Count Pairs Of Nodes/README_EN.md
index 10717cdd494c1..27fce30218815 100644
--- a/solution/1700-1799/1782.Count Pairs Of Nodes/README_EN.md
+++ b/solution/1700-1799/1782.Count Pairs Of Nodes/README_EN.md
@@ -7,8 +7,10 @@ source: Biweekly Contest 47 Q4
tags:
- Graph
- Array
+ - Hash Table
- Two Pointers
- Binary Search
+ - Counting
- Sorting
---
diff --git a/solution/1800-1899/1858.Longest Word With All Prefixes/README.md b/solution/1800-1899/1858.Longest Word With All Prefixes/README.md
index 98319b2b037cc..ac042587d5839 100644
--- a/solution/1800-1899/1858.Longest Word With All Prefixes/README.md
+++ b/solution/1800-1899/1858.Longest Word With All Prefixes/README.md
@@ -5,6 +5,8 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/1800-1899/1858.Lo
tags:
- 深度优先搜索
- 字典树
+ - 数组
+ - 字符串
---
diff --git a/solution/1800-1899/1858.Longest Word With All Prefixes/README_EN.md b/solution/1800-1899/1858.Longest Word With All Prefixes/README_EN.md
index c9983247f32f8..0ebd12e11de1a 100644
--- a/solution/1800-1899/1858.Longest Word With All Prefixes/README_EN.md
+++ b/solution/1800-1899/1858.Longest Word With All Prefixes/README_EN.md
@@ -5,6 +5,8 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/1800-1899/1858.Lo
tags:
- Depth-First Search
- Trie
+ - Array
+ - String
---
diff --git a/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/README.md b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/README.md
index 6e138b23b3d9f..afaa23d0616a1 100644
--- a/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/README.md
+++ b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/README.md
@@ -82,41 +82,341 @@ tags:
-### 方法一
+### 方法一：记忆化搜索 + 二进制枚举
+
+我们定义一个函数 $\text{dfs}(l, r, n)$，表示在当前回合中，编号为 $l$ 和 $r$ 的运动员在 $n$ 名运动员中比拼的最早和最晚回合数。
+
+函数 $\text{dfs}(l, r, n)$ 的执行逻辑如下：
+
+1. 如果 $l + r = n - 1$，说明两名运动员在当前回合中比拼，返回 $[1, 1]$。
+2. 如果 $f[l][r][n] \neq 0$，说明之前已经计算过这个状态，直接返回结果。
+3. 初始化最早回合数为正无穷大，最晚回合数为负无穷大。
+4. 计算当前回合中前半部分的运动员数目 $m = n / 2$。
+5. 枚举前半部分的所有可能的胜者组合（使用二进制枚举），对于每一种组合：
+ - 根据当前组合确定哪些运动员获胜。
+ - 确定当前回合中编号为 $l$ 和 $r$ 的运动员在当前回合中的位置。
+ - 统计当前回合中编号为 $l$ 和 $r$ 的运动员在剩余运动员中的位置，记为 $a$ 和 $b$，以及剩余运动员的总数 $c$。
+ - 递归调用 $\text{dfs}(a, b, c)$，获取当前状态的最早和最晚回合数。
+ - 更新最早回合数和最晚回合数。
+6. 将计算结果存储在 $f[l][r][n]$ 中，并返回最早和最晚回合数。
+
+答案为 $\text{dfs}(\text{firstPlayer} - 1, \text{secondPlayer} - 1, n)$。
#### Python3
```python
+@cache
+def dfs(l: int, r: int, n: int):
+ if l + r == n - 1:
+ return [1, 1]
+ res = [inf, -inf]
+ m = n >> 1
+ for i in range(1 << m):
+ win = [False] * n
+ for j in range(m):
+ if i >> j & 1:
+ win[j] = True
+ else:
+ win[n - 1 - j] = True
+ if n & 1:
+ win[m] = True
+ win[n - 1 - l] = win[n - 1 - r] = False
+ win[l] = win[r] = True
+ a = b = c = 0
+ for j in range(n):
+ if j == l:
+ a = c
+ if j == r:
+ b = c
+ if win[j]:
+ c += 1
+ x, y = dfs(a, b, c)
+ res[0] = min(res[0], x + 1)
+ res[1] = max(res[1], y + 1)
+ return res
+
+
class Solution:
def earliestAndLatest(
self, n: int, firstPlayer: int, secondPlayer: int
) -> List[int]:
- # dp[i][j][k] := (earliest, latest) pair w/ firstPlayer is i-th player from
- # Front, secondPlayer is j-th player from end, and there're k people
- @functools.lru_cache(None)
- def dp(l: int, r: int, k: int) -> List[int]:
- if l == r:
- return [1, 1]
- if l > r:
- return dp(r, l, k)
-
- a = math.inf
- b = -math.inf
-
- # Enumerate all possible positions
- for i in range(1, l + 1):
- for j in range(l - i + 1, r - i + 1):
- if not l + r - k // 2 <= i + j <= (k + 1) // 2:
- continue
- x, y = dp(i, j, (k + 1) // 2)
- a = min(a, x + 1)
- b = max(b, y + 1)
-
- return [a, b]
-
- return dp(firstPlayer, n - secondPlayer + 1, n)
+ return dfs(firstPlayer - 1, secondPlayer - 1, n)
+```
+
+#### Java
+
+```java
+class Solution {
+ static int[][][] f = new int[30][30][31];
+
+ public int[] earliestAndLatest(int n, int firstPlayer, int secondPlayer) {
+ return dfs(firstPlayer - 1, secondPlayer - 1, n);
+ }
+
+ private int[] dfs(int l, int r, int n) {
+ if (f[l][r][n] != 0) {
+ return decode(f[l][r][n]);
+ }
+ if (l + r == n - 1) {
+ f[l][r][n] = encode(1, 1);
+ return new int[] {1, 1};
+ }
+ int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;
+ int m = n >> 1;
+ for (int i = 0; i < (1 << m); i++) {
+ boolean[] win = new boolean[n];
+ for (int j = 0; j < m; j++) {
+ if (((i >> j) & 1) == 1) {
+ win[j] = true;
+ } else {
+ win[n - 1 - j] = true;
+ }
+ }
+ if ((n & 1) == 1) {
+ win[m] = true;
+ }
+ win[n - 1 - l] = win[n - 1 - r] = false;
+ win[l] = win[r] = true;
+ int a = 0, b = 0, c = 0;
+ for (int j = 0; j < n; j++) {
+ if (j == l) {
+ a = c;
+ }
+ if (j == r) {
+ b = c;
+ }
+ if (win[j]) {
+ c++;
+ }
+ }
+ int[] t = dfs(a, b, c);
+ min = Math.min(min, t[0] + 1);
+ max = Math.max(max, t[1] + 1);
+ }
+ f[l][r][n] = encode(min, max);
+ return new int[] {min, max};
+ }
+
+ private int encode(int x, int y) {
+ return (x << 8) | y;
+ }
+
+ private int[] decode(int val) {
+ return new int[] {val >> 8, val & 255};
+ }
+}
+```
+
+#### C++
+
+```cpp
+int f[30][30][31];
+class Solution {
+public:
+ vector earliestAndLatest(int n, int firstPlayer, int secondPlayer) {
+ return dfs(firstPlayer - 1, secondPlayer - 1, n);
+ }
+
+private:
+ vector dfs(int l, int r, int n) {
+ if (f[l][r][n] != 0) {
+ return decode(f[l][r][n]);
+ }
+ if (l + r == n - 1) {
+ f[l][r][n] = encode(1, 1);
+ return {1, 1};
+ }
+
+ int min = INT_MAX, max = INT_MIN;
+ int m = n >> 1;
+
+ for (int i = 0; i < (1 << m); i++) {
+ vector win(n, false);
+ for (int j = 0; j < m; j++) {
+ if ((i >> j) & 1) {
+ win[j] = true;
+ } else {
+ win[n - 1 - j] = true;
+ }
+ }
+ if (n & 1) {
+ win[m] = true;
+ }
+
+ win[n - 1 - l] = false;
+ win[n - 1 - r] = false;
+ win[l] = true;
+ win[r] = true;
+
+ int a = 0, b = 0, c = 0;
+ for (int j = 0; j < n; j++) {
+ if (j == l) a = c;
+ if (j == r) b = c;
+ if (win[j]) c++;
+ }
+
+ vector t = dfs(a, b, c);
+ min = std::min(min, t[0] + 1);
+ max = std::max(max, t[1] + 1);
+ }
+
+ f[l][r][n] = encode(min, max);
+ return {min, max};
+ }
+
+ int encode(int x, int y) {
+ return (x << 8) | y;
+ }
+
+ vector decode(int val) {
+ return {val >> 8, val & 255};
+ }
+};
+```
+
+#### Go
+
+```go
+var f [30][30][31]int
+
+func earliestAndLatest(n int, firstPlayer int, secondPlayer int) []int {
+ return dfs(firstPlayer-1, secondPlayer-1, n)
+}
+
+func dfs(l, r, n int) []int {
+ if f[l][r][n] != 0 {
+ return decode(f[l][r][n])
+ }
+ if l+r == n-1 {
+ f[l][r][n] = encode(1, 1)
+ return []int{1, 1}
+ }
+
+ min, max := 1<<30, -1<<31
+ m := n >> 1
+
+ for i := 0; i < (1 << m); i++ {
+ win := make([]bool, n)
+ for j := 0; j < m; j++ {
+ if (i>>j)&1 == 1 {
+ win[j] = true
+ } else {
+ win[n-1-j] = true
+ }
+ }
+ if n&1 == 1 {
+ win[m] = true
+ }
+ win[n-1-l] = false
+ win[n-1-r] = false
+ win[l] = true
+ win[r] = true
+
+ a, b, c := 0, 0, 0
+ for j := 0; j < n; j++ {
+ if j == l {
+ a = c
+ }
+ if j == r {
+ b = c
+ }
+ if win[j] {
+ c++
+ }
+ }
+
+ t := dfs(a, b, c)
+ if t[0]+1 < min {
+ min = t[0] + 1
+ }
+ if t[1]+1 > max {
+ max = t[1] + 1
+ }
+ }
+
+ f[l][r][n] = encode(min, max)
+ return []int{min, max}
+}
+
+func encode(x, y int) int {
+ return (x << 8) | y
+}
+
+func decode(val int) []int {
+ return []int{val >> 8, val & 255}
+}
+```
+
+#### TypeScript
+
+```ts
+function earliestAndLatest(n: number, firstPlayer: number, secondPlayer: number): number[] {
+ return dfs(firstPlayer - 1, secondPlayer - 1, n);
+}
+
+const f: number[][][] = Array.from({ length: 30 }, () =>
+ Array.from({ length: 30 }, () => Array(31).fill(0)),
+);
+
+function dfs(l: number, r: number, n: number): number[] {
+ if (f[l][r][n] !== 0) {
+ return decode(f[l][r][n]);
+ }
+ if (l + r === n - 1) {
+ f[l][r][n] = encode(1, 1);
+ return [1, 1];
+ }
+
+ let min = Number.MAX_SAFE_INTEGER;
+ let max = Number.MIN_SAFE_INTEGER;
+ const m = n >> 1;
+
+ for (let i = 0; i < 1 << m; i++) {
+ const win: boolean[] = Array(n).fill(false);
+ for (let j = 0; j < m; j++) {
+ if ((i >> j) & 1) {
+ win[j] = true;
+ } else {
+ win[n - 1 - j] = true;
+ }
+ }
+
+ if (n & 1) {
+ win[m] = true;
+ }
+
+ win[n - 1 - l] = false;
+ win[n - 1 - r] = false;
+ win[l] = true;
+ win[r] = true;
+
+ let a = 0,
+ b = 0,
+ c = 0;
+ for (let j = 0; j < n; j++) {
+ if (j === l) a = c;
+ if (j === r) b = c;
+ if (win[j]) c++;
+ }
+
+ const t = dfs(a, b, c);
+ min = Math.min(min, t[0] + 1);
+ max = Math.max(max, t[1] + 1);
+ }
+
+ f[l][r][n] = encode(min, max);
+ return [min, max];
+}
+
+function encode(x: number, y: number): number {
+ return (x << 8) | y;
+}
+
+function decode(val: number): number[] {
+ return [val >> 8, val & 255];
+}
```
diff --git a/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/README_EN.md b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/README_EN.md
index e53be4a5412c8..a1b7924f02ebe 100644
--- a/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/README_EN.md
+++ b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/README_EN.md
@@ -82,41 +82,341 @@ There is no way to make them compete in any other round.
-### Solution 1
+### Solution 1: Memoization + Binary Enumeration
+
+We define a function $\text{dfs}(l, r, n)$, which represents the earliest and latest rounds where players numbered $l$ and $r$ compete among $n$ players in the current round.
+
+The execution logic of function $\text{dfs}(l, r, n)$ is as follows:
+
+1. If $l + r = n - 1$, it means the two players compete in the current round, return $[1, 1]$.
+2. If $f[l][r][n] \neq 0$, it means this state has been calculated before, directly return the result.
+3. Initialize the earliest round number as positive infinity and the latest round number as negative infinity.
+4. Calculate the number of players in the first half of the current round $m = n / 2$.
+5. Enumerate all possible winner combinations of the first half (using binary enumeration), for each combination:
+ - Determine which players win based on the current combination.
+ - Determine the positions of players numbered $l$ and $r$ in the current round.
+ - Count the positions of players numbered $l$ and $r$ among the remaining players, denoted as $a$ and $b$, and the total number of remaining players $c$.
+ - Recursively call $\text{dfs}(a, b, c)$ to get the earliest and latest round numbers for the current state.
+ - Update the earliest and latest round numbers.
+6. Store the calculation result in $f[l][r][n]$ and return the earliest and latest round numbers.
+
+The answer is $\text{dfs}(\text{firstPlayer} - 1, \text{secondPlayer} - 1, n)$.
#### Python3
```python
+@cache
+def dfs(l: int, r: int, n: int):
+ if l + r == n - 1:
+ return [1, 1]
+ res = [inf, -inf]
+ m = n >> 1
+ for i in range(1 << m):
+ win = [False] * n
+ for j in range(m):
+ if i >> j & 1:
+ win[j] = True
+ else:
+ win[n - 1 - j] = True
+ if n & 1:
+ win[m] = True
+ win[n - 1 - l] = win[n - 1 - r] = False
+ win[l] = win[r] = True
+ a = b = c = 0
+ for j in range(n):
+ if j == l:
+ a = c
+ if j == r:
+ b = c
+ if win[j]:
+ c += 1
+ x, y = dfs(a, b, c)
+ res[0] = min(res[0], x + 1)
+ res[1] = max(res[1], y + 1)
+ return res
+
+
class Solution:
def earliestAndLatest(
self, n: int, firstPlayer: int, secondPlayer: int
) -> List[int]:
- # dp[i][j][k] := (earliest, latest) pair w/ firstPlayer is i-th player from
- # Front, secondPlayer is j-th player from end, and there're k people
- @functools.lru_cache(None)
- def dp(l: int, r: int, k: int) -> List[int]:
- if l == r:
- return [1, 1]
- if l > r:
- return dp(r, l, k)
-
- a = math.inf
- b = -math.inf
-
- # Enumerate all possible positions
- for i in range(1, l + 1):
- for j in range(l - i + 1, r - i + 1):
- if not l + r - k // 2 <= i + j <= (k + 1) // 2:
- continue
- x, y = dp(i, j, (k + 1) // 2)
- a = min(a, x + 1)
- b = max(b, y + 1)
-
- return [a, b]
-
- return dp(firstPlayer, n - secondPlayer + 1, n)
+ return dfs(firstPlayer - 1, secondPlayer - 1, n)
+```
+
+#### Java
+
+```java
+class Solution {
+ static int[][][] f = new int[30][30][31];
+
+ public int[] earliestAndLatest(int n, int firstPlayer, int secondPlayer) {
+ return dfs(firstPlayer - 1, secondPlayer - 1, n);
+ }
+
+ private int[] dfs(int l, int r, int n) {
+ if (f[l][r][n] != 0) {
+ return decode(f[l][r][n]);
+ }
+ if (l + r == n - 1) {
+ f[l][r][n] = encode(1, 1);
+ return new int[] {1, 1};
+ }
+ int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;
+ int m = n >> 1;
+ for (int i = 0; i < (1 << m); i++) {
+ boolean[] win = new boolean[n];
+ for (int j = 0; j < m; j++) {
+ if (((i >> j) & 1) == 1) {
+ win[j] = true;
+ } else {
+ win[n - 1 - j] = true;
+ }
+ }
+ if ((n & 1) == 1) {
+ win[m] = true;
+ }
+ win[n - 1 - l] = win[n - 1 - r] = false;
+ win[l] = win[r] = true;
+ int a = 0, b = 0, c = 0;
+ for (int j = 0; j < n; j++) {
+ if (j == l) {
+ a = c;
+ }
+ if (j == r) {
+ b = c;
+ }
+ if (win[j]) {
+ c++;
+ }
+ }
+ int[] t = dfs(a, b, c);
+ min = Math.min(min, t[0] + 1);
+ max = Math.max(max, t[1] + 1);
+ }
+ f[l][r][n] = encode(min, max);
+ return new int[] {min, max};
+ }
+
+ private int encode(int x, int y) {
+ return (x << 8) | y;
+ }
+
+ private int[] decode(int val) {
+ return new int[] {val >> 8, val & 255};
+ }
+}
+```
+
+#### C++
+
+```cpp
+int f[30][30][31];
+class Solution {
+public:
+ vector earliestAndLatest(int n, int firstPlayer, int secondPlayer) {
+ return dfs(firstPlayer - 1, secondPlayer - 1, n);
+ }
+
+private:
+ vector dfs(int l, int r, int n) {
+ if (f[l][r][n] != 0) {
+ return decode(f[l][r][n]);
+ }
+ if (l + r == n - 1) {
+ f[l][r][n] = encode(1, 1);
+ return {1, 1};
+ }
+
+ int min = INT_MAX, max = INT_MIN;
+ int m = n >> 1;
+
+ for (int i = 0; i < (1 << m); i++) {
+ vector win(n, false);
+ for (int j = 0; j < m; j++) {
+ if ((i >> j) & 1) {
+ win[j] = true;
+ } else {
+ win[n - 1 - j] = true;
+ }
+ }
+ if (n & 1) {
+ win[m] = true;
+ }
+
+ win[n - 1 - l] = false;
+ win[n - 1 - r] = false;
+ win[l] = true;
+ win[r] = true;
+
+ int a = 0, b = 0, c = 0;
+ for (int j = 0; j < n; j++) {
+ if (j == l) a = c;
+ if (j == r) b = c;
+ if (win[j]) c++;
+ }
+
+ vector t = dfs(a, b, c);
+ min = std::min(min, t[0] + 1);
+ max = std::max(max, t[1] + 1);
+ }
+
+ f[l][r][n] = encode(min, max);
+ return {min, max};
+ }
+
+ int encode(int x, int y) {
+ return (x << 8) | y;
+ }
+
+ vector decode(int val) {
+ return {val >> 8, val & 255};
+ }
+};
+```
+
+#### Go
+
+```go
+var f [30][30][31]int
+
+func earliestAndLatest(n int, firstPlayer int, secondPlayer int) []int {
+ return dfs(firstPlayer-1, secondPlayer-1, n)
+}
+
+func dfs(l, r, n int) []int {
+ if f[l][r][n] != 0 {
+ return decode(f[l][r][n])
+ }
+ if l+r == n-1 {
+ f[l][r][n] = encode(1, 1)
+ return []int{1, 1}
+ }
+
+ min, max := 1<<30, -1<<31
+ m := n >> 1
+
+ for i := 0; i < (1 << m); i++ {
+ win := make([]bool, n)
+ for j := 0; j < m; j++ {
+ if (i>>j)&1 == 1 {
+ win[j] = true
+ } else {
+ win[n-1-j] = true
+ }
+ }
+ if n&1 == 1 {
+ win[m] = true
+ }
+ win[n-1-l] = false
+ win[n-1-r] = false
+ win[l] = true
+ win[r] = true
+
+ a, b, c := 0, 0, 0
+ for j := 0; j < n; j++ {
+ if j == l {
+ a = c
+ }
+ if j == r {
+ b = c
+ }
+ if win[j] {
+ c++
+ }
+ }
+
+ t := dfs(a, b, c)
+ if t[0]+1 < min {
+ min = t[0] + 1
+ }
+ if t[1]+1 > max {
+ max = t[1] + 1
+ }
+ }
+
+ f[l][r][n] = encode(min, max)
+ return []int{min, max}
+}
+
+func encode(x, y int) int {
+ return (x << 8) | y
+}
+
+func decode(val int) []int {
+ return []int{val >> 8, val & 255}
+}
+```
+
+#### TypeScript
+
+```ts
+function earliestAndLatest(n: number, firstPlayer: number, secondPlayer: number): number[] {
+ return dfs(firstPlayer - 1, secondPlayer - 1, n);
+}
+
+const f: number[][][] = Array.from({ length: 30 }, () =>
+ Array.from({ length: 30 }, () => Array(31).fill(0)),
+);
+
+function dfs(l: number, r: number, n: number): number[] {
+ if (f[l][r][n] !== 0) {
+ return decode(f[l][r][n]);
+ }
+ if (l + r === n - 1) {
+ f[l][r][n] = encode(1, 1);
+ return [1, 1];
+ }
+
+ let min = Number.MAX_SAFE_INTEGER;
+ let max = Number.MIN_SAFE_INTEGER;
+ const m = n >> 1;
+
+ for (let i = 0; i < 1 << m; i++) {
+ const win: boolean[] = Array(n).fill(false);
+ for (let j = 0; j < m; j++) {
+ if ((i >> j) & 1) {
+ win[j] = true;
+ } else {
+ win[n - 1 - j] = true;
+ }
+ }
+
+ if (n & 1) {
+ win[m] = true;
+ }
+
+ win[n - 1 - l] = false;
+ win[n - 1 - r] = false;
+ win[l] = true;
+ win[r] = true;
+
+ let a = 0,
+ b = 0,
+ c = 0;
+ for (let j = 0; j < n; j++) {
+ if (j === l) a = c;
+ if (j === r) b = c;
+ if (win[j]) c++;
+ }
+
+ const t = dfs(a, b, c);
+ min = Math.min(min, t[0] + 1);
+ max = Math.max(max, t[1] + 1);
+ }
+
+ f[l][r][n] = encode(min, max);
+ return [min, max];
+}
+
+function encode(x: number, y: number): number {
+ return (x << 8) | y;
+}
+
+function decode(val: number): number[] {
+ return [val >> 8, val & 255];
+}
```
diff --git a/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.cpp b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.cpp
new file mode 100644
index 0000000000000..d274dc8ce825a
--- /dev/null
+++ b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.cpp
@@ -0,0 +1,62 @@
+int f[30][30][31];
+class Solution {
+public:
+ vector earliestAndLatest(int n, int firstPlayer, int secondPlayer) {
+ return dfs(firstPlayer - 1, secondPlayer - 1, n);
+ }
+
+private:
+ vector dfs(int l, int r, int n) {
+ if (f[l][r][n] != 0) {
+ return decode(f[l][r][n]);
+ }
+ if (l + r == n - 1) {
+ f[l][r][n] = encode(1, 1);
+ return {1, 1};
+ }
+
+ int min = INT_MAX, max = INT_MIN;
+ int m = n >> 1;
+
+ for (int i = 0; i < (1 << m); i++) {
+ vector win(n, false);
+ for (int j = 0; j < m; j++) {
+ if ((i >> j) & 1) {
+ win[j] = true;
+ } else {
+ win[n - 1 - j] = true;
+ }
+ }
+ if (n & 1) {
+ win[m] = true;
+ }
+
+ win[n - 1 - l] = false;
+ win[n - 1 - r] = false;
+ win[l] = true;
+ win[r] = true;
+
+ int a = 0, b = 0, c = 0;
+ for (int j = 0; j < n; j++) {
+ if (j == l) a = c;
+ if (j == r) b = c;
+ if (win[j]) c++;
+ }
+
+ vector t = dfs(a, b, c);
+ min = std::min(min, t[0] + 1);
+ max = std::max(max, t[1] + 1);
+ }
+
+ f[l][r][n] = encode(min, max);
+ return {min, max};
+ }
+
+ int encode(int x, int y) {
+ return (x << 8) | y;
+ }
+
+ vector decode(int val) {
+ return {val >> 8, val & 255};
+ }
+};
\ No newline at end of file
diff --git a/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.go b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.go
new file mode 100644
index 0000000000000..c7c4473015c3c
--- /dev/null
+++ b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.go
@@ -0,0 +1,68 @@
+var f [30][30][31]int
+
+func earliestAndLatest(n int, firstPlayer int, secondPlayer int) []int {
+ return dfs(firstPlayer-1, secondPlayer-1, n)
+}
+
+func dfs(l, r, n int) []int {
+ if f[l][r][n] != 0 {
+ return decode(f[l][r][n])
+ }
+ if l+r == n-1 {
+ f[l][r][n] = encode(1, 1)
+ return []int{1, 1}
+ }
+
+ min, max := 1<<30, -1<<31
+ m := n >> 1
+
+ for i := 0; i < (1 << m); i++ {
+ win := make([]bool, n)
+ for j := 0; j < m; j++ {
+ if (i>>j)&1 == 1 {
+ win[j] = true
+ } else {
+ win[n-1-j] = true
+ }
+ }
+ if n&1 == 1 {
+ win[m] = true
+ }
+ win[n-1-l] = false
+ win[n-1-r] = false
+ win[l] = true
+ win[r] = true
+
+ a, b, c := 0, 0, 0
+ for j := 0; j < n; j++ {
+ if j == l {
+ a = c
+ }
+ if j == r {
+ b = c
+ }
+ if win[j] {
+ c++
+ }
+ }
+
+ t := dfs(a, b, c)
+ if t[0]+1 < min {
+ min = t[0] + 1
+ }
+ if t[1]+1 > max {
+ max = t[1] + 1
+ }
+ }
+
+ f[l][r][n] = encode(min, max)
+ return []int{min, max}
+}
+
+func encode(x, y int) int {
+ return (x << 8) | y
+}
+
+func decode(val int) []int {
+ return []int{val >> 8, val & 255}
+}
diff --git a/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.java b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.java
new file mode 100644
index 0000000000000..e9786bf268209
--- /dev/null
+++ b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.java
@@ -0,0 +1,59 @@
+class Solution {
+ static int[][][] f = new int[30][30][31];
+
+ public int[] earliestAndLatest(int n, int firstPlayer, int secondPlayer) {
+ return dfs(firstPlayer - 1, secondPlayer - 1, n);
+ }
+
+ private int[] dfs(int l, int r, int n) {
+ if (f[l][r][n] != 0) {
+ return decode(f[l][r][n]);
+ }
+ if (l + r == n - 1) {
+ f[l][r][n] = encode(1, 1);
+ return new int[] {1, 1};
+ }
+ int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;
+ int m = n >> 1;
+ for (int i = 0; i < (1 << m); i++) {
+ boolean[] win = new boolean[n];
+ for (int j = 0; j < m; j++) {
+ if (((i >> j) & 1) == 1) {
+ win[j] = true;
+ } else {
+ win[n - 1 - j] = true;
+ }
+ }
+ if ((n & 1) == 1) {
+ win[m] = true;
+ }
+ win[n - 1 - l] = win[n - 1 - r] = false;
+ win[l] = win[r] = true;
+ int a = 0, b = 0, c = 0;
+ for (int j = 0; j < n; j++) {
+ if (j == l) {
+ a = c;
+ }
+ if (j == r) {
+ b = c;
+ }
+ if (win[j]) {
+ c++;
+ }
+ }
+ int[] t = dfs(a, b, c);
+ min = Math.min(min, t[0] + 1);
+ max = Math.max(max, t[1] + 1);
+ }
+ f[l][r][n] = encode(min, max);
+ return new int[] {min, max};
+ }
+
+ private int encode(int x, int y) {
+ return (x << 8) | y;
+ }
+
+ private int[] decode(int val) {
+ return new int[] {val >> 8, val & 255};
+ }
+}
diff --git a/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.py b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.py
index f16f724b7a0ab..ecdb1da17d8cc 100644
--- a/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.py
+++ b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.py
@@ -1,28 +1,36 @@
+@cache
+def dfs(l: int, r: int, n: int):
+ if l + r == n - 1:
+ return [1, 1]
+ res = [inf, -inf]
+ m = n >> 1
+ for i in range(1 << m):
+ win = [False] * n
+ for j in range(m):
+ if i >> j & 1:
+ win[j] = True
+ else:
+ win[n - 1 - j] = True
+ if n & 1:
+ win[m] = True
+ win[n - 1 - l] = win[n - 1 - r] = False
+ win[l] = win[r] = True
+ a = b = c = 0
+ for j in range(n):
+ if j == l:
+ a = c
+ if j == r:
+ b = c
+ if win[j]:
+ c += 1
+ x, y = dfs(a, b, c)
+ res[0] = min(res[0], x + 1)
+ res[1] = max(res[1], y + 1)
+ return res
+
+
class Solution:
def earliestAndLatest(
self, n: int, firstPlayer: int, secondPlayer: int
) -> List[int]:
- # dp[i][j][k] := (earliest, latest) pair w/ firstPlayer is i-th player from
- # Front, secondPlayer is j-th player from end, and there're k people
- @functools.lru_cache(None)
- def dp(l: int, r: int, k: int) -> List[int]:
- if l == r:
- return [1, 1]
- if l > r:
- return dp(r, l, k)
-
- a = math.inf
- b = -math.inf
-
- # Enumerate all possible positions
- for i in range(1, l + 1):
- for j in range(l - i + 1, r - i + 1):
- if not l + r - k // 2 <= i + j <= (k + 1) // 2:
- continue
- x, y = dp(i, j, (k + 1) // 2)
- a = min(a, x + 1)
- b = max(b, y + 1)
-
- return [a, b]
-
- return dp(firstPlayer, n - secondPlayer + 1, n)
+ return dfs(firstPlayer - 1, secondPlayer - 1, n)
diff --git a/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.ts b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.ts
new file mode 100644
index 0000000000000..4c0797ca5804c
--- /dev/null
+++ b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.ts
@@ -0,0 +1,65 @@
+function earliestAndLatest(n: number, firstPlayer: number, secondPlayer: number): number[] {
+ return dfs(firstPlayer - 1, secondPlayer - 1, n);
+}
+
+const f: number[][][] = Array.from({ length: 30 }, () =>
+ Array.from({ length: 30 }, () => Array(31).fill(0)),
+);
+
+function dfs(l: number, r: number, n: number): number[] {
+ if (f[l][r][n] !== 0) {
+ return decode(f[l][r][n]);
+ }
+ if (l + r === n - 1) {
+ f[l][r][n] = encode(1, 1);
+ return [1, 1];
+ }
+
+ let min = Number.MAX_SAFE_INTEGER;
+ let max = Number.MIN_SAFE_INTEGER;
+ const m = n >> 1;
+
+ for (let i = 0; i < 1 << m; i++) {
+ const win: boolean[] = Array(n).fill(false);
+ for (let j = 0; j < m; j++) {
+ if ((i >> j) & 1) {
+ win[j] = true;
+ } else {
+ win[n - 1 - j] = true;
+ }
+ }
+
+ if (n & 1) {
+ win[m] = true;
+ }
+
+ win[n - 1 - l] = false;
+ win[n - 1 - r] = false;
+ win[l] = true;
+ win[r] = true;
+
+ let a = 0,
+ b = 0,
+ c = 0;
+ for (let j = 0; j < n; j++) {
+ if (j === l) a = c;
+ if (j === r) b = c;
+ if (win[j]) c++;
+ }
+
+ const t = dfs(a, b, c);
+ min = Math.min(min, t[0] + 1);
+ max = Math.max(max, t[1] + 1);
+ }
+
+ f[l][r][n] = encode(min, max);
+ return [min, max];
+}
+
+function encode(x: number, y: number): number {
+ return (x << 8) | y;
+}
+
+function decode(val: number): number[] {
+ return [val >> 8, val & 255];
+}
diff --git a/solution/1900-1999/1948.Delete Duplicate Folders in System/README.md b/solution/1900-1999/1948.Delete Duplicate Folders in System/README.md
index d3255436fb79c..073d0a88e91b7 100644
--- a/solution/1900-1999/1948.Delete Duplicate Folders in System/README.md
+++ b/solution/1900-1999/1948.Delete Duplicate Folders in System/README.md
@@ -122,32 +122,348 @@ tags:
-### 方法一
+### 方法一：字典树 + DFS
+
+我们可以使用字典树来存储文件夹的结构，字典树的每个节点数据如下：
+
+- `children`：一个字典，键为子文件夹的名称，值为对应的子节点。
+- `deleted`：一个布尔值，表示该节点是否被标记为待删除。
+
+我们将所有路径插入到字典树中，然后使用 DFS 遍历字典树，构建每个子树的字符串表示。对于每个子树，如果它的字符串表示已经存在于一个全局字典中，则将该节点和全局字典中的对应节点都标记为待删除。最后，再次使用 DFS 遍历字典树，将未被标记的节点的路径添加到结果列表中。
#### Python3
```python
-
+class Trie:
+ def __init__(self):
+ self.children: Dict[str, "Trie"] = defaultdict(Trie)
+ self.deleted: bool = False
+
+
+class Solution:
+ def deleteDuplicateFolder(self, paths: List[List[str]]) -> List[List[str]]:
+ root = Trie()
+ for path in paths:
+ cur = root
+ for name in path:
+ if cur.children[name] is None:
+ cur.children[name] = Trie()
+ cur = cur.children[name]
+
+ g: Dict[str, Trie] = {}
+
+ def dfs(node: Trie) -> str:
+ if not node.children:
+ return ""
+ subs: List[str] = []
+ for name, child in node.children.items():
+ subs.append(f"{name}({dfs(child)})")
+ s = "".join(sorted(subs))
+ if s in g:
+ node.deleted = g[s].deleted = True
+ else:
+ g[s] = node
+ return s
+
+ def dfs2(node: Trie) -> None:
+ if node.deleted:
+ return
+ if path:
+ ans.append(path[:])
+ for name, child in node.children.items():
+ path.append(name)
+ dfs2(child)
+ path.pop()
+
+ dfs(root)
+ ans: List[List[str]] = []
+ path: List[str] = []
+ dfs2(root)
+ return ans
```
#### Java
```java
-
+class Trie {
+ Map children;
+ boolean deleted;
+
+ public Trie() {
+ children = new HashMap<>();
+ deleted = false;
+ }
+}
+
+class Solution {
+ public List> deleteDuplicateFolder(List> paths) {
+ Trie root = new Trie();
+ for (List path : paths) {
+ Trie cur = root;
+ for (String name : path) {
+ if (!cur.children.containsKey(name)) {
+ cur.children.put(name, new Trie());
+ }
+ cur = cur.children.get(name);
+ }
+ }
+
+ Map g = new HashMap<>();
+
+ var dfs = new Function() {
+ @Override
+ public String apply(Trie node) {
+ if (node.children.isEmpty()) {
+ return "";
+ }
+ List subs = new ArrayList<>();
+ for (var entry : node.children.entrySet()) {
+ subs.add(entry.getKey() + "(" + apply(entry.getValue()) + ")");
+ }
+ Collections.sort(subs);
+ String s = String.join("", subs);
+ if (g.containsKey(s)) {
+ node.deleted = true;
+ g.get(s).deleted = true;
+ } else {
+ g.put(s, node);
+ }
+ return s;
+ }
+ };
+
+ dfs.apply(root);
+
+ List> ans = new ArrayList<>();
+ List path = new ArrayList<>();
+
+ var dfs2 = new Function() {
+ @Override
+ public Void apply(Trie node) {
+ if (node.deleted) {
+ return null;
+ }
+ if (!path.isEmpty()) {
+ ans.add(new ArrayList<>(path));
+ }
+ for (Map.Entry entry : node.children.entrySet()) {
+ path.add(entry.getKey());
+ apply(entry.getValue());
+ path.remove(path.size() - 1);
+ }
+ return null;
+ }
+ };
+
+ dfs2.apply(root);
+
+ return ans;
+ }
+}
```
#### C++
```cpp
-
+class Trie {
+public:
+ unordered_map children;
+ bool deleted = false;
+};
+
+class Solution {
+public:
+ vector> deleteDuplicateFolder(vector>& paths) {
+ Trie* root = new Trie();
+
+ for (auto& path : paths) {
+ Trie* cur = root;
+ for (auto& name : path) {
+ if (cur->children.find(name) == cur->children.end()) {
+ cur->children[name] = new Trie();
+ }
+ cur = cur->children[name];
+ }
+ }
+
+ unordered_map g;
+
+ auto dfs = [&](this auto&& dfs, Trie* node) -> string {
+ if (node->children.empty()) return "";
+
+ vector subs;
+ for (auto& child : node->children) {
+ subs.push_back(child.first + "(" + dfs(child.second) + ")");
+ }
+ sort(subs.begin(), subs.end());
+ string s = "";
+ for (auto& sub : subs) s += sub;
+
+ if (g.contains(s)) {
+ node->deleted = true;
+ g[s]->deleted = true;
+ } else {
+ g[s] = node;
+ }
+ return s;
+ };
+
+ dfs(root);
+
+ vector> ans;
+ vector path;
+
+ auto dfs2 = [&](this auto&& dfs2, Trie* node) -> void {
+ if (node->deleted) return;
+ if (!path.empty()) {
+ ans.push_back(path);
+ }
+ for (auto& child : node->children) {
+ path.push_back(child.first);
+ dfs2(child.second);
+ path.pop_back();
+ }
+ };
+
+ dfs2(root);
+
+ return ans;
+ }
+};
```
#### Go
```go
+type Trie struct {
+ children map[string]*Trie
+ deleted bool
+}
+
+func NewTrie() *Trie {
+ return &Trie{
+ children: make(map[string]*Trie),
+ }
+}
+
+func deleteDuplicateFolder(paths [][]string) (ans [][]string) {
+ root := NewTrie()
+ for _, path := range paths {
+ cur := root
+ for _, name := range path {
+ if _, exists := cur.children[name]; !exists {
+ cur.children[name] = NewTrie()
+ }
+ cur = cur.children[name]
+ }
+ }
+
+ g := make(map[string]*Trie)
+
+ var dfs func(*Trie) string
+ dfs = func(node *Trie) string {
+ if len(node.children) == 0 {
+ return ""
+ }
+ var subs []string
+ for name, child := range node.children {
+ subs = append(subs, name+"("+dfs(child)+")")
+ }
+ sort.Strings(subs)
+ s := strings.Join(subs, "")
+ if existingNode, exists := g[s]; exists {
+ node.deleted = true
+ existingNode.deleted = true
+ } else {
+ g[s] = node
+ }
+ return s
+ }
+
+ var dfs2 func(*Trie, []string)
+ dfs2 = func(node *Trie, path []string) {
+ if node.deleted {
+ return
+ }
+ if len(path) > 0 {
+ ans = append(ans, append([]string{}, path...))
+ }
+ for name, child := range node.children {
+ dfs2(child, append(path, name))
+ }
+ }
+
+ dfs(root)
+ dfs2(root, []string{})
+ return ans
+}
+```
+#### TypeScript
+
+```ts
+function deleteDuplicateFolder(paths: string[][]): string[][] {
+ class Trie {
+ children: { [key: string]: Trie } = {};
+ deleted: boolean = false;
+ }
+
+ const root = new Trie();
+
+ for (const path of paths) {
+ let cur = root;
+ for (const name of path) {
+ if (!cur.children[name]) {
+ cur.children[name] = new Trie();
+ }
+ cur = cur.children[name];
+ }
+ }
+
+ const g: { [key: string]: Trie } = {};
+
+ const dfs = (node: Trie): string => {
+ if (Object.keys(node.children).length === 0) return '';
+
+ const subs: string[] = [];
+ for (const [name, child] of Object.entries(node.children)) {
+ subs.push(`${name}(${dfs(child)})`);
+ }
+ subs.sort();
+ const s = subs.join('');
+
+ if (g[s]) {
+ node.deleted = true;
+ g[s].deleted = true;
+ } else {
+ g[s] = node;
+ }
+ return s;
+ };
+
+ dfs(root);
+
+ const ans: string[][] = [];
+ const path: string[] = [];
+
+ const dfs2 = (node: Trie): void => {
+ if (node.deleted) return;
+ if (path.length > 0) {
+ ans.push([...path]);
+ }
+ for (const [name, child] of Object.entries(node.children)) {
+ path.push(name);
+ dfs2(child);
+ path.pop();
+ }
+ };
+
+ dfs2(root);
+
+ return ans;
+}
```
diff --git a/solution/1900-1999/1948.Delete Duplicate Folders in System/README_EN.md b/solution/1900-1999/1948.Delete Duplicate Folders in System/README_EN.md
index 01fa7d10a03c7..70015e2e4de1d 100644
--- a/solution/1900-1999/1948.Delete Duplicate Folders in System/README_EN.md
+++ b/solution/1900-1999/1948.Delete Duplicate Folders in System/README_EN.md
@@ -101,32 +101,348 @@ Note that the returned array can be in a different order as the order does not m
-### Solution 1
+### Solution 1: Trie + DFS
+
+We can use a trie to store the folder structure, where each node in the trie contains the following data:
+
+- `children`: A dictionary where the key is the name of the subfolder and the value is the corresponding child node.
+- `deleted`: A boolean value indicating whether the node is marked for deletion.
+
+We insert all paths into the trie, then use DFS to traverse the trie and build a string representation for each subtree. For each subtree, if its string representation already exists in a global dictionary, we mark both the current node and the corresponding node in the global dictionary for deletion. Finally, we use DFS again to traverse the trie and add the paths of unmarked nodes to the result list.
#### Python3
```python
-
+class Trie:
+ def __init__(self):
+ self.children: Dict[str, "Trie"] = defaultdict(Trie)
+ self.deleted: bool = False
+
+
+class Solution:
+ def deleteDuplicateFolder(self, paths: List[List[str]]) -> List[List[str]]:
+ root = Trie()
+ for path in paths:
+ cur = root
+ for name in path:
+ if cur.children[name] is None:
+ cur.children[name] = Trie()
+ cur = cur.children[name]
+
+ g: Dict[str, Trie] = {}
+
+ def dfs(node: Trie) -> str:
+ if not node.children:
+ return ""
+ subs: List[str] = []
+ for name, child in node.children.items():
+ subs.append(f"{name}({dfs(child)})")
+ s = "".join(sorted(subs))
+ if s in g:
+ node.deleted = g[s].deleted = True
+ else:
+ g[s] = node
+ return s
+
+ def dfs2(node: Trie) -> None:
+ if node.deleted:
+ return
+ if path:
+ ans.append(path[:])
+ for name, child in node.children.items():
+ path.append(name)
+ dfs2(child)
+ path.pop()
+
+ dfs(root)
+ ans: List[List[str]] = []
+ path: List[str] = []
+ dfs2(root)
+ return ans
```
#### Java
```java
-
+class Trie {
+ Map children;
+ boolean deleted;
+
+ public Trie() {
+ children = new HashMap<>();
+ deleted = false;
+ }
+}
+
+class Solution {
+ public List> deleteDuplicateFolder(List> paths) {
+ Trie root = new Trie();
+ for (List path : paths) {
+ Trie cur = root;
+ for (String name : path) {
+ if (!cur.children.containsKey(name)) {
+ cur.children.put(name, new Trie());
+ }
+ cur = cur.children.get(name);
+ }
+ }
+
+ Map g = new HashMap<>();
+
+ var dfs = new Function() {
+ @Override
+ public String apply(Trie node) {
+ if (node.children.isEmpty()) {
+ return "";
+ }
+ List subs = new ArrayList<>();
+ for (var entry : node.children.entrySet()) {
+ subs.add(entry.getKey() + "(" + apply(entry.getValue()) + ")");
+ }
+ Collections.sort(subs);
+ String s = String.join("", subs);
+ if (g.containsKey(s)) {
+ node.deleted = true;
+ g.get(s).deleted = true;
+ } else {
+ g.put(s, node);
+ }
+ return s;
+ }
+ };
+
+ dfs.apply(root);
+
+ List> ans = new ArrayList<>();
+ List path = new ArrayList<>();
+
+ var dfs2 = new Function() {
+ @Override
+ public Void apply(Trie node) {
+ if (node.deleted) {
+ return null;
+ }
+ if (!path.isEmpty()) {
+ ans.add(new ArrayList<>(path));
+ }
+ for (Map.Entry entry : node.children.entrySet()) {
+ path.add(entry.getKey());
+ apply(entry.getValue());
+ path.remove(path.size() - 1);
+ }
+ return null;
+ }
+ };
+
+ dfs2.apply(root);
+
+ return ans;
+ }
+}
```
#### C++
```cpp
-
+class Trie {
+public:
+ unordered_map children;
+ bool deleted = false;
+};
+
+class Solution {
+public:
+ vector> deleteDuplicateFolder(vector>& paths) {
+ Trie* root = new Trie();
+
+ for (auto& path : paths) {
+ Trie* cur = root;
+ for (auto& name : path) {
+ if (cur->children.find(name) == cur->children.end()) {
+ cur->children[name] = new Trie();
+ }
+ cur = cur->children[name];
+ }
+ }
+
+ unordered_map g;
+
+ auto dfs = [&](this auto&& dfs, Trie* node) -> string {
+ if (node->children.empty()) return "";
+
+ vector subs;
+ for (auto& child : node->children) {
+ subs.push_back(child.first + "(" + dfs(child.second) + ")");
+ }
+ sort(subs.begin(), subs.end());
+ string s = "";
+ for (auto& sub : subs) s += sub;
+
+ if (g.contains(s)) {
+ node->deleted = true;
+ g[s]->deleted = true;
+ } else {
+ g[s] = node;
+ }
+ return s;
+ };
+
+ dfs(root);
+
+ vector> ans;
+ vector path;
+
+ auto dfs2 = [&](this auto&& dfs2, Trie* node) -> void {
+ if (node->deleted) return;
+ if (!path.empty()) {
+ ans.push_back(path);
+ }
+ for (auto& child : node->children) {
+ path.push_back(child.first);
+ dfs2(child.second);
+ path.pop_back();
+ }
+ };
+
+ dfs2(root);
+
+ return ans;
+ }
+};
```
#### Go
```go
+type Trie struct {
+ children map[string]*Trie
+ deleted bool
+}
+
+func NewTrie() *Trie {
+ return &Trie{
+ children: make(map[string]*Trie),
+ }
+}
+
+func deleteDuplicateFolder(paths [][]string) (ans [][]string) {
+ root := NewTrie()
+ for _, path := range paths {
+ cur := root
+ for _, name := range path {
+ if _, exists := cur.children[name]; !exists {
+ cur.children[name] = NewTrie()
+ }
+ cur = cur.children[name]
+ }
+ }
+
+ g := make(map[string]*Trie)
+
+ var dfs func(*Trie) string
+ dfs = func(node *Trie) string {
+ if len(node.children) == 0 {
+ return ""
+ }
+ var subs []string
+ for name, child := range node.children {
+ subs = append(subs, name+"("+dfs(child)+")")
+ }
+ sort.Strings(subs)
+ s := strings.Join(subs, "")
+ if existingNode, exists := g[s]; exists {
+ node.deleted = true
+ existingNode.deleted = true
+ } else {
+ g[s] = node
+ }
+ return s
+ }
+
+ var dfs2 func(*Trie, []string)
+ dfs2 = func(node *Trie, path []string) {
+ if node.deleted {
+ return
+ }
+ if len(path) > 0 {
+ ans = append(ans, append([]string{}, path...))
+ }
+ for name, child := range node.children {
+ dfs2(child, append(path, name))
+ }
+ }
+
+ dfs(root)
+ dfs2(root, []string{})
+ return ans
+}
+```
+#### TypeScript
+
+```ts
+function deleteDuplicateFolder(paths: string[][]): string[][] {
+ class Trie {
+ children: { [key: string]: Trie } = {};
+ deleted: boolean = false;
+ }
+
+ const root = new Trie();
+
+ for (const path of paths) {
+ let cur = root;
+ for (const name of path) {
+ if (!cur.children[name]) {
+ cur.children[name] = new Trie();
+ }
+ cur = cur.children[name];
+ }
+ }
+
+ const g: { [key: string]: Trie } = {};
+
+ const dfs = (node: Trie): string => {
+ if (Object.keys(node.children).length === 0) return '';
+
+ const subs: string[] = [];
+ for (const [name, child] of Object.entries(node.children)) {
+ subs.push(`${name}(${dfs(child)})`);
+ }
+ subs.sort();
+ const s = subs.join('');
+
+ if (g[s]) {
+ node.deleted = true;
+ g[s].deleted = true;
+ } else {
+ g[s] = node;
+ }
+ return s;
+ };
+
+ dfs(root);
+
+ const ans: string[][] = [];
+ const path: string[] = [];
+
+ const dfs2 = (node: Trie): void => {
+ if (node.deleted) return;
+ if (path.length > 0) {
+ ans.push([...path]);
+ }
+ for (const [name, child] of Object.entries(node.children)) {
+ path.push(name);
+ dfs2(child);
+ path.pop();
+ }
+ };
+
+ dfs2(root);
+
+ return ans;
+}
```
diff --git a/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.cpp b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.cpp
new file mode 100644
index 0000000000000..3f7b140bc9353
--- /dev/null
+++ b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.cpp
@@ -0,0 +1,65 @@
+class Trie {
+public:
+ unordered_map children;
+ bool deleted = false;
+};
+
+class Solution {
+public:
+ vector> deleteDuplicateFolder(vector>& paths) {
+ Trie* root = new Trie();
+
+ for (auto& path : paths) {
+ Trie* cur = root;
+ for (auto& name : path) {
+ if (cur->children.find(name) == cur->children.end()) {
+ cur->children[name] = new Trie();
+ }
+ cur = cur->children[name];
+ }
+ }
+
+ unordered_map g;
+
+ auto dfs = [&](this auto&& dfs, Trie* node) -> string {
+ if (node->children.empty()) return "";
+
+ vector subs;
+ for (auto& child : node->children) {
+ subs.push_back(child.first + "(" + dfs(child.second) + ")");
+ }
+ sort(subs.begin(), subs.end());
+ string s = "";
+ for (auto& sub : subs) s += sub;
+
+ if (g.contains(s)) {
+ node->deleted = true;
+ g[s]->deleted = true;
+ } else {
+ g[s] = node;
+ }
+ return s;
+ };
+
+ dfs(root);
+
+ vector> ans;
+ vector path;
+
+ auto dfs2 = [&](this auto&& dfs2, Trie* node) -> void {
+ if (node->deleted) return;
+ if (!path.empty()) {
+ ans.push_back(path);
+ }
+ for (auto& child : node->children) {
+ path.push_back(child.first);
+ dfs2(child.second);
+ path.pop_back();
+ }
+ };
+
+ dfs2(root);
+
+ return ans;
+ }
+};
diff --git a/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.go b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.go
new file mode 100644
index 0000000000000..2b61f3796a413
--- /dev/null
+++ b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.go
@@ -0,0 +1,62 @@
+type Trie struct {
+ children map[string]*Trie
+ deleted bool
+}
+
+func NewTrie() *Trie {
+ return &Trie{
+ children: make(map[string]*Trie),
+ }
+}
+
+func deleteDuplicateFolder(paths [][]string) (ans [][]string) {
+ root := NewTrie()
+ for _, path := range paths {
+ cur := root
+ for _, name := range path {
+ if _, exists := cur.children[name]; !exists {
+ cur.children[name] = NewTrie()
+ }
+ cur = cur.children[name]
+ }
+ }
+
+ g := make(map[string]*Trie)
+
+ var dfs func(*Trie) string
+ dfs = func(node *Trie) string {
+ if len(node.children) == 0 {
+ return ""
+ }
+ var subs []string
+ for name, child := range node.children {
+ subs = append(subs, name+"("+dfs(child)+")")
+ }
+ sort.Strings(subs)
+ s := strings.Join(subs, "")
+ if existingNode, exists := g[s]; exists {
+ node.deleted = true
+ existingNode.deleted = true
+ } else {
+ g[s] = node
+ }
+ return s
+ }
+
+ var dfs2 func(*Trie, []string)
+ dfs2 = func(node *Trie, path []string) {
+ if node.deleted {
+ return
+ }
+ if len(path) > 0 {
+ ans = append(ans, append([]string{}, path...))
+ }
+ for name, child := range node.children {
+ dfs2(child, append(path, name))
+ }
+ }
+
+ dfs(root)
+ dfs2(root, []string{})
+ return ans
+}
diff --git a/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.java b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.java
new file mode 100644
index 0000000000000..cd5912d34b40c
--- /dev/null
+++ b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.java
@@ -0,0 +1,75 @@
+class Trie {
+ Map children;
+ boolean deleted;
+
+ public Trie() {
+ children = new HashMap<>();
+ deleted = false;
+ }
+}
+
+class Solution {
+ public List> deleteDuplicateFolder(List> paths) {
+ Trie root = new Trie();
+ for (List path : paths) {
+ Trie cur = root;
+ for (String name : path) {
+ if (!cur.children.containsKey(name)) {
+ cur.children.put(name, new Trie());
+ }
+ cur = cur.children.get(name);
+ }
+ }
+
+ Map g = new HashMap<>();
+
+ var dfs = new Function() {
+ @Override
+ public String apply(Trie node) {
+ if (node.children.isEmpty()) {
+ return "";
+ }
+ List subs = new ArrayList<>();
+ for (var entry : node.children.entrySet()) {
+ subs.add(entry.getKey() + "(" + apply(entry.getValue()) + ")");
+ }
+ Collections.sort(subs);
+ String s = String.join("", subs);
+ if (g.containsKey(s)) {
+ node.deleted = true;
+ g.get(s).deleted = true;
+ } else {
+ g.put(s, node);
+ }
+ return s;
+ }
+ };
+
+ dfs.apply(root);
+
+ List> ans = new ArrayList<>();
+ List path = new ArrayList<>();
+
+ var dfs2 = new Function() {
+ @Override
+ public Void apply(Trie node) {
+ if (node.deleted) {
+ return null;
+ }
+ if (!path.isEmpty()) {
+ ans.add(new ArrayList<>(path));
+ }
+ for (Map.Entry entry : node.children.entrySet()) {
+ path.add(entry.getKey());
+ apply(entry.getValue());
+ path.remove(path.size() - 1);
+ }
+ return null;
+ }
+ };
+
+ dfs2.apply(root);
+
+ return ans;
+ }
+}
diff --git a/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.py b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.py
new file mode 100644
index 0000000000000..9031f263762d1
--- /dev/null
+++ b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.py
@@ -0,0 +1,46 @@
+class Trie:
+ def __init__(self):
+ self.children: Dict[str, "Trie"] = defaultdict(Trie)
+ self.deleted: bool = False
+
+
+class Solution:
+ def deleteDuplicateFolder(self, paths: List[List[str]]) -> List[List[str]]:
+ root = Trie()
+ for path in paths:
+ cur = root
+ for name in path:
+ if cur.children[name] is None:
+ cur.children[name] = Trie()
+ cur = cur.children[name]
+
+ g: Dict[str, Trie] = {}
+
+ def dfs(node: Trie) -> str:
+ if not node.children:
+ return ""
+ subs: List[str] = []
+ for name, child in node.children.items():
+ subs.append(f"{name}({dfs(child)})")
+ s = "".join(sorted(subs))
+ if s in g:
+ node.deleted = g[s].deleted = True
+ else:
+ g[s] = node
+ return s
+
+ def dfs2(node: Trie) -> None:
+ if node.deleted:
+ return
+ if path:
+ ans.append(path[:])
+ for name, child in node.children.items():
+ path.append(name)
+ dfs2(child)
+ path.pop()
+
+ dfs(root)
+ ans: List[List[str]] = []
+ path: List[str] = []
+ dfs2(root)
+ return ans
diff --git a/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.ts b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.ts
new file mode 100644
index 0000000000000..10096fe3014d4
--- /dev/null
+++ b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.ts
@@ -0,0 +1,60 @@
+function deleteDuplicateFolder(paths: string[][]): string[][] {
+ class Trie {
+ children: { [key: string]: Trie } = {};
+ deleted: boolean = false;
+ }
+
+ const root = new Trie();
+
+ for (const path of paths) {
+ let cur = root;
+ for (const name of path) {
+ if (!cur.children[name]) {
+ cur.children[name] = new Trie();
+ }
+ cur = cur.children[name];
+ }
+ }
+
+ const g: { [key: string]: Trie } = {};
+
+ const dfs = (node: Trie): string => {
+ if (Object.keys(node.children).length === 0) return '';
+
+ const subs: string[] = [];
+ for (const [name, child] of Object.entries(node.children)) {
+ subs.push(`${name}(${dfs(child)})`);
+ }
+ subs.sort();
+ const s = subs.join('');
+
+ if (g[s]) {
+ node.deleted = true;
+ g[s].deleted = true;
+ } else {
+ g[s] = node;
+ }
+ return s;
+ };
+
+ dfs(root);
+
+ const ans: string[][] = [];
+ const path: string[] = [];
+
+ const dfs2 = (node: Trie): void => {
+ if (node.deleted) return;
+ if (path.length > 0) {
+ ans.push([...path]);
+ }
+ for (const [name, child] of Object.entries(node.children)) {
+ path.push(name);
+ dfs2(child);
+ path.pop();
+ }
+ };
+
+ dfs2(root);
+
+ return ans;
+}
diff --git a/solution/1900-1999/1957.Delete Characters to Make Fancy String/README.md b/solution/1900-1999/1957.Delete Characters to Make Fancy String/README.md
index fbfab3d1aea3c..ec802af1344cc 100644
--- a/solution/1900-1999/1957.Delete Characters to Make Fancy String/README.md
+++ b/solution/1900-1999/1957.Delete Characters to Make Fancy String/README.md
@@ -72,11 +72,11 @@ tags:
### 方法一：模拟
-我们可以遍历字符串 $s$，并使用一个数组 $\textit{ans}$ 记录当前的答案。对于每一个字符 $c$，如果 $\textit{ans}$ 的长度小于 $2$ 或者 $\textit{ans}$ 的最后两个字符不等于 $c$，我们就将 $c$ 添加到 $\textit{ans}$ 中。
+我们可以遍历字符串 $s$，并使用一个数组 $\textit{ans}$ 记录当前的答案。对于每一个字符 $\textit{s[i]}$，如果 $i \lt 2$ 或者 $s[i]$ 与 $s[i - 1]$ 不等，或者 $s[i]$ 与 $s[i - 2]$ 不等，我们就将 $s[i]$ 添加到 $\textit{ans}$ 中。
最后，我们将 $\textit{ans}$ 中的字符连接起来，就得到了答案。
-时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为字符串 $s$ 的长度。
+时间复杂度 $O(n)$，其中 $n$ 为字符串 $s$ 的长度。忽略答案的空间消耗，空间复杂度 $O(1)$。
@@ -86,8 +86,8 @@ tags:
class Solution:
def makeFancyString(self, s: str) -> str:
ans = []
- for c in s:
- if len(ans) < 2 or ans[-1] != c or ans[-2] != c:
+ for i, c in enumerate(s):
+ if i < 2 or c != s[i - 1] or c != s[i - 2]:
ans.append(c)
return "".join(ans)
```
@@ -98,9 +98,9 @@ class Solution:
class Solution {
public String makeFancyString(String s) {
StringBuilder ans = new StringBuilder();
- for (char c : s.toCharArray()) {
- int n = ans.length();
- if (n < 2 || c != ans.charAt(n - 1) || c != ans.charAt(n - 2)) {
+ for (int i = 0; i < s.length(); ++i) {
+ char c = s.charAt(i);
+ if (i < 2 || c != s.charAt(i - 1) || c != s.charAt(i - 2)) {
ans.append(c);
}
}
@@ -116,9 +116,9 @@ class Solution {
public:
string makeFancyString(string s) {
string ans = "";
- for (char& c : s) {
- int n = ans.size();
- if (n < 2 || ans[n - 1] != c || ans[n - 2] != c) {
+ for (int i = 0; i < s.length(); ++i) {
+ char c = s[i];
+ if (i < 2 || c != s[i - 1] || c != s[i - 2]) {
ans += c;
}
}
@@ -131,9 +131,9 @@ public:
```go
func makeFancyString(s string) string {
- ans := []rune{}
- for _, c := range s {
- if n := len(ans); n < 2 || c != ans[n-1] || c != ans[n-2] {
+ ans := []byte{}
+ for i, ch := range s {
+ if c := byte(ch); i < 2 || c != s[i-1] || c != s[i-2] {
ans = append(ans, c)
}
}
@@ -145,28 +145,32 @@ func makeFancyString(s string) string {
```ts
function makeFancyString(s: string): string {
- let [n, ans] = [s.length, ''];
- for (let i = 0; i < n; i++) {
+ const ans: string[] = [];
+ for (let i = 0; i < s.length; ++i) {
if (s[i] !== s[i - 1] || s[i] !== s[i - 2]) {
- ans += s[i];
+ ans.push(s[i]);
}
}
- return ans;
+ return ans.join('');
}
```
#### JavaScript
```js
-function makeFancyString(s) {
- let [n, ans] = [s.length, ''];
- for (let i = 0; i < n; i++) {
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var makeFancyString = function (s) {
+ const ans = [];
+ for (let i = 0; i < s.length; ++i) {
if (s[i] !== s[i - 1] || s[i] !== s[i - 2]) {
- ans += s[i];
+ ans.push(s[i]);
}
}
- return ans;
-}
+ return ans.join('');
+};
```
#### PHP
@@ -178,17 +182,14 @@ class Solution {
* @return String
*/
function makeFancyString($s) {
- $ans = [];
- $length = strlen($s);
-
- for ($i = 0; $i < $length; $i++) {
- $n = count($ans);
- if ($n < 2 || $s[$i] !== $ans[$n - 1] || $s[$i] !== $ans[$n - 2]) {
- $ans[] = $s[$i];
+ $ans = '';
+ for ($i = 0; $i < strlen($s); $i++) {
+ $c = $s[$i];
+ if ($i < 2 || $c !== $s[$i - 1] || $c !== $s[$i - 2]) {
+ $ans .= $c;
}
}
-
- return implode('', $ans);
+ return $ans;
}
}
```
diff --git a/solution/1900-1999/1957.Delete Characters to Make Fancy String/README_EN.md b/solution/1900-1999/1957.Delete Characters to Make Fancy String/README_EN.md
index 466d7474105a2..2879eb33fac38 100644
--- a/solution/1900-1999/1957.Delete Characters to Make Fancy String/README_EN.md
+++ b/solution/1900-1999/1957.Delete Characters to Make Fancy String/README_EN.md
@@ -70,11 +70,11 @@ No three consecutive characters are equal, so return "aabaa".
### Solution 1: Simulation
-We can traverse the string $s$ and use an array $\textit{ans}$ to record the current answer. For each character $c$, if the length of $\textit{ans}$ is less than $2$ or the last two characters of $\textit{ans}$ are not equal to $c$, we add $c$ to $\textit{ans}$.
+We can iterate through the string $s$ and use an array $\textit{ans}$ to record the current answer. For each character $\textit{s[i]}$, if $i < 2$ or $s[i]$ is not equal to $s[i - 1]$, or $s[i]$ is not equal to $s[i - 2]$, we add $s[i]$ to $\textit{ans}$.
Finally, we concatenate the characters in $\textit{ans}$ to get the answer.
-The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the string $s$.
+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)$.
@@ -84,8 +84,8 @@ The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is
class Solution:
def makeFancyString(self, s: str) -> str:
ans = []
- for c in s:
- if len(ans) < 2 or ans[-1] != c or ans[-2] != c:
+ for i, c in enumerate(s):
+ if i < 2 or c != s[i - 1] or c != s[i - 2]:
ans.append(c)
return "".join(ans)
```
@@ -96,9 +96,9 @@ class Solution:
class Solution {
public String makeFancyString(String s) {
StringBuilder ans = new StringBuilder();
- for (char c : s.toCharArray()) {
- int n = ans.length();
- if (n < 2 || c != ans.charAt(n - 1) || c != ans.charAt(n - 2)) {
+ for (int i = 0; i < s.length(); ++i) {
+ char c = s.charAt(i);
+ if (i < 2 || c != s.charAt(i - 1) || c != s.charAt(i - 2)) {
ans.append(c);
}
}
@@ -114,9 +114,9 @@ class Solution {
public:
string makeFancyString(string s) {
string ans = "";
- for (char& c : s) {
- int n = ans.size();
- if (n < 2 || ans[n - 1] != c || ans[n - 2] != c) {
+ for (int i = 0; i < s.length(); ++i) {
+ char c = s[i];
+ if (i < 2 || c != s[i - 1] || c != s[i - 2]) {
ans += c;
}
}
@@ -129,9 +129,9 @@ public:
```go
func makeFancyString(s string) string {
- ans := []rune{}
- for _, c := range s {
- if n := len(ans); n < 2 || c != ans[n-1] || c != ans[n-2] {
+ ans := []byte{}
+ for i, ch := range s {
+ if c := byte(ch); i < 2 || c != s[i-1] || c != s[i-2] {
ans = append(ans, c)
}
}
@@ -143,28 +143,32 @@ func makeFancyString(s string) string {
```ts
function makeFancyString(s: string): string {
- let [n, ans] = [s.length, ''];
- for (let i = 0; i < n; i++) {
+ const ans: string[] = [];
+ for (let i = 0; i < s.length; ++i) {
if (s[i] !== s[i - 1] || s[i] !== s[i - 2]) {
- ans += s[i];
+ ans.push(s[i]);
}
}
- return ans;
+ return ans.join('');
}
```
#### JavaScript
```js
-function makeFancyString(s) {
- let [n, ans] = [s.length, ''];
- for (let i = 0; i < n; i++) {
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var makeFancyString = function (s) {
+ const ans = [];
+ for (let i = 0; i < s.length; ++i) {
if (s[i] !== s[i - 1] || s[i] !== s[i - 2]) {
- ans += s[i];
+ ans.push(s[i]);
}
}
- return ans;
-}
+ return ans.join('');
+};
```
#### PHP
@@ -176,17 +180,14 @@ class Solution {
* @return String
*/
function makeFancyString($s) {
- $ans = [];
- $length = strlen($s);
-
- for ($i = 0; $i < $length; $i++) {
- $n = count($ans);
- if ($n < 2 || $s[$i] !== $ans[$n - 1] || $s[$i] !== $ans[$n - 2]) {
- $ans[] = $s[$i];
+ $ans = '';
+ for ($i = 0; $i < strlen($s); $i++) {
+ $c = $s[$i];
+ if ($i < 2 || $c !== $s[$i - 1] || $c !== $s[$i - 2]) {
+ $ans .= $c;
}
}
-
- return implode('', $ans);
+ return $ans;
}
}
```
diff --git a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.cpp b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.cpp
index 79416b151e375..450b000663202 100644
--- a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.cpp
+++ b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.cpp
@@ -2,9 +2,9 @@ class Solution {
public:
string makeFancyString(string s) {
string ans = "";
- for (char& c : s) {
- int n = ans.size();
- if (n < 2 || ans[n - 1] != c || ans[n - 2] != c) {
+ for (int i = 0; i < s.length(); ++i) {
+ char c = s[i];
+ if (i < 2 || c != s[i - 1] || c != s[i - 2]) {
ans += c;
}
}
diff --git a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.go b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.go
index b472925d7fd9e..3118be7e97ed2 100644
--- a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.go
+++ b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.go
@@ -1,7 +1,7 @@
func makeFancyString(s string) string {
- ans := []rune{}
- for _, c := range s {
- if n := len(ans); n < 2 || c != ans[n-1] || c != ans[n-2] {
+ ans := []byte{}
+ for i, ch := range s {
+ if c := byte(ch); i < 2 || c != s[i-1] || c != s[i-2] {
ans = append(ans, c)
}
}
diff --git a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.java b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.java
index 0947382c03255..4828771d9f284 100644
--- a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.java
+++ b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.java
@@ -1,12 +1,12 @@
class Solution {
public String makeFancyString(String s) {
StringBuilder ans = new StringBuilder();
- for (char c : s.toCharArray()) {
- int n = ans.length();
- if (n < 2 || c != ans.charAt(n - 1) || c != ans.charAt(n - 2)) {
+ for (int i = 0; i < s.length(); ++i) {
+ char c = s.charAt(i);
+ if (i < 2 || c != s.charAt(i - 1) || c != s.charAt(i - 2)) {
ans.append(c);
}
}
return ans.toString();
}
-}
+}
\ No newline at end of file
diff --git a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.js b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.js
index 16bfe1a2a7c98..745e2443b1d37 100644
--- a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.js
+++ b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.js
@@ -1,9 +1,13 @@
-function makeFancyString(s) {
- let [n, ans] = [s.length, ''];
- for (let i = 0; i < n; i++) {
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var makeFancyString = function (s) {
+ const ans = [];
+ for (let i = 0; i < s.length; ++i) {
if (s[i] !== s[i - 1] || s[i] !== s[i - 2]) {
- ans += s[i];
+ ans.push(s[i]);
}
}
- return ans;
-}
+ return ans.join('');
+};
diff --git a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.php b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.php
index 41b56186c248a..dc20f0120a451 100644
--- a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.php
+++ b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.php
@@ -4,16 +4,13 @@ class Solution {
* @return String
*/
function makeFancyString($s) {
- $ans = [];
- $length = strlen($s);
-
- for ($i = 0; $i < $length; $i++) {
- $n = count($ans);
- if ($n < 2 || $s[$i] !== $ans[$n - 1] || $s[$i] !== $ans[$n - 2]) {
- $ans[] = $s[$i];
+ $ans = '';
+ for ($i = 0; $i < strlen($s); $i++) {
+ $c = $s[$i];
+ if ($i < 2 || $c !== $s[$i - 1] || $c !== $s[$i - 2]) {
+ $ans .= $c;
}
}
-
- return implode('', $ans);
+ return $ans;
}
-}
+}
\ No newline at end of file
diff --git a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.py b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.py
index 76eb795267313..d601ec8b77fb2 100644
--- a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.py
+++ b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.py
@@ -1,7 +1,7 @@
class Solution:
def makeFancyString(self, s: str) -> str:
ans = []
- for c in s:
- if len(ans) < 2 or ans[-1] != c or ans[-2] != c:
+ for i, c in enumerate(s):
+ if i < 2 or c != s[i - 1] or c != s[i - 2]:
ans.append(c)
return "".join(ans)
diff --git a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.ts b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.ts
index 6f86484842ea4..bc989a239c6d2 100644
--- a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.ts
+++ b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.ts
@@ -1,9 +1,9 @@
function makeFancyString(s: string): string {
- let [n, ans] = [s.length, ''];
- for (let i = 0; i < n; i++) {
+ const ans: string[] = [];
+ for (let i = 0; i < s.length; ++i) {
if (s[i] !== s[i - 1] || s[i] !== s[i - 2]) {
- ans += s[i];
+ ans.push(s[i]);
}
}
- return ans;
+ return ans.join('');
}
diff --git a/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/README.md b/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/README.md
index b918ee2cb015b..f80ef7a0f97eb 100644
--- a/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/README.md
+++ b/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/README.md
@@ -68,25 +68,202 @@ tags:
#### Python3
```python
-
+class Solution:
+ def maxProduct(self, s: str) -> int:
+ n = len(s)
+ hlen = [0] * n
+ center = right = 0
+
+ for i in range(n):
+ if i < right:
+ hlen[i] = min(right - i, hlen[2 * center - i])
+ while (
+ 0 <= i - 1 - hlen[i]
+ and i + 1 + hlen[i] < len(s)
+ and s[i - 1 - hlen[i]] == s[i + 1 + hlen[i]]
+ ):
+ hlen[i] += 1
+ if right < i + hlen[i]:
+ center, right = i, i + hlen[i]
+
+ prefix = [0] * n
+ suffix = [0] * n
+
+ for i in range(n):
+ prefix[i + hlen[i]] = max(prefix[i + hlen[i]], 2 * hlen[i] + 1)
+ suffix[i - hlen[i]] = max(suffix[i - hlen[i]], 2 * hlen[i] + 1)
+
+ for i in range(1, n):
+ prefix[~i] = max(prefix[~i], prefix[~i + 1] - 2)
+ suffix[i] = max(suffix[i], suffix[i - 1] - 2)
+
+ for i in range(1, n):
+ prefix[i] = max(prefix[i - 1], prefix[i])
+ suffix[~i] = max(suffix[~i], suffix[~i + 1])
+
+ return max(prefix[i - 1] * suffix[i] for i in range(1, n))
```
#### Java
```java
-
+class Solution {
+ public long maxProduct(String s) {
+ int n = s.length();
+ if (n == 2) return 1;
+ int[] len = manachers(s);
+ long[] left = new long[n];
+ int max = 1;
+ left[0] = max;
+ for (int i = 1; i <= n - 1; i++) {
+ if (len[(i - max - 1 + i) / 2] > max) max += 2;
+ left[i] = max;
+ }
+ max = 1;
+ long[] right = new long[n];
+ right[n - 1] = max;
+ for (int i = n - 2; i >= 0; i--) {
+ if (len[(i + max + 1 + i) / 2] > max) max += 2;
+ right[i] = max;
+ }
+ long res = 1;
+ for (int i = 1; i < n; i++) {
+ res = Math.max(res, left[i - 1] * right[i]);
+ }
+ return res;
+ }
+ private int[] manachers(String s) {
+ int len = s.length();
+ int[] P = new int[len];
+ int c = 0;
+ int r = 0;
+ for (int i = 0; i < len; i++) {
+ int mirror = (2 * c) - i;
+ if (i < r) {
+ P[i] = Math.min(r - i, P[mirror]);
+ }
+ int a = i + (1 + P[i]);
+ int b = i - (1 + P[i]);
+ while (a < len && b >= 0 && s.charAt(a) == s.charAt(b)) {
+ P[i]++;
+ a++;
+ b--;
+ }
+ if (i + P[i] > r) {
+ c = i;
+ r = i + P[i];
+ }
+ }
+ for (int i = 0; i < len; i++) {
+ P[i] = 1 + 2 * P[i];
+ }
+ return P;
+ }
+}
```
#### C++
```cpp
-
+class Solution {
+public:
+ long long maxProduct(string s) {
+ long long res = 0, l = 0, n = s.size();
+ vector m(n), r(n);
+
+ for (int i = 0, l = 0, r = -1; i < n; ++i) {
+ int k = (i > r) ? 1 : min(m[l + r - i], r - i + 1);
+ while (0 <= i - k && i + k < n && s[i - k] == s[i + k])
+ k++;
+ m[i] = k--;
+ if (i + k > r) {
+ l = i - k;
+ r = i + k;
+ }
+ }
+
+ queue> q, q1;
+
+ for (int i = n - 1; i >= 0; --i) {
+ while (!q.empty() && q.front()[0] - q.front()[1] > i - 1)
+ q.pop();
+ r[i] = 1 + (q.empty() ? 0 : (q.front()[0] - i) * 2);
+ q.push({i, m[i]});
+ }
+
+ for (int i = 0; i < n - 1; i++) {
+ while (!q1.empty() && q1.front()[0] + q1.front()[1] < i + 1)
+ q1.pop();
+ l = max(l, 1ll + (q1.empty() ? 0 : (i - q1.front()[0]) * 2));
+ res = max(res, l * r[i + 1]);
+ q1.push({i, m[i]});
+ }
+
+ return res;
+ }
+};
```
#### Go
```go
-
+func maxProduct(s string) int64 {
+ n := len(s)
+ hlen := make([]int, n)
+ center, right := 0, 0
+
+ for i := 0; i < n; i++ {
+ if i < right {
+ mirror := 2*center - i
+ if mirror >= 0 && mirror < n {
+ hlen[i] = min(right-i, hlen[mirror])
+ }
+ }
+ for i-1-hlen[i] >= 0 && i+1+hlen[i] < n && s[i-1-hlen[i]] == s[i+1+hlen[i]] {
+ hlen[i]++
+ }
+ if i+hlen[i] > right {
+ center = i
+ right = i + hlen[i]
+ }
+ }
+
+ prefix := make([]int, n)
+ suffix := make([]int, n)
+
+ for i := 0; i < n; i++ {
+ r := i + hlen[i]
+ if r < n {
+ prefix[r] = max(prefix[r], 2*hlen[i]+1)
+ }
+ l := i - hlen[i]
+ if l >= 0 {
+ suffix[l] = max(suffix[l], 2*hlen[i]+1)
+ }
+ }
+
+ for i := 1; i < n; i++ {
+ if n-i-1 >= 0 {
+ prefix[n-i-1] = max(prefix[n-i-1], prefix[n-i]-2)
+ }
+ suffix[i] = max(suffix[i], suffix[i-1]-2)
+ }
+
+ for i := 1; i < n; i++ {
+ prefix[i] = max(prefix[i-1], prefix[i])
+ suffix[n-i-1] = max(suffix[n-i], suffix[n-i-1])
+ }
+
+ var res int64
+ for i := 1; i < n; i++ {
+ prod := int64(prefix[i-1]) * int64(suffix[i])
+ if prod > res {
+ res = prod
+ }
+ }
+
+ return res
+}
```
diff --git a/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/README_EN.md b/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/README_EN.md
index 044c570412d56..7959a940d8336 100644
--- a/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/README_EN.md
+++ b/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/README_EN.md
@@ -66,25 +66,202 @@ tags:
#### Python3
```python
-
+class Solution:
+ def maxProduct(self, s: str) -> int:
+ n = len(s)
+ hlen = [0] * n
+ center = right = 0
+
+ for i in range(n):
+ if i < right:
+ hlen[i] = min(right - i, hlen[2 * center - i])
+ while (
+ 0 <= i - 1 - hlen[i]
+ and i + 1 + hlen[i] < len(s)
+ and s[i - 1 - hlen[i]] == s[i + 1 + hlen[i]]
+ ):
+ hlen[i] += 1
+ if right < i + hlen[i]:
+ center, right = i, i + hlen[i]
+
+ prefix = [0] * n
+ suffix = [0] * n
+
+ for i in range(n):
+ prefix[i + hlen[i]] = max(prefix[i + hlen[i]], 2 * hlen[i] + 1)
+ suffix[i - hlen[i]] = max(suffix[i - hlen[i]], 2 * hlen[i] + 1)
+
+ for i in range(1, n):
+ prefix[~i] = max(prefix[~i], prefix[~i + 1] - 2)
+ suffix[i] = max(suffix[i], suffix[i - 1] - 2)
+
+ for i in range(1, n):
+ prefix[i] = max(prefix[i - 1], prefix[i])
+ suffix[~i] = max(suffix[~i], suffix[~i + 1])
+
+ return max(prefix[i - 1] * suffix[i] for i in range(1, n))
```
#### Java
```java
-
+class Solution {
+ public long maxProduct(String s) {
+ int n = s.length();
+ if (n == 2) return 1;
+ int[] len = manachers(s);
+ long[] left = new long[n];
+ int max = 1;
+ left[0] = max;
+ for (int i = 1; i <= n - 1; i++) {
+ if (len[(i - max - 1 + i) / 2] > max) max += 2;
+ left[i] = max;
+ }
+ max = 1;
+ long[] right = new long[n];
+ right[n - 1] = max;
+ for (int i = n - 2; i >= 0; i--) {
+ if (len[(i + max + 1 + i) / 2] > max) max += 2;
+ right[i] = max;
+ }
+ long res = 1;
+ for (int i = 1; i < n; i++) {
+ res = Math.max(res, left[i - 1] * right[i]);
+ }
+ return res;
+ }
+ private int[] manachers(String s) {
+ int len = s.length();
+ int[] P = new int[len];
+ int c = 0;
+ int r = 0;
+ for (int i = 0; i < len; i++) {
+ int mirror = (2 * c) - i;
+ if (i < r) {
+ P[i] = Math.min(r - i, P[mirror]);
+ }
+ int a = i + (1 + P[i]);
+ int b = i - (1 + P[i]);
+ while (a < len && b >= 0 && s.charAt(a) == s.charAt(b)) {
+ P[i]++;
+ a++;
+ b--;
+ }
+ if (i + P[i] > r) {
+ c = i;
+ r = i + P[i];
+ }
+ }
+ for (int i = 0; i < len; i++) {
+ P[i] = 1 + 2 * P[i];
+ }
+ return P;
+ }
+}
```
#### C++
```cpp
-
+class Solution {
+public:
+ long long maxProduct(string s) {
+ long long res = 0, l = 0, n = s.size();
+ vector m(n), r(n);
+
+ for (int i = 0, l = 0, r = -1; i < n; ++i) {
+ int k = (i > r) ? 1 : min(m[l + r - i], r - i + 1);
+ while (0 <= i - k && i + k < n && s[i - k] == s[i + k])
+ k++;
+ m[i] = k--;
+ if (i + k > r) {
+ l = i - k;
+ r = i + k;
+ }
+ }
+
+ queue> q, q1;
+
+ for (int i = n - 1; i >= 0; --i) {
+ while (!q.empty() && q.front()[0] - q.front()[1] > i - 1)
+ q.pop();
+ r[i] = 1 + (q.empty() ? 0 : (q.front()[0] - i) * 2);
+ q.push({i, m[i]});
+ }
+
+ for (int i = 0; i < n - 1; i++) {
+ while (!q1.empty() && q1.front()[0] + q1.front()[1] < i + 1)
+ q1.pop();
+ l = max(l, 1ll + (q1.empty() ? 0 : (i - q1.front()[0]) * 2));
+ res = max(res, l * r[i + 1]);
+ q1.push({i, m[i]});
+ }
+
+ return res;
+ }
+};
```
#### Go
```go
-
+func maxProduct(s string) int64 {
+ n := len(s)
+ hlen := make([]int, n)
+ center, right := 0, 0
+
+ for i := 0; i < n; i++ {
+ if i < right {
+ mirror := 2*center - i
+ if mirror >= 0 && mirror < n {
+ hlen[i] = min(right-i, hlen[mirror])
+ }
+ }
+ for i-1-hlen[i] >= 0 && i+1+hlen[i] < n && s[i-1-hlen[i]] == s[i+1+hlen[i]] {
+ hlen[i]++
+ }
+ if i+hlen[i] > right {
+ center = i
+ right = i + hlen[i]
+ }
+ }
+
+ prefix := make([]int, n)
+ suffix := make([]int, n)
+
+ for i := 0; i < n; i++ {
+ r := i + hlen[i]
+ if r < n {
+ prefix[r] = max(prefix[r], 2*hlen[i]+1)
+ }
+ l := i - hlen[i]
+ if l >= 0 {
+ suffix[l] = max(suffix[l], 2*hlen[i]+1)
+ }
+ }
+
+ for i := 1; i < n; i++ {
+ if n-i-1 >= 0 {
+ prefix[n-i-1] = max(prefix[n-i-1], prefix[n-i]-2)
+ }
+ suffix[i] = max(suffix[i], suffix[i-1]-2)
+ }
+
+ for i := 1; i < n; i++ {
+ prefix[i] = max(prefix[i-1], prefix[i])
+ suffix[n-i-1] = max(suffix[n-i], suffix[n-i-1])
+ }
+
+ var res int64
+ for i := 1; i < n; i++ {
+ prod := int64(prefix[i-1]) * int64(suffix[i])
+ if prod > res {
+ res = prod
+ }
+ }
+
+ return res
+}
```
diff --git a/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/Solution.cpp b/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/Solution.cpp
new file mode 100644
index 0000000000000..c287fd98d7883
--- /dev/null
+++ b/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/Solution.cpp
@@ -0,0 +1,37 @@
+class Solution {
+public:
+ long long maxProduct(string s) {
+ long long res = 0, l = 0, n = s.size();
+ vector m(n), r(n);
+
+ for (int i = 0, l = 0, r = -1; i < n; ++i) {
+ int k = (i > r) ? 1 : min(m[l + r - i], r - i + 1);
+ while (0 <= i - k && i + k < n && s[i - k] == s[i + k])
+ k++;
+ m[i] = k--;
+ if (i + k > r) {
+ l = i - k;
+ r = i + k;
+ }
+ }
+
+ queue> q, q1;
+
+ for (int i = n - 1; i >= 0; --i) {
+ while (!q.empty() && q.front()[0] - q.front()[1] > i - 1)
+ q.pop();
+ r[i] = 1 + (q.empty() ? 0 : (q.front()[0] - i) * 2);
+ q.push({i, m[i]});
+ }
+
+ for (int i = 0; i < n - 1; i++) {
+ while (!q1.empty() && q1.front()[0] + q1.front()[1] < i + 1)
+ q1.pop();
+ l = max(l, 1ll + (q1.empty() ? 0 : (i - q1.front()[0]) * 2));
+ res = max(res, l * r[i + 1]);
+ q1.push({i, m[i]});
+ }
+
+ return res;
+ }
+};
diff --git a/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/Solution.go b/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/Solution.go
new file mode 100644
index 0000000000000..56fa1a39b45cb
--- /dev/null
+++ b/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/Solution.go
@@ -0,0 +1,57 @@
+func maxProduct(s string) int64 {
+ n := len(s)
+ hlen := make([]int, n)
+ center, right := 0, 0
+
+ for i := 0; i < n; i++ {
+ if i < right {
+ mirror := 2*center - i
+ if mirror >= 0 && mirror < n {
+ hlen[i] = min(right-i, hlen[mirror])
+ }
+ }
+ for i-1-hlen[i] >= 0 && i+1+hlen[i] < n && s[i-1-hlen[i]] == s[i+1+hlen[i]] {
+ hlen[i]++
+ }
+ if i+hlen[i] > right {
+ center = i
+ right = i + hlen[i]
+ }
+ }
+
+ prefix := make([]int, n)
+ suffix := make([]int, n)
+
+ for i := 0; i < n; i++ {
+ r := i + hlen[i]
+ if r < n {
+ prefix[r] = max(prefix[r], 2*hlen[i]+1)
+ }
+ l := i - hlen[i]
+ if l >= 0 {
+ suffix[l] = max(suffix[l], 2*hlen[i]+1)
+ }
+ }
+
+ for i := 1; i < n; i++ {
+ if n-i-1 >= 0 {
+ prefix[n-i-1] = max(prefix[n-i-1], prefix[n-i]-2)
+ }
+ suffix[i] = max(suffix[i], suffix[i-1]-2)
+ }
+
+ for i := 1; i < n; i++ {
+ prefix[i] = max(prefix[i-1], prefix[i])
+ suffix[n-i-1] = max(suffix[n-i], suffix[n-i-1])
+ }
+
+ var res int64
+ for i := 1; i < n; i++ {
+ prod := int64(prefix[i-1]) * int64(suffix[i])
+ if prod > res {
+ res = prod
+ }
+ }
+
+ return res
+}
diff --git a/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/Solution.java b/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/Solution.java
new file mode 100644
index 0000000000000..7f6946576cbae
--- /dev/null
+++ b/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/Solution.java
@@ -0,0 +1,53 @@
+class Solution {
+ public long maxProduct(String s) {
+ int n = s.length();
+ if (n == 2) return 1;
+ int[] len = manachers(s);
+ long[] left = new long[n];
+ int max = 1;
+ left[0] = max;
+ for (int i = 1; i <= n - 1; i++) {
+ if (len[(i - max - 1 + i) / 2] > max) max += 2;
+ left[i] = max;
+ }
+ max = 1;
+ long[] right = new long[n];
+ right[n - 1] = max;
+ for (int i = n - 2; i >= 0; i--) {
+ if (len[(i + max + 1 + i) / 2] > max) max += 2;
+ right[i] = max;
+ }
+ long res = 1;
+ for (int i = 1; i < n; i++) {
+ res = Math.max(res, left[i - 1] * right[i]);
+ }
+ return res;
+ }
+ private int[] manachers(String s) {
+ int len = s.length();
+ int[] P = new int[len];
+ int c = 0;
+ int r = 0;
+ for (int i = 0; i < len; i++) {
+ int mirror = (2 * c) - i;
+ if (i < r) {
+ P[i] = Math.min(r - i, P[mirror]);
+ }
+ int a = i + (1 + P[i]);
+ int b = i - (1 + P[i]);
+ while (a < len && b >= 0 && s.charAt(a) == s.charAt(b)) {
+ P[i]++;
+ a++;
+ b--;
+ }
+ if (i + P[i] > r) {
+ c = i;
+ r = i + P[i];
+ }
+ }
+ for (int i = 0; i < len; i++) {
+ P[i] = 1 + 2 * P[i];
+ }
+ return P;
+ }
+}
diff --git a/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/Solution.py b/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/Solution.py
new file mode 100644
index 0000000000000..196786c37fecd
--- /dev/null
+++ b/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/Solution.py
@@ -0,0 +1,34 @@
+class Solution:
+ def maxProduct(self, s: str) -> int:
+ n = len(s)
+ hlen = [0] * n
+ center = right = 0
+
+ for i in range(n):
+ if i < right:
+ hlen[i] = min(right - i, hlen[2 * center - i])
+ while (
+ 0 <= i - 1 - hlen[i]
+ and i + 1 + hlen[i] < len(s)
+ and s[i - 1 - hlen[i]] == s[i + 1 + hlen[i]]
+ ):
+ hlen[i] += 1
+ if right < i + hlen[i]:
+ center, right = i, i + hlen[i]
+
+ prefix = [0] * n
+ suffix = [0] * n
+
+ for i in range(n):
+ prefix[i + hlen[i]] = max(prefix[i + hlen[i]], 2 * hlen[i] + 1)
+ suffix[i - hlen[i]] = max(suffix[i - hlen[i]], 2 * hlen[i] + 1)
+
+ for i in range(1, n):
+ prefix[~i] = max(prefix[~i], prefix[~i + 1] - 2)
+ suffix[i] = max(suffix[i], suffix[i - 1] - 2)
+
+ for i in range(1, n):
+ prefix[i] = max(prefix[i - 1], prefix[i])
+ suffix[~i] = max(suffix[~i], suffix[~i + 1])
+
+ return max(prefix[i - 1] * suffix[i] for i in range(1, n))
diff --git a/solution/1900-1999/1962.Remove Stones to Minimize the Total/README.md b/solution/1900-1999/1962.Remove Stones to Minimize the Total/README.md
index de6ec8f6b68bf..3ad285fcae654 100644
--- a/solution/1900-1999/1962.Remove Stones to Minimize the Total/README.md
+++ b/solution/1900-1999/1962.Remove Stones to Minimize the Total/README.md
@@ -23,14 +23,14 @@ tags:
给你一个整数数组 piles ，数组 下标从 0 开始 ，其中 piles[i] 表示第 i 堆石子中的石子数量。另给你一个整数 k ，请你执行下述操作 恰好 k 次：
- - 选出任一石子堆
piles[i] ，并从中 移除 ceil(piles[i] / 2) 颗石子。
+ - 选出任一石子堆
piles[i] ，并从中 移除 floor(piles[i] / 2) 颗石子。
注意：你可以对 同一堆 石子多次执行此操作。
返回执行 k 次操作后，剩下石子的 最小 总数。
-ceil(x) 为 大于 或 等于 x 的 最小 整数。（即，对 x 向上取整）。
+floor(x) 为 小于 或 等于 x 的 最大 整数。（即，对 x 向下取整）。
@@ -180,15 +180,14 @@ func (h *hp) pop() int { return heap.Pop(h).(int) }
```ts
function minStoneSum(piles: number[], k: number): number {
- const pq = new MaxPriorityQueue();
+ const pq = new MaxPriorityQueue();
for (const x of piles) {
pq.enqueue(x);
}
while (k--) {
- pq.enqueue((pq.dequeue().element + 1) >> 1);
+ pq.enqueue((pq.dequeue() + 1) >> 1);
}
-
- return pq.toArray().reduce((a, b) => a + b.element, 0);
+ return pq.toArray().reduce((a, b) => a + b, 0);
}
```
diff --git a/solution/1900-1999/1962.Remove Stones to Minimize the Total/README_EN.md b/solution/1900-1999/1962.Remove Stones to Minimize the Total/README_EN.md
index cc0e8df44b0fe..178cc9bc921b5 100644
--- a/solution/1900-1999/1962.Remove Stones to Minimize the Total/README_EN.md
+++ b/solution/1900-1999/1962.Remove Stones to Minimize the Total/README_EN.md
@@ -23,14 +23,14 @@ tags:
You are given a 0-indexed integer array piles, where piles[i] represents the number of stones in the ith pile, and an integer k. You should apply the following operation exactly k times:
- - Choose any
piles[i] and remove ceil(piles[i] / 2) stones from it.
+ - Choose any
piles[i] and remove floor(piles[i] / 2) stones from it.
Notice that you can apply the operation on the same pile more than once.
Return the minimum possible total number of stones remaining after applying the k operations.
-ceil(x) is the smallest integer that is greater than or equal to x (i.e., rounds x up).
+floor(x) is the largest integer that is smaller than or equal to x (i.e., rounds x down).
Example 1:
@@ -178,15 +178,14 @@ func (h *hp) pop() int { return heap.Pop(h).(int) }
```ts
function minStoneSum(piles: number[], k: number): number {
- const pq = new MaxPriorityQueue();
+ const pq = new MaxPriorityQueue();
for (const x of piles) {
pq.enqueue(x);
}
while (k--) {
- pq.enqueue((pq.dequeue().element + 1) >> 1);
+ pq.enqueue((pq.dequeue() + 1) >> 1);
}
-
- return pq.toArray().reduce((a, b) => a + b.element, 0);
+ return pq.toArray().reduce((a, b) => a + b, 0);
}
```
diff --git a/solution/1900-1999/1962.Remove Stones to Minimize the Total/Solution.ts b/solution/1900-1999/1962.Remove Stones to Minimize the Total/Solution.ts
index b15b74422286e..3b211ba768acb 100644
--- a/solution/1900-1999/1962.Remove Stones to Minimize the Total/Solution.ts
+++ b/solution/1900-1999/1962.Remove Stones to Minimize the Total/Solution.ts
@@ -1,11 +1,10 @@
function minStoneSum(piles: number[], k: number): number {
- const pq = new MaxPriorityQueue();
+ const pq = new MaxPriorityQueue();
for (const x of piles) {
pq.enqueue(x);
}
while (k--) {
- pq.enqueue((pq.dequeue().element + 1) >> 1);
+ pq.enqueue((pq.dequeue() + 1) >> 1);
}
-
- return pq.toArray().reduce((a, b) => a + b.element, 0);
+ return pq.toArray().reduce((a, b) => a + b, 0);
}
diff --git a/solution/1900-1999/1994.The Number of Good Subsets/README.md b/solution/1900-1999/1994.The Number of Good Subsets/README.md
index 8c088483d9df5..920daa2528416 100644
--- a/solution/1900-1999/1994.The Number of Good Subsets/README.md
+++ b/solution/1900-1999/1994.The Number of Good Subsets/README.md
@@ -7,9 +7,12 @@ source: 第 60 场双周赛 Q4
tags:
- 位运算
- 数组
+ - 哈希表
- 数学
- 动态规划
- 状态压缩
+ - 计数
+ - 数论
---
diff --git a/solution/1900-1999/1994.The Number of Good Subsets/README_EN.md b/solution/1900-1999/1994.The Number of Good Subsets/README_EN.md
index 3db69382669c8..8f3fb8866e50e 100644
--- a/solution/1900-1999/1994.The Number of Good Subsets/README_EN.md
+++ b/solution/1900-1999/1994.The Number of Good Subsets/README_EN.md
@@ -7,9 +7,12 @@ source: Biweekly Contest 60 Q4
tags:
- Bit Manipulation
- Array
+ - Hash Table
- Math
- Dynamic Programming
- Bitmask
+ - Counting
+ - Number Theory
---
diff --git a/solution/2000-2099/2019.The Score of Students Solving Math Expression/README.md b/solution/2000-2099/2019.The Score of Students Solving Math Expression/README.md
index 3f98e3762a616..3bc0c67f8f974 100644
--- a/solution/2000-2099/2019.The Score of Students Solving Math Expression/README.md
+++ b/solution/2000-2099/2019.The Score of Students Solving Math Expression/README.md
@@ -8,6 +8,7 @@ tags:
- 栈
- 记忆化搜索
- 数组
+ - 哈希表
- 数学
- 字符串
- 动态规划
@@ -44,9 +45,10 @@ tags:
示例 1：
-
+
-输入：s = "7+3*1*2", answers = [20,13,42]
+
+输入：s = "7+3*1*2", answers = [20,13,42]
输出：7
解释：如上图所示，正确答案为 13 ，因此有一位学生得分为 5 分：[20,13,42] 。
一位学生可能通过错误的运算顺序得到结果 20 ：7+3=10，10*1=10，10*2=20 。所以这位学生得分为 2 分：[20,13,42] 。
@@ -55,7 +57,8 @@ tags:
示例 2：
-输入：s = "3+5*2", answers = [13,0,10,13,13,16,16]
+
+输入：s = "3+5*2", answers = [13,0,10,13,13,16,16]
输出：19
解释：表达式的正确结果为 13 ，所以有 3 位学生得到 5 分：[13,0,10,13,13,16,16] 。
学生可能通过错误的运算顺序得到结果 16 ：3+5=8，8*2=16 。所以两位学生得到 2 分：[13,0,10,13,13,16,16] 。
@@ -64,7 +67,8 @@ tags:
示例 3：
-输入：s = "6+0*1", answers = [12,9,6,4,8,6]
+
+输入：s = "6+0*1", answers = [12,9,6,4,8,6]
输出：10
解释：表达式的正确结果为 6 。
如果一位学生通过错误的运算顺序计算该表达式，结果仍为 6 。
@@ -82,6 +86,7 @@ tags:
表达式中所有整数运算数字都在闭区间 [0, 9] 以内。
1 <= 数学表达式中所有运算符数目（'+' 和 '*'） <= 15
测试数据保证正确表达式结果在范围 [0, 1000] 以内。
+ 测试用例保证乘法中间步骤中的值永远不会超过 109。
n == answers.length
1 <= n <= 104
0 <= answers[i] <= 1000
diff --git a/solution/2000-2099/2019.The Score of Students Solving Math Expression/README_EN.md b/solution/2000-2099/2019.The Score of Students Solving Math Expression/README_EN.md
index 57471129cdde4..4f97ba51de745 100644
--- a/solution/2000-2099/2019.The Score of Students Solving Math Expression/README_EN.md
+++ b/solution/2000-2099/2019.The Score of Students Solving Math Expression/README_EN.md
@@ -8,6 +8,7 @@ tags:
- Stack
- Memoization
- Array
+ - Hash Table
- Math
- String
- Dynamic Programming
@@ -81,6 +82,7 @@ The points for the students are: [0,0,5,0,0,5]. The sum of the points is 10.
All the integer operands in the expression are in the inclusive range [0, 9].
1 <= The count of all operators ('+' and '*') in the math expression <= 15
Test data are generated such that the correct answer of the expression is in the range of [0, 1000].
+ Test data are generated such that value never exceeds 109 in intermediate steps of multiplication.
n == answers.length
1 <= n <= 104
0 <= answers[i] <= 1000
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/README.md b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/README.md
index e2c3dbe051e3e..25d2759b63984 100644
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/README.md
+++ b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/README.md
@@ -77,9 +77,15 @@ tags:
### 方法一：DFS
-简单 DFS。可以预先算出按位或的最大值 mx，然后 DFS 搜索按位或结果等于 mx 的所有子集数。也可以在 DFS 搜索中逐渐更新 mx 与对应的子集数。
+数组 $\textit{nums}$ 中按位或的最大值 $\textit{mx}$ 可以通过对数组中所有元素按位或得到。
-时间复杂度 $O(2^n)$。
+然后我们可以使用深度优先搜索来枚举所有子集，统计按位或等于 $\textit{mx}$ 的子集个数。我们设计一个函数 $\text{dfs(i, t)}$，表示从下标 $\textit{i}$ 开始，当前按位或的值为 $\textit{t}$ 的子集个数。初始时 $\textit{i} = 0$, $\textit{t} = 0$。
+
+在函数 $\text{dfs(i, t)}$ 中，如果 $\textit{i}$ 等于数组长度，说明已经枚举完所有元素，此时如果 $\textit{t}$ 等于 $\textit{mx}$，则答案加一。否则，我们可以选择不包含当前元素 $\textit{nums[i]}$，或者包含当前元素 $\textit{nums[i]}$，因此我们可以递归调用 $\text{dfs(i + 1, t)}$ 和 $\text{dfs(i + 1, t | nums[i])}$。
+
+最后返回答案即可。
+
+时间复杂度 $O(2^n)$，空间复杂度 $O(n)$。其中 $n$ 是数组 $\textit{nums}$ 的长度。
@@ -88,12 +94,8 @@ tags:
```python
class Solution:
def countMaxOrSubsets(self, nums: List[int]) -> int:
- mx = ans = 0
- for x in nums:
- mx |= x
-
def dfs(i, t):
- nonlocal mx, ans
+ nonlocal ans, mx
if i == len(nums):
if t == mx:
ans += 1
@@ -101,6 +103,8 @@ class Solution:
dfs(i + 1, t)
dfs(i + 1, t | nums[i])
+ ans = 0
+ mx = reduce(lambda x, y: x | y, nums)
dfs(0, 0)
return ans
```
@@ -141,35 +145,30 @@ class Solution {
```cpp
class Solution {
public:
- int mx;
- int ans;
- vector nums;
-
int countMaxOrSubsets(vector& nums) {
- this->nums = nums;
- mx = 0;
- ans = 0;
- for (int x : nums) mx |= x;
+ int ans = 0;
+ int mx = accumulate(nums.begin(), nums.end(), 0, bit_or());
+ auto dfs = [&](this auto&& dfs, int i, int t) {
+ if (i == nums.size()) {
+ if (t == mx) {
+ ans++;
+ }
+ return;
+ }
+ dfs(i + 1, t);
+ dfs(i + 1, t | nums[i]);
+ };
dfs(0, 0);
return ans;
}
-
- void dfs(int i, int t) {
- if (i == nums.size()) {
- if (t == mx) ++ans;
- return;
- }
- dfs(i + 1, t);
- dfs(i + 1, t | nums[i]);
- }
};
```
#### Go
```go
-func countMaxOrSubsets(nums []int) int {
- mx, ans := 0, 0
+func countMaxOrSubsets(nums []int) (ans int) {
+ mx := 0
for _, x := range nums {
mx |= x
}
@@ -187,7 +186,7 @@ func countMaxOrSubsets(nums []int) int {
}
dfs(0, 0)
- return ans
+ return
}
```
@@ -195,20 +194,20 @@ func countMaxOrSubsets(nums []int) int {
```ts
function countMaxOrSubsets(nums: number[]): number {
- let n = nums.length;
- let max = 0;
- for (let i = 0; i < n; i++) {
- max |= nums[i];
- }
let ans = 0;
- function dfs(pre: number, depth: number): void {
- if (depth == n) {
- if (pre == max) ++ans;
+ const mx = nums.reduce((x, y) => x | y, 0);
+
+ const dfs = (i: number, t: number) => {
+ if (i === nums.length) {
+ if (t === mx) {
+ ans++;
+ }
return;
}
- dfs(pre, depth + 1);
- dfs(pre | nums[depth], depth + 1);
- }
+ dfs(i + 1, t);
+ dfs(i + 1, t | nums[i]);
+ };
+
dfs(0, 0);
return ans;
}
@@ -218,33 +217,23 @@ function countMaxOrSubsets(nums: number[]): number {
```rust
impl Solution {
- fn dfs(nums: &Vec, i: usize, sum: i32) -> (i32, i32) {
- let n = nums.len();
- let mut max = i32::MIN;
- let mut res = 0;
- for j in i..n {
- let num = sum | nums[j];
- if num >= max {
- if num > max {
- max = num;
- res = 0;
- }
- res += 1;
- }
- let (r_max, r_res) = Self::dfs(nums, j + 1, num);
- if r_max >= max {
- if r_max > max {
- max = r_max;
- res = 0;
+ pub fn count_max_or_subsets(nums: Vec) -> i32 {
+ let mut ans = 0;
+ let mx = nums.iter().fold(0, |x, &y| x | y);
+
+ fn dfs(i: usize, t: i32, nums: &Vec, mx: i32, ans: &mut i32) {
+ if i == nums.len() {
+ if t == mx {
+ *ans += 1;
}
- res += r_res;
+ return;
}
+ dfs(i + 1, t, nums, mx, ans);
+ dfs(i + 1, t | nums[i], nums, mx, ans);
}
- (max, res)
- }
- pub fn count_max_or_subsets(nums: Vec) -> i32 {
- Self::dfs(&nums, 0, 0).1
+ dfs(0, 0, &nums, mx, &mut ans);
+ ans
}
}
```
@@ -257,147 +246,11 @@ impl Solution {
### 方法二：二进制枚举
-时间复杂度 $O(n*2^n)$。
+我们可以使用二进制枚举来统计所有子集的按位或结果。对于长度为 $n$ 的数组 $\textit{nums}$，我们可以使用一个整数 $\textit{mask}$ 来表示一个子集，其中 $\textit{mask}$ 的第 $i$ 位为 1 表示包含元素 $\textit{nums[i]}$，为 0 则表示不包含。
-
+我们可以遍历所有可能的 $\textit{mask}$，从 $0$ 到 $2^n - 1$。对于每个 $\textit{mask}$，我们可以计算出对应子集的按位或结果，并更新最大值 $\textit{mx}$ 和答案 $\textit{ans}$。
-#### Python3
-
-```python
-class Solution:
- def countMaxOrSubsets(self, nums: List[int]) -> int:
- def dfs(u, t):
- nonlocal ans, mx
- if u == len(nums):
- if t > mx:
- mx, ans = t, 1
- elif t == mx:
- ans += 1
- return
- dfs(u + 1, t | nums[u])
- dfs(u + 1, t)
-
- ans = mx = 0
- dfs(0, 0)
- return ans
-```
-
-#### Java
-
-```java
-class Solution {
- private int mx;
- private int ans;
- private int[] nums;
-
- public int countMaxOrSubsets(int[] nums) {
- this.nums = nums;
- dfs(0, 0);
- return ans;
- }
-
- private void dfs(int u, int t) {
- if (u == nums.length) {
- if (t > mx) {
- mx = t;
- ans = 1;
- } else if (t == mx) {
- ++ans;
- }
- return;
- }
- dfs(u + 1, t);
- dfs(u + 1, t | nums[u]);
- }
-}
-```
-
-#### C++
-
-```cpp
-class Solution {
-public:
- int mx;
- int ans;
-
- int countMaxOrSubsets(vector& nums) {
- dfs(0, 0, nums);
- return ans;
- }
-
- void dfs(int u, int t, vector& nums) {
- if (u == nums.size()) {
- if (t > mx) {
- mx = t;
- ans = 1;
- } else if (t == mx)
- ++ans;
- return;
- }
- dfs(u + 1, t, nums);
- dfs(u + 1, t | nums[u], nums);
- }
-};
-```
-
-#### Go
-
-```go
-func countMaxOrSubsets(nums []int) int {
- n := len(nums)
- ans := 0
- mx := 0
- for mask := 1; mask < 1<> i) & 1) == 1 {
- t |= v
- }
- }
- if mx < t {
- mx = t
- ans = 1
- } else if mx == t {
- ans++
- }
- }
- return ans
-}
-```
-
-#### TypeScript
-
-```ts
-function countMaxOrSubsets(nums: number[]): number {
- const n = nums.length;
- let res = 0;
- let max = -Infinity;
- const dfs = (i: number, sum: number) => {
- for (let j = i; j < n; j++) {
- const num = sum | nums[j];
- if (num >= max) {
- if (num > max) {
- max = num;
- res = 0;
- }
- res++;
- }
- dfs(j + 1, num);
- }
- };
- dfs(0, 0);
-
- return res;
-}
-```
-
-
-
-
-
-
-
-### 方法三
+时间复杂度 $O(2^n \cdot n)$，其中 $n$ 是数组 $\textit{nums}$ 的长度。空间复杂度 $O(1)$。
@@ -479,23 +332,82 @@ public:
#### Go
```go
-func countMaxOrSubsets(nums []int) int {
- mx, ans := 0, 0
- var dfs func(u, t int)
- dfs = func(u, t int) {
- if u == len(nums) {
- if t > mx {
- mx, ans = t, 1
- } else if t == mx {
- ans++
+func countMaxOrSubsets(nums []int) (ans int) {
+ n := len(nums)
+ mx := 0
+
+ for mask := 0; mask < (1 << n); mask++ {
+ t := 0
+ for i, v := range nums {
+ if (mask>>i)&1 == 1 {
+ t |= v
}
- return
}
- dfs(u+1, t)
- dfs(u+1, t|nums[u])
+ if mx < t {
+ mx = t
+ ans = 1
+ } else if mx == t {
+ ans++
+ }
}
- dfs(0, 0)
- return ans
+
+ return
+}
+```
+
+#### TypeScript
+
+```ts
+function countMaxOrSubsets(nums: number[]): number {
+ const n = nums.length;
+ let ans = 0;
+ let mx = 0;
+
+ for (let mask = 0; mask < 1 << n; mask++) {
+ let t = 0;
+ for (let i = 0; i < n; i++) {
+ if ((mask >> i) & 1) {
+ t |= nums[i];
+ }
+ }
+ if (mx < t) {
+ mx = t;
+ ans = 1;
+ } else if (mx === t) {
+ ans++;
+ }
+ }
+
+ return ans;
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+ pub fn count_max_or_subsets(nums: Vec) -> i32 {
+ let n = nums.len();
+ let mut ans = 0;
+ let mut mx = 0;
+
+ for mask in 0..(1 << n) {
+ let mut t = 0;
+ for i in 0..n {
+ if (mask >> i) & 1 == 1 {
+ t |= nums[i];
+ }
+ }
+ if mx < t {
+ mx = t;
+ ans = 1;
+ } else if mx == t {
+ ans += 1;
+ }
+ }
+
+ ans
+ }
}
```
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/README_EN.md b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/README_EN.md
index 8f9aa2c0c8fa3..210bb8e736522 100644
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/README_EN.md
+++ b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/README_EN.md
@@ -73,7 +73,17 @@ tags:
-### Solution 1
+### Solution 1: DFS
+
+The maximum bitwise OR value $\textit{mx}$ in the array $\textit{nums}$ can be obtained by performing bitwise OR on all elements in the array.
+
+Then we can use depth-first search to enumerate all subsets and count the number of subsets whose bitwise OR equals $\textit{mx}$. We design a function $\text{dfs(i, t)}$, which represents the number of subsets starting from index $\textit{i}$ with the current bitwise OR value being $\textit{t}$. Initially, $\textit{i} = 0$ and $\textit{t} = 0$.
+
+In the function $\text{dfs(i, t)}$, if $\textit{i}$ equals the array length, it means we have enumerated all elements. At this point, if $\textit{t}$ equals $\textit{mx}$, we increment the answer by one. Otherwise, we can choose to either exclude the current element $\textit{nums[i]}$ or include the current element $\textit{nums[i]}$, so we can recursively call $\text{dfs(i + 1, t)}$ and $\text{dfs(i + 1, t | nums[i])}$.
+
+Finally, we return the answer.
+
+The time complexity is $O(2^n)$, and the space complexity is $O(n)$, where $n$ is the length of the array $\textit{nums}$.
@@ -82,12 +92,8 @@ tags:
```python
class Solution:
def countMaxOrSubsets(self, nums: List[int]) -> int:
- mx = ans = 0
- for x in nums:
- mx |= x
-
def dfs(i, t):
- nonlocal mx, ans
+ nonlocal ans, mx
if i == len(nums):
if t == mx:
ans += 1
@@ -95,6 +101,8 @@ class Solution:
dfs(i + 1, t)
dfs(i + 1, t | nums[i])
+ ans = 0
+ mx = reduce(lambda x, y: x | y, nums)
dfs(0, 0)
return ans
```
@@ -135,35 +143,30 @@ class Solution {
```cpp
class Solution {
public:
- int mx;
- int ans;
- vector nums;
-
int countMaxOrSubsets(vector& nums) {
- this->nums = nums;
- mx = 0;
- ans = 0;
- for (int x : nums) mx |= x;
+ int ans = 0;
+ int mx = accumulate(nums.begin(), nums.end(), 0, bit_or());
+ auto dfs = [&](this auto&& dfs, int i, int t) {
+ if (i == nums.size()) {
+ if (t == mx) {
+ ans++;
+ }
+ return;
+ }
+ dfs(i + 1, t);
+ dfs(i + 1, t | nums[i]);
+ };
dfs(0, 0);
return ans;
}
-
- void dfs(int i, int t) {
- if (i == nums.size()) {
- if (t == mx) ++ans;
- return;
- }
- dfs(i + 1, t);
- dfs(i + 1, t | nums[i]);
- }
};
```
#### Go
```go
-func countMaxOrSubsets(nums []int) int {
- mx, ans := 0, 0
+func countMaxOrSubsets(nums []int) (ans int) {
+ mx := 0
for _, x := range nums {
mx |= x
}
@@ -181,7 +184,7 @@ func countMaxOrSubsets(nums []int) int {
}
dfs(0, 0)
- return ans
+ return
}
```
@@ -189,20 +192,20 @@ func countMaxOrSubsets(nums []int) int {
```ts
function countMaxOrSubsets(nums: number[]): number {
- let n = nums.length;
- let max = 0;
- for (let i = 0; i < n; i++) {
- max |= nums[i];
- }
let ans = 0;
- function dfs(pre: number, depth: number): void {
- if (depth == n) {
- if (pre == max) ++ans;
+ const mx = nums.reduce((x, y) => x | y, 0);
+
+ const dfs = (i: number, t: number) => {
+ if (i === nums.length) {
+ if (t === mx) {
+ ans++;
+ }
return;
}
- dfs(pre, depth + 1);
- dfs(pre | nums[depth], depth + 1);
- }
+ dfs(i + 1, t);
+ dfs(i + 1, t | nums[i]);
+ };
+
dfs(0, 0);
return ans;
}
@@ -212,33 +215,23 @@ function countMaxOrSubsets(nums: number[]): number {
```rust
impl Solution {
- fn dfs(nums: &Vec, i: usize, sum: i32) -> (i32, i32) {
- let n = nums.len();
- let mut max = i32::MIN;
- let mut res = 0;
- for j in i..n {
- let num = sum | nums[j];
- if num >= max {
- if num > max {
- max = num;
- res = 0;
- }
- res += 1;
- }
- let (r_max, r_res) = Self::dfs(nums, j + 1, num);
- if r_max >= max {
- if r_max > max {
- max = r_max;
- res = 0;
+ pub fn count_max_or_subsets(nums: Vec) -> i32 {
+ let mut ans = 0;
+ let mx = nums.iter().fold(0, |x, &y| x | y);
+
+ fn dfs(i: usize, t: i32, nums: &Vec, mx: i32, ans: &mut i32) {
+ if i == nums.len() {
+ if t == mx {
+ *ans += 1;
}
- res += r_res;
+ return;
}
+ dfs(i + 1, t, nums, mx, ans);
+ dfs(i + 1, t | nums[i], nums, mx, ans);
}
- (max, res)
- }
- pub fn count_max_or_subsets(nums: Vec) -> i32 {
- Self::dfs(&nums, 0, 0).1
+ dfs(0, 0, &nums, mx, &mut ans);
+ ans
}
}
```
@@ -249,147 +242,13 @@ impl Solution {
-### Solution 2
-
-
-
-#### Python3
-
-```python
-class Solution:
- def countMaxOrSubsets(self, nums: List[int]) -> int:
- def dfs(u, t):
- nonlocal ans, mx
- if u == len(nums):
- if t > mx:
- mx, ans = t, 1
- elif t == mx:
- ans += 1
- return
- dfs(u + 1, t | nums[u])
- dfs(u + 1, t)
-
- ans = mx = 0
- dfs(0, 0)
- return ans
-```
-
-#### Java
-
-```java
-class Solution {
- private int mx;
- private int ans;
- private int[] nums;
-
- public int countMaxOrSubsets(int[] nums) {
- this.nums = nums;
- dfs(0, 0);
- return ans;
- }
-
- private void dfs(int u, int t) {
- if (u == nums.length) {
- if (t > mx) {
- mx = t;
- ans = 1;
- } else if (t == mx) {
- ++ans;
- }
- return;
- }
- dfs(u + 1, t);
- dfs(u + 1, t | nums[u]);
- }
-}
-```
-
-#### C++
-
-```cpp
-class Solution {
-public:
- int mx;
- int ans;
-
- int countMaxOrSubsets(vector& nums) {
- dfs(0, 0, nums);
- return ans;
- }
-
- void dfs(int u, int t, vector& nums) {
- if (u == nums.size()) {
- if (t > mx) {
- mx = t;
- ans = 1;
- } else if (t == mx)
- ++ans;
- return;
- }
- dfs(u + 1, t, nums);
- dfs(u + 1, t | nums[u], nums);
- }
-};
-```
-
-#### Go
-
-```go
-func countMaxOrSubsets(nums []int) int {
- n := len(nums)
- ans := 0
- mx := 0
- for mask := 1; mask < 1<> i) & 1) == 1 {
- t |= v
- }
- }
- if mx < t {
- mx = t
- ans = 1
- } else if mx == t {
- ans++
- }
- }
- return ans
-}
-```
-
-#### TypeScript
+### Solution 2: Binary Enumeration
-```ts
-function countMaxOrSubsets(nums: number[]): number {
- const n = nums.length;
- let res = 0;
- let max = -Infinity;
- const dfs = (i: number, sum: number) => {
- for (let j = i; j < n; j++) {
- const num = sum | nums[j];
- if (num >= max) {
- if (num > max) {
- max = num;
- res = 0;
- }
- res++;
- }
- dfs(j + 1, num);
- }
- };
- dfs(0, 0);
+We can use binary enumeration to count the bitwise OR results of all subsets. For an array $\textit{nums}$ of length $n$, we can use an integer $\textit{mask}$ to represent a subset, where the $i$-th bit of $\textit{mask}$ being 1 means including element $\textit{nums[i]}$, and 0 means not including it.
- return res;
-}
-```
+We can iterate through all possible $\textit{mask}$ values from $0$ to $2^n - 1$. For each $\textit{mask}$, we can calculate the bitwise OR result of the corresponding subset and update the maximum value $\textit{mx}$ and answer $\textit{ans}$.
-
-
-
-
-
-
-### Solution 3
+The time complexity is $O(2^n \cdot n)$, where $n$ is the length of the array $\textit{nums}$. The space complexity is $O(1)$.
@@ -471,23 +330,82 @@ public:
#### Go
```go
-func countMaxOrSubsets(nums []int) int {
- mx, ans := 0, 0
- var dfs func(u, t int)
- dfs = func(u, t int) {
- if u == len(nums) {
- if t > mx {
- mx, ans = t, 1
- } else if t == mx {
- ans++
+func countMaxOrSubsets(nums []int) (ans int) {
+ n := len(nums)
+ mx := 0
+
+ for mask := 0; mask < (1 << n); mask++ {
+ t := 0
+ for i, v := range nums {
+ if (mask>>i)&1 == 1 {
+ t |= v
}
- return
}
- dfs(u+1, t)
- dfs(u+1, t|nums[u])
+ if mx < t {
+ mx = t
+ ans = 1
+ } else if mx == t {
+ ans++
+ }
}
- dfs(0, 0)
- return ans
+
+ return
+}
+```
+
+#### TypeScript
+
+```ts
+function countMaxOrSubsets(nums: number[]): number {
+ const n = nums.length;
+ let ans = 0;
+ let mx = 0;
+
+ for (let mask = 0; mask < 1 << n; mask++) {
+ let t = 0;
+ for (let i = 0; i < n; i++) {
+ if ((mask >> i) & 1) {
+ t |= nums[i];
+ }
+ }
+ if (mx < t) {
+ mx = t;
+ ans = 1;
+ } else if (mx === t) {
+ ans++;
+ }
+ }
+
+ return ans;
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+ pub fn count_max_or_subsets(nums: Vec) -> i32 {
+ let n = nums.len();
+ let mut ans = 0;
+ let mut mx = 0;
+
+ for mask in 0..(1 << n) {
+ let mut t = 0;
+ for i in 0..n {
+ if (mask >> i) & 1 == 1 {
+ t |= nums[i];
+ }
+ }
+ if mx < t {
+ mx = t;
+ ans = 1;
+ } else if mx == t {
+ ans += 1;
+ }
+ }
+
+ ans
+ }
}
```
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.cpp b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.cpp
index c8939eb26024f..4e32478c50149 100644
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.cpp
+++ b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.cpp
@@ -1,24 +1,19 @@
class Solution {
public:
- int mx;
- int ans;
- vector nums;
-
int countMaxOrSubsets(vector& nums) {
- this->nums = nums;
- mx = 0;
- ans = 0;
- for (int x : nums) mx |= x;
+ int ans = 0;
+ int mx = accumulate(nums.begin(), nums.end(), 0, bit_or());
+ auto dfs = [&](this auto&& dfs, int i, int t) {
+ if (i == nums.size()) {
+ if (t == mx) {
+ ans++;
+ }
+ return;
+ }
+ dfs(i + 1, t);
+ dfs(i + 1, t | nums[i]);
+ };
dfs(0, 0);
return ans;
}
-
- void dfs(int i, int t) {
- if (i == nums.size()) {
- if (t == mx) ++ans;
- return;
- }
- dfs(i + 1, t);
- dfs(i + 1, t | nums[i]);
- }
-};
\ No newline at end of file
+};
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.go b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.go
index 19cc168adee93..88813db6ec65e 100644
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.go
+++ b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.go
@@ -1,5 +1,5 @@
-func countMaxOrSubsets(nums []int) int {
- mx, ans := 0, 0
+func countMaxOrSubsets(nums []int) (ans int) {
+ mx := 0
for _, x := range nums {
mx |= x
}
@@ -17,5 +17,5 @@ func countMaxOrSubsets(nums []int) int {
}
dfs(0, 0)
- return ans
+ return
}
\ No newline at end of file
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.py b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.py
index 334d606fccb6b..c8718ffec466c 100644
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.py
+++ b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.py
@@ -1,11 +1,7 @@
class Solution:
def countMaxOrSubsets(self, nums: List[int]) -> int:
- mx = ans = 0
- for x in nums:
- mx |= x
-
def dfs(i, t):
- nonlocal mx, ans
+ nonlocal ans, mx
if i == len(nums):
if t == mx:
ans += 1
@@ -13,5 +9,7 @@ def dfs(i, t):
dfs(i + 1, t)
dfs(i + 1, t | nums[i])
+ ans = 0
+ mx = reduce(lambda x, y: x | y, nums)
dfs(0, 0)
return ans
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.rs b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.rs
index 9132d7dd6b653..4362bfdb0cdd8 100644
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.rs
+++ b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.rs
@@ -1,30 +1,20 @@
impl Solution {
- fn dfs(nums: &Vec, i: usize, sum: i32) -> (i32, i32) {
- let n = nums.len();
- let mut max = i32::MIN;
- let mut res = 0;
- for j in i..n {
- let num = sum | nums[j];
- if num >= max {
- if num > max {
- max = num;
- res = 0;
- }
- res += 1;
- }
- let (r_max, r_res) = Self::dfs(nums, j + 1, num);
- if r_max >= max {
- if r_max > max {
- max = r_max;
- res = 0;
+ pub fn count_max_or_subsets(nums: Vec) -> i32 {
+ let mut ans = 0;
+ let mx = nums.iter().fold(0, |x, &y| x | y);
+
+ fn dfs(i: usize, t: i32, nums: &Vec, mx: i32, ans: &mut i32) {
+ if i == nums.len() {
+ if t == mx {
+ *ans += 1;
}
- res += r_res;
+ return;
}
+ dfs(i + 1, t, nums, mx, ans);
+ dfs(i + 1, t | nums[i], nums, mx, ans);
}
- (max, res)
- }
- pub fn count_max_or_subsets(nums: Vec) -> i32 {
- Self::dfs(&nums, 0, 0).1
+ dfs(0, 0, &nums, mx, &mut ans);
+ ans
}
}
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.ts b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.ts
index 7892d8fa13ba1..fca84d99fb8d7 100644
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.ts
+++ b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.ts
@@ -1,18 +1,18 @@
function countMaxOrSubsets(nums: number[]): number {
- let n = nums.length;
- let max = 0;
- for (let i = 0; i < n; i++) {
- max |= nums[i];
- }
let ans = 0;
- function dfs(pre: number, depth: number): void {
- if (depth == n) {
- if (pre == max) ++ans;
+ const mx = nums.reduce((x, y) => x | y, 0);
+
+ const dfs = (i: number, t: number) => {
+ if (i === nums.length) {
+ if (t === mx) {
+ ans++;
+ }
return;
}
- dfs(pre, depth + 1);
- dfs(pre | nums[depth], depth + 1);
- }
+ dfs(i + 1, t);
+ dfs(i + 1, t | nums[i]);
+ };
+
dfs(0, 0);
return ans;
}
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.cpp b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.cpp
index c8e8122f8587b..aebbbcaebe217 100644
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.cpp
+++ b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.cpp
@@ -1,23 +1,22 @@
class Solution {
public:
- int mx;
- int ans;
-
int countMaxOrSubsets(vector& nums) {
- dfs(0, 0, nums);
- return ans;
- }
-
- void dfs(int u, int t, vector& nums) {
- if (u == nums.size()) {
- if (t > mx) {
+ int n = nums.size();
+ int ans = 0;
+ int mx = 0;
+ for (int mask = 1; mask < 1 << n; ++mask) {
+ int t = 0;
+ for (int i = 0; i < n; ++i) {
+ if ((mask >> i) & 1) {
+ t |= nums[i];
+ }
+ }
+ if (mx < t) {
mx = t;
ans = 1;
- } else if (t == mx)
+ } else if (mx == t)
++ans;
- return;
}
- dfs(u + 1, t, nums);
- dfs(u + 1, t | nums[u], nums);
+ return ans;
}
};
\ No newline at end of file
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.go b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.go
index d017ea1ba963b..ecd53632e8a91 100644
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.go
+++ b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.go
@@ -1,11 +1,11 @@
-func countMaxOrSubsets(nums []int) int {
+func countMaxOrSubsets(nums []int) (ans int) {
n := len(nums)
- ans := 0
mx := 0
- for mask := 1; mask < 1<> i) & 1) == 1 {
+ if (mask>>i)&1 == 1 {
t |= v
}
}
@@ -16,5 +16,6 @@ func countMaxOrSubsets(nums []int) int {
ans++
}
}
- return ans
-}
\ No newline at end of file
+
+ return
+}
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.java b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.java
index 75143a8b30763..401802a01543c 100644
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.java
+++ b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.java
@@ -1,25 +1,22 @@
class Solution {
- private int mx;
- private int ans;
- private int[] nums;
-
public int countMaxOrSubsets(int[] nums) {
- this.nums = nums;
- dfs(0, 0);
- return ans;
- }
-
- private void dfs(int u, int t) {
- if (u == nums.length) {
- if (t > mx) {
+ int n = nums.length;
+ int ans = 0;
+ int mx = 0;
+ for (int mask = 1; mask < 1 << n; ++mask) {
+ int t = 0;
+ for (int i = 0; i < n; ++i) {
+ if (((mask >> i) & 1) == 1) {
+ t |= nums[i];
+ }
+ }
+ if (mx < t) {
mx = t;
ans = 1;
- } else if (t == mx) {
+ } else if (mx == t) {
++ans;
}
- return;
}
- dfs(u + 1, t);
- dfs(u + 1, t | nums[u]);
+ return ans;
}
}
\ No newline at end of file
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.py b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.py
index c7fb372d8f204..7f6b040cf392b 100644
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.py
+++ b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.py
@@ -1,16 +1,16 @@
class Solution:
def countMaxOrSubsets(self, nums: List[int]) -> int:
- def dfs(u, t):
- nonlocal ans, mx
- if u == len(nums):
- if t > mx:
- mx, ans = t, 1
- elif t == mx:
- ans += 1
- return
- dfs(u + 1, t | nums[u])
- dfs(u + 1, t)
-
- ans = mx = 0
- dfs(0, 0)
+ n = len(nums)
+ ans = 0
+ mx = 0
+ for mask in range(1 << n):
+ t = 0
+ for i, v in enumerate(nums):
+ if (mask >> i) & 1:
+ t |= v
+ if mx < t:
+ mx = t
+ ans = 1
+ elif mx == t:
+ ans += 1
return ans
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.rs b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.rs
new file mode 100644
index 0000000000000..d924bfcf3befa
--- /dev/null
+++ b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.rs
@@ -0,0 +1,24 @@
+impl Solution {
+ pub fn count_max_or_subsets(nums: Vec) -> i32 {
+ let n = nums.len();
+ let mut ans = 0;
+ let mut mx = 0;
+
+ for mask in 0..(1 << n) {
+ let mut t = 0;
+ for i in 0..n {
+ if (mask >> i) & 1 == 1 {
+ t |= nums[i];
+ }
+ }
+ if mx < t {
+ mx = t;
+ ans = 1;
+ } else if mx == t {
+ ans += 1;
+ }
+ }
+
+ ans
+ }
+}
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.ts b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.ts
index e3c35b2161906..3da88b9c02132 100644
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.ts
+++ b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.ts
@@ -1,21 +1,22 @@
function countMaxOrSubsets(nums: number[]): number {
const n = nums.length;
- let res = 0;
- let max = -Infinity;
- const dfs = (i: number, sum: number) => {
- for (let j = i; j < n; j++) {
- const num = sum | nums[j];
- if (num >= max) {
- if (num > max) {
- max = num;
- res = 0;
- }
- res++;
+ let ans = 0;
+ let mx = 0;
+
+ for (let mask = 0; mask < 1 << n; mask++) {
+ let t = 0;
+ for (let i = 0; i < n; i++) {
+ if ((mask >> i) & 1) {
+ t |= nums[i];
}
- dfs(j + 1, num);
}
- };
- dfs(0, 0);
+ if (mx < t) {
+ mx = t;
+ ans = 1;
+ } else if (mx === t) {
+ ans++;
+ }
+ }
- return res;
+ return ans;
}
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution3.cpp b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution3.cpp
deleted file mode 100644
index aebbbcaebe217..0000000000000
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution3.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-class Solution {
-public:
- int countMaxOrSubsets(vector& nums) {
- int n = nums.size();
- int ans = 0;
- int mx = 0;
- for (int mask = 1; mask < 1 << n; ++mask) {
- int t = 0;
- for (int i = 0; i < n; ++i) {
- if ((mask >> i) & 1) {
- t |= nums[i];
- }
- }
- if (mx < t) {
- mx = t;
- ans = 1;
- } else if (mx == t)
- ++ans;
- }
- return ans;
- }
-};
\ No newline at end of file
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution3.go b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution3.go
deleted file mode 100644
index 0047a1dbf7d07..0000000000000
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution3.go
+++ /dev/null
@@ -1,18 +0,0 @@
-func countMaxOrSubsets(nums []int) int {
- mx, ans := 0, 0
- var dfs func(u, t int)
- dfs = func(u, t int) {
- if u == len(nums) {
- if t > mx {
- mx, ans = t, 1
- } else if t == mx {
- ans++
- }
- return
- }
- dfs(u+1, t)
- dfs(u+1, t|nums[u])
- }
- dfs(0, 0)
- return ans
-}
\ No newline at end of file
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution3.java b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution3.java
deleted file mode 100644
index 401802a01543c..0000000000000
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution3.java
+++ /dev/null
@@ -1,22 +0,0 @@
-class Solution {
- public int countMaxOrSubsets(int[] nums) {
- int n = nums.length;
- int ans = 0;
- int mx = 0;
- for (int mask = 1; mask < 1 << n; ++mask) {
- int t = 0;
- for (int i = 0; i < n; ++i) {
- if (((mask >> i) & 1) == 1) {
- t |= nums[i];
- }
- }
- if (mx < t) {
- mx = t;
- ans = 1;
- } else if (mx == t) {
- ++ans;
- }
- }
- return ans;
- }
-}
\ No newline at end of file
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution3.py b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution3.py
deleted file mode 100644
index 7f6b040cf392b..0000000000000
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution3.py
+++ /dev/null
@@ -1,16 +0,0 @@
-class Solution:
- def countMaxOrSubsets(self, nums: List[int]) -> int:
- n = len(nums)
- ans = 0
- mx = 0
- for mask in range(1 << n):
- t = 0
- for i, v in enumerate(nums):
- if (mask >> i) & 1:
- t |= v
- if mx < t:
- mx = t
- ans = 1
- elif mx == t:
- ans += 1
- return ans
diff --git a/solution/2100-2199/2106.Maximum Fruits Harvested After at Most K Steps/README.md b/solution/2100-2199/2106.Maximum Fruits Harvested After at Most K Steps/README.md
index d487c6ae2cdbf..c3bae1c3e11f4 100644
--- a/solution/2100-2199/2106.Maximum Fruits Harvested After at Most K Steps/README.md
+++ b/solution/2100-2199/2106.Maximum Fruits Harvested After at Most K Steps/README.md
@@ -83,24 +83,24 @@ tags:
### 方法一：双指针
-我们不妨假设移动的位置区间为 $[l,r]$，开始位置为 $startPos$，来看看如何算出移动的最小步数。根据 $startPos$ 所处的位置，我们可以分为三种情况：
+我们不妨假设移动的位置区间为 $[l, r]$，开始位置为 $\textit{startPos}$，来看看如何算出移动的最小步数。根据 $\textit{startPos}$ 所处的位置，我们可以分为三种情况：
-1. 如果 $startPos \leq l$，那么就是从 $startPos$ 一直向右移动到 $r$。移动的最小步数为 $r - startPos$；
-2. 如果 $startPos \geq r$，那么就是从 $startPos$ 一直向左移动到 $l$。移动的最小步数为 $startPos - l$；
-3. 如果 $l \lt startPos \lt r$，那么可以从 $startPos$ 向左移动到 $l$，再向右移动到 $r$；也可以从 $startPos$ 向右移动到 $r$，再向左移动到 $l$。移动的最小步数为 $r - l + \min(\lvert startPos - l \rvert, \lvert r - startPos \rvert)$。
+1. 如果 $\textit{startPos} \leq l$，那么就是从 $\textit{startPos}$ 一直向右移动到 $r$。移动的最小步数为 $r - \textit{startPos}$；
+2. 如果 $\textit{startPos} \geq r$，那么就是从 $\textit{startPos}$ 一直向左移动到 $l$。移动的最小步数为 $\textit{startPos} - l$；
+3. 如果 $l < \textit{startPos} < r$，那么可以从 $\textit{startPos}$ 向左移动到 $l$，再向右移动到 $r$；也可以从 $\textit{startPos}$ 向右移动到 $r$，再向左移动到 $l$。移动的最小步数为 $r - l + \min(\lvert \textit{startPos} - l \rvert, \lvert r - \textit{startPos} \rvert)$。
-以上三种情况可以统一用式子 $r - l + \min(\lvert startPos - l \rvert, \lvert r - startPos \rvert)$ 表示。
+以上三种情况可以统一用式子 $r - l + \min(\lvert \textit{startPos} - l \rvert, \lvert r - \textit{startPos} \rvert)$ 表示。
假设我们固定区间右端点 $r$，向右移动左端点 $l$，我们来看看最小移动步数是怎么变化的。
-1. 如果 $startPos \leq l$，随着 $l$ 的增大，最小步数不会发生变化。
-2. 如果 $startPos \gt l$，随着 $l$ 的增大，最小步数会减小。
+1. 如果 $\textit{startPos} \leq l$，随着 $l$ 的增大，最小步数不会发生变化。
+2. 如果 $\textit{startPos} > l$，随着 $l$ 的增大，最小步数会减小。
因此，随着 $l$ 的增大，最小移动步数一定是非严格单调递减的。基于此，我们可以使用双指针的方法，找出所有符合条件的最大区间，然后取所有符合条件的区间中水果总数最大的一个作为答案。
具体地，我们用两个指针 $i$ 和 $j$ 分别指向区间的左右下标，初始时 $i = j = 0$。另外用一个变量 $s$ 记录区间内的水果总数，初始时 $s = 0$。
-每次我们将 $j$ 加入区间中，然后更新 $s = s + fruits[j][1]$。如果此时区间内的最小步数 $fruits[j][0] - fruits[i][0] + \min(\lvert startPos - fruits[i][0] \rvert, \lvert startPos - fruits[j][0] \rvert)$ 大于 $k$，那么我们就将 $i$ 循环向右移动，直到 $i \gt j$ 或者区间内的最小步数小于等于 $k$。此时我们更新答案 $ans = \max(ans, s)$。继续移动 $j$，直到 $j$ 到达数组末尾。
+每次我们将 $j$ 加入区间中，然后更新 $s = s + \textit{fruits}[j][1]$。如果此时区间内的最小步数 $\textit{fruits}[j][0] - \textit{fruits}[i][0] + \min(\lvert \textit{startPos} - \textit{fruits}[i][0] \rvert, \lvert \textit{startPos} - \textit{fruits}[j][0] \rvert)$ 大于 $k$，那么我们就将 $i$ 循环向右移动，直到 $i > j$ 或者区间内的最小步数小于等于 $k$。此时我们更新答案 $\textit{ans} = \max(\textit{ans}, s)$。继续移动 $j$，直到 $j$ 到达数组末尾。
最后返回答案即可。
@@ -219,6 +219,29 @@ function maxTotalFruits(fruits: number[][], startPos: number, k: number): number
}
```
+#### Rust
+
+```rust
+impl Solution {
+ pub fn max_total_fruits(fruits: Vec>, start_pos: i32, k: i32) -> i32 {
+ let mut ans = 0;
+ let mut s = 0;
+ let mut i = 0;
+ for j in 0..fruits.len() {
+ let pj = fruits[j][0];
+ let fj = fruits[j][1];
+ s += fj;
+ while i <= j && pj - fruits[i][0] + std::cmp::min((start_pos - fruits[i][0]).abs(), (start_pos - pj).abs()) > k {
+ s -= fruits[i][1];
+ i += 1;
+ }
+ ans = ans.max(s)
+ }
+ ans
+ }
+}
+```
+
diff --git a/solution/2100-2199/2106.Maximum Fruits Harvested After at Most K Steps/README_EN.md b/solution/2100-2199/2106.Maximum Fruits Harvested After at Most K Steps/README_EN.md
index 3f9a05e1dfb76..465c59a41e48f 100644
--- a/solution/2100-2199/2106.Maximum Fruits Harvested After at Most K Steps/README_EN.md
+++ b/solution/2100-2199/2106.Maximum Fruits Harvested After at Most K Steps/README_EN.md
@@ -82,7 +82,30 @@ You can move at most k = 2 steps and cannot reach any position with fruits.
-### Solution 1
+### Solution 1: Two Pointers
+
+Let's assume the movement range is $[l, r]$ and the starting position is $\textit{startPos}$. We need to calculate the minimum number of steps required. Based on the position of $\textit{startPos}$, we can divide this into three cases:
+
+1. If $\textit{startPos} \leq l$, then we move right from $\textit{startPos}$ to $r$. The minimum number of steps is $r - \textit{startPos}$;
+2. If $\textit{startPos} \geq r$, then we move left from $\textit{startPos}$ to $l$. The minimum number of steps is $\textit{startPos} - l$;
+3. If $l < \textit{startPos} < r$, we can either move left from $\textit{startPos}$ to $l$ then right to $r$, or move right from $\textit{startPos}$ to $r$ then left to $l$. The minimum number of steps is $r - l + \min(\lvert \textit{startPos} - l \rvert, \lvert r - \textit{startPos} \rvert)$.
+
+All three cases can be unified by the formula $r - l + \min(\lvert \textit{startPos} - l \rvert, \lvert r - \textit{startPos} \rvert)$.
+
+Suppose we fix the right endpoint $r$ of the interval and move the left endpoint $l$ to the right. Let's see how the minimum number of steps changes:
+
+1. If $\textit{startPos} \leq l$, as $l$ increases, the minimum number of steps remains unchanged.
+2. If $\textit{startPos} > l$, as $l$ increases, the minimum number of steps decreases.
+
+Therefore, as $l$ increases, the minimum number of steps is non-strictly monotonically decreasing. Based on this, we can use the two-pointer approach to find all qualifying maximum intervals, then take the one with the maximum total fruits among all qualifying intervals as the answer.
+
+Specifically, we use two pointers $i$ and $j$ to point to the left and right indices of the interval, initially $i = j = 0$. We also use a variable $s$ to record the total number of fruits in the interval, initially $s = 0$.
+
+Each time we include $j$ in the interval, then update $s = s + \textit{fruits}[j][1]$. If the minimum number of steps in the current interval $\textit{fruits}[j][0] - \textit{fruits}[i][0] + \min(\lvert \textit{startPos} - \textit{fruits}[i][0] \rvert, \lvert \textit{startPos} - \textit{fruits}[j][0] \rvert)$ is greater than $k$, we move $i$ to the right in a loop until $i > j$ or the minimum number of steps in the interval is less than or equal to $k$. At this point, we update the answer $\textit{ans} = \max(\textit{ans}, s)$. Continue moving $j$ until $j$ reaches the end of the array.
+
+Finally, return the answer.
+
+The time complexity is $O(n)$, where $n$ is the length of the array. The space complexity is $O(1)$.
@@ -197,6 +220,29 @@ function maxTotalFruits(fruits: number[][], startPos: number, k: number): number
}
```
+#### Rust
+
+```rust
+impl Solution {
+ pub fn max_total_fruits(fruits: Vec>, start_pos: i32, k: i32) -> i32 {
+ let mut ans = 0;
+ let mut s = 0;
+ let mut i = 0;
+ for j in 0..fruits.len() {
+ let pj = fruits[j][0];
+ let fj = fruits[j][1];
+ s += fj;
+ while i <= j && pj - fruits[i][0] + std::cmp::min((start_pos - fruits[i][0]).abs(), (start_pos - pj).abs()) > k {
+ s -= fruits[i][1];
+ i += 1;
+ }
+ ans = ans.max(s)
+ }
+ ans
+ }
+}
+```
+
diff --git a/solution/2100-2199/2106.Maximum Fruits Harvested After at Most K Steps/Solution.rs b/solution/2100-2199/2106.Maximum Fruits Harvested After at Most K Steps/Solution.rs
new file mode 100644
index 0000000000000..e9c789b82dc2e
--- /dev/null
+++ b/solution/2100-2199/2106.Maximum Fruits Harvested After at Most K Steps/Solution.rs
@@ -0,0 +1,22 @@
+impl Solution {
+ pub fn max_total_fruits(fruits: Vec>, start_pos: i32, k: i32) -> i32 {
+ let mut ans = 0;
+ let mut s = 0;
+ let mut i = 0;
+ for j in 0..fruits.len() {
+ let pj = fruits[j][0];
+ let fj = fruits[j][1];
+ s += fj;
+ while i <= j
+ && pj - fruits[i][0]
+ + std::cmp::min((start_pos - fruits[i][0]).abs(), (start_pos - pj).abs())
+ > k
+ {
+ s -= fruits[i][1];
+ i += 1;
+ }
+ ans = ans.max(s)
+ }
+ ans
+ }
+}
diff --git a/solution/2100-2199/2143.Choose Numbers From Two Arrays in Range/README.md b/solution/2100-2199/2143.Choose Numbers From Two Arrays in Range/README.md
index 8a601e38ad610..21f650b5ddf8f 100644
--- a/solution/2100-2199/2143.Choose Numbers From Two Arrays in Range/README.md
+++ b/solution/2100-2199/2143.Choose Numbers From Two Arrays in Range/README.md
@@ -44,7 +44,7 @@ tags:
输入: nums1 = [1,2,5], nums2 = [2,6,3]
输出: 3
解释: 平衡的区间有:
-- [0, 1], 我们选取 nums2[0] 和 nums2[1]。
+- [0, 1], 我们选取 nums2[0] 和 nums1[1]。
从 nums1 中选取的数字和与从 nums2 中选取的数字和相等: 2 = 2.
- [0, 2], 我们选取 nums1[0], nums2[1] 和 nums1[2]。
从 nums1 中选取的数字和与从 nums2 中选取的数字和相等: 1 + 5 = 6。
diff --git a/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/README.md b/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/README.md
index fc6d85ba96c64..f3b21d53007b9 100644
--- a/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/README.md
+++ b/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/README.md
@@ -264,25 +264,25 @@ function minimumDifference(nums: number[]): number {
const n = Math.floor(m / 3);
let s = 0;
const pre: number[] = Array(m + 1);
- const q1 = new MaxPriorityQueue();
+ const q1 = new MaxPriorityQueue();
for (let i = 1; i <= n * 2; ++i) {
const x = nums[i - 1];
s += x;
- q1.enqueue(x, x);
+ q1.enqueue(x);
if (q1.size() > n) {
- s -= q1.dequeue().element;
+ s -= q1.dequeue();
}
pre[i] = s;
}
s = 0;
const suf: number[] = Array(m + 1);
- const q2 = new MinPriorityQueue();
+ const q2 = new MinPriorityQueue();
for (let i = m; i > n; --i) {
const x = nums[i - 1];
s += x;
- q2.enqueue(x, x);
+ q2.enqueue(x);
if (q2.size() > n) {
- s -= q2.dequeue().element;
+ s -= q2.dequeue();
}
suf[i] = s;
}
@@ -294,6 +294,58 @@ function minimumDifference(nums: number[]): number {
}
```
+#### Rust
+
+```rust
+use std::collections::BinaryHeap;
+use std::cmp::Reverse;
+
+impl Solution {
+ pub fn minimum_difference(nums: Vec) -> i64 {
+ let m = nums.len();
+ let n = m / 3;
+ let mut s = 0i64;
+ let mut pre = vec![0i64; m + 1];
+ let mut pq = BinaryHeap::new(); // max-heap
+
+ for i in 1..=2 * n {
+ let x = nums[i - 1] as i64;
+ s += x;
+ pq.push(x);
+ if pq.len() > n {
+ if let Some(top) = pq.pop() {
+ s -= top;
+ }
+ }
+ pre[i] = s;
+ }
+
+ s = 0;
+ let mut suf = vec![0i64; m + 1];
+ let mut pq = BinaryHeap::new();
+
+ for i in (n + 1..=m).rev() {
+ let x = nums[i - 1] as i64;
+ s += x;
+ pq.push(Reverse(x));
+ if pq.len() > n {
+ if let Some(Reverse(top)) = pq.pop() {
+ s -= top;
+ }
+ }
+ suf[i] = s;
+ }
+
+ let mut ans = i64::MAX;
+ for i in n..=2 * n {
+ ans = ans.min(pre[i] - suf[i + 1]);
+ }
+
+ ans
+ }
+}
+```
+
diff --git a/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/README_EN.md b/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/README_EN.md
index a3219e509b366..141608a7e8fcc 100644
--- a/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/README_EN.md
+++ b/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/README_EN.md
@@ -264,25 +264,25 @@ function minimumDifference(nums: number[]): number {
const n = Math.floor(m / 3);
let s = 0;
const pre: number[] = Array(m + 1);
- const q1 = new MaxPriorityQueue();
+ const q1 = new MaxPriorityQueue();
for (let i = 1; i <= n * 2; ++i) {
const x = nums[i - 1];
s += x;
- q1.enqueue(x, x);
+ q1.enqueue(x);
if (q1.size() > n) {
- s -= q1.dequeue().element;
+ s -= q1.dequeue();
}
pre[i] = s;
}
s = 0;
const suf: number[] = Array(m + 1);
- const q2 = new MinPriorityQueue();
+ const q2 = new MinPriorityQueue();
for (let i = m; i > n; --i) {
const x = nums[i - 1];
s += x;
- q2.enqueue(x, x);
+ q2.enqueue(x);
if (q2.size() > n) {
- s -= q2.dequeue().element;
+ s -= q2.dequeue();
}
suf[i] = s;
}
@@ -294,6 +294,58 @@ function minimumDifference(nums: number[]): number {
}
```
+#### Rust
+
+```rust
+use std::collections::BinaryHeap;
+use std::cmp::Reverse;
+
+impl Solution {
+ pub fn minimum_difference(nums: Vec) -> i64 {
+ let m = nums.len();
+ let n = m / 3;
+ let mut s = 0i64;
+ let mut pre = vec![0i64; m + 1];
+ let mut pq = BinaryHeap::new(); // max-heap
+
+ for i in 1..=2 * n {
+ let x = nums[i - 1] as i64;
+ s += x;
+ pq.push(x);
+ if pq.len() > n {
+ if let Some(top) = pq.pop() {
+ s -= top;
+ }
+ }
+ pre[i] = s;
+ }
+
+ s = 0;
+ let mut suf = vec![0i64; m + 1];
+ let mut pq = BinaryHeap::new();
+
+ for i in (n + 1..=m).rev() {
+ let x = nums[i - 1] as i64;
+ s += x;
+ pq.push(Reverse(x));
+ if pq.len() > n {
+ if let Some(Reverse(top)) = pq.pop() {
+ s -= top;
+ }
+ }
+ suf[i] = s;
+ }
+
+ let mut ans = i64::MAX;
+ for i in n..=2 * n {
+ ans = ans.min(pre[i] - suf[i + 1]);
+ }
+
+ ans
+ }
+}
+```
+
diff --git a/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/Solution.rs b/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/Solution.rs
new file mode 100644
index 0000000000000..c0081d3a69131
--- /dev/null
+++ b/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/Solution.rs
@@ -0,0 +1,47 @@
+use std::cmp::Reverse;
+use std::collections::BinaryHeap;
+
+impl Solution {
+ pub fn minimum_difference(nums: Vec) -> i64 {
+ let m = nums.len();
+ let n = m / 3;
+ let mut s = 0i64;
+ let mut pre = vec![0i64; m + 1];
+ let mut pq = BinaryHeap::new(); // max-heap
+
+ for i in 1..=2 * n {
+ let x = nums[i - 1] as i64;
+ s += x;
+ pq.push(x);
+ if pq.len() > n {
+ if let Some(top) = pq.pop() {
+ s -= top;
+ }
+ }
+ pre[i] = s;
+ }
+
+ s = 0;
+ let mut suf = vec![0i64; m + 1];
+ let mut pq = BinaryHeap::new();
+
+ for i in (n + 1..=m).rev() {
+ let x = nums[i - 1] as i64;
+ s += x;
+ pq.push(Reverse(x));
+ if pq.len() > n {
+ if let Some(Reverse(top)) = pq.pop() {
+ s -= top;
+ }
+ }
+ suf[i] = s;
+ }
+
+ let mut ans = i64::MAX;
+ for i in n..=2 * n {
+ ans = ans.min(pre[i] - suf[i + 1]);
+ }
+
+ ans
+ }
+}
diff --git a/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/Solution.ts b/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/Solution.ts
index 2ae41810bf305..d407e351f40a5 100644
--- a/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/Solution.ts
+++ b/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/Solution.ts
@@ -3,25 +3,25 @@ function minimumDifference(nums: number[]): number {
const n = Math.floor(m / 3);
let s = 0;
const pre: number[] = Array(m + 1);
- const q1 = new MaxPriorityQueue();
+ const q1 = new MaxPriorityQueue();
for (let i = 1; i <= n * 2; ++i) {
const x = nums[i - 1];
s += x;
- q1.enqueue(x, x);
+ q1.enqueue(x);
if (q1.size() > n) {
- s -= q1.dequeue().element;
+ s -= q1.dequeue();
}
pre[i] = s;
}
s = 0;
const suf: number[] = Array(m + 1);
- const q2 = new MinPriorityQueue();
+ const q2 = new MinPriorityQueue();
for (let i = m; i > n; --i) {
const x = nums[i - 1];
s += x;
- q2.enqueue(x, x);
+ q2.enqueue(x);
if (q2.size() > n) {
- s -= q2.dequeue().element;
+ s -= q2.dequeue();
}
suf[i] = s;
}
diff --git a/solution/2300-2399/2322.Minimum Score After Removals on a Tree/README.md b/solution/2300-2399/2322.Minimum Score After Removals on a Tree/README.md
index b41b68cd1bac7..65904785b7ae2 100644
--- a/solution/2300-2399/2322.Minimum Score After Removals on a Tree/README.md
+++ b/solution/2300-2399/2322.Minimum Score After Removals on a Tree/README.md
@@ -87,11 +87,13 @@ tags:
### 方法一：DFS + 子树异或和
-枚举 $[0,n)$ 的每个点 $i$ 作为树的根节点，将根节点与某个子节点相连的边作为第一条被删除的边。这样我们就获得了两个连通块，我们记包含根节点 $i$ 的连通块为 $A$，不包含根节点 $i$ 的连通块为 $B$。
+我们记树的异或和为 $s$，即 $s = \text{nums}[0] \oplus \text{nums}[1] \oplus \ldots \oplus \text{nums}[n-1]$。
-在 $A$ 中枚举第二条被删除的边。那么 $A$ 也会被划分成两个连通块 $C$ 和 $D$。
+接下来，枚举 $[0..n)$ 的每个点 $i$ 作为树的根节点，将根节点与某个子节点 $j$ 相连的边作为第一条被删除的边。这样我们就获得了两个连通块，我们记包含根节点 $i$ 的连通块的异或和为 $s_1$，然后我们对包含根节点 $i$ 的连通块进行 DFS，计算出每个子树的异或和，记每次 DFS 计算出的子树异或和为 $s_2$。那么三个连通块的异或和分别为 $s \oplus s_1$, $s_2$ 和 $s_1 \oplus s_2$。我们需要计算这三个异或和的最大值和最小值，记为 $\textit{mx}$ 和 $\textit{mn}$，那么对于枚举的每一种情况，得到的分数为 $\textit{mx} - \textit{mn}$。求所有情况的最小值作为答案。
-记每个连通块的异或和为 $S_i$，那么对于枚举的每一种情况，得到的分数为 $max(S_B, S_C, S_D)-min(S_B, S_C, S_D)$。求所有情况的最小值作为答案。
+计算每个子树的异或和可以通过 DFS 实现。定义一个函数 $\text{dfs}(i, fa)$，表示从节点 $i$ 开始 DFS，而 $fa$ 是节点 $i$ 的父节点。函数返回值为以节点 $i$ 为根的子树的异或和。
+
+时间复杂度 $O(n^2)$，空间复杂度 $O(n)$。其中 $n$ 是树的节点数。
@@ -100,40 +102,36 @@ tags:
```python
class Solution:
def minimumScore(self, nums: List[int], edges: List[List[int]]) -> int:
- def dfs(i, fa, x):
+ def dfs(i: int, fa: int) -> int:
res = nums[i]
for j in g[i]:
- if j != fa and j != x:
- res ^= dfs(j, i, x)
+ if j != fa:
+ res ^= dfs(j, i)
return res
- def dfs2(i, fa, x):
+ def dfs2(i: int, fa: int) -> int:
nonlocal s, s1, ans
res = nums[i]
for j in g[i]:
- if j != fa and j != x:
- a = dfs2(j, i, x)
- res ^= a
- b = s1 ^ a
- c = s ^ s1
- t = max(a, b, c) - min(a, b, c)
- ans = min(ans, t)
+ if j != fa:
+ s2 = dfs2(j, i)
+ res ^= s2
+ mx = max(s ^ s1, s2, s1 ^ s2)
+ mn = min(s ^ s1, s2, s1 ^ s2)
+ ans = min(ans, mx - mn)
return res
g = defaultdict(list)
for a, b in edges:
g[a].append(b)
g[b].append(a)
-
- s = 0
- for v in nums:
- s ^= v
+ s = reduce(lambda x, y: x ^ y, nums)
n = len(nums)
ans = inf
for i in range(n):
for j in g[i]:
- s1 = dfs(i, -1, j)
- dfs2(i, -1, j)
+ s1 = dfs(i, j)
+ dfs2(i, j)
return ans
```
@@ -141,55 +139,53 @@ class Solution:
```java
class Solution {
- private int s;
- private int s1;
- private int n;
- private int ans = Integer.MAX_VALUE;
private int[] nums;
private List[] g;
+ private int ans = Integer.MAX_VALUE;
+ private int s;
+ private int s1;
public int minimumScore(int[] nums, int[][] edges) {
- n = nums.length;
- g = new List[n];
+ int n = nums.length;
this.nums = nums;
+ g = new List[n];
Arrays.setAll(g, k -> new ArrayList<>());
for (int[] e : edges) {
int a = e[0], b = e[1];
g[a].add(b);
g[b].add(a);
}
- for (int v : nums) {
- s ^= v;
+ for (int x : nums) {
+ s ^= x;
}
for (int i = 0; i < n; ++i) {
for (int j : g[i]) {
- s1 = dfs(i, -1, j);
- dfs2(i, -1, j);
+ s1 = dfs(i, j);
+ dfs2(i, j);
}
}
return ans;
}
- private int dfs(int i, int fa, int x) {
+ private int dfs(int i, int fa) {
int res = nums[i];
for (int j : g[i]) {
- if (j != fa && j != x) {
- res ^= dfs(j, i, x);
+ if (j != fa) {
+ res ^= dfs(j, i);
}
}
return res;
}
- private int dfs2(int i, int fa, int x) {
+ private int dfs2(int i, int fa) {
int res = nums[i];
for (int j : g[i]) {
- if (j != fa && j != x) {
- int a = dfs2(j, i, x);
- res ^= a;
- int b = s1 ^ a;
- int c = s ^ s1;
- int t = Math.max(Math.max(a, b), c) - Math.min(Math.min(a, b), c);
- ans = Math.min(ans, t);
+ if (j != fa) {
+ int s2 = dfs2(j, i);
+ res ^= s2;
+ int mx = Math.max(Math.max(s ^ s1, s2), s1 ^ s2);
+ int mn = Math.min(Math.min(s ^ s1, s2), s1 ^ s2);
+ ans = Math.min(ans, mx - mn);
}
}
return res;
@@ -202,52 +198,49 @@ class Solution {
```cpp
class Solution {
public:
- vector nums;
- int s;
- int s1;
- int n;
- int ans = INT_MAX;
- vector> g;
-
int minimumScore(vector& nums, vector>& edges) {
- n = nums.size();
- g.resize(n, vector());
- for (auto& e : edges) {
+ int n = nums.size();
+ vector g[n];
+ for (const auto& e : edges) {
int a = e[0], b = e[1];
g[a].push_back(b);
g[b].push_back(a);
}
- for (int& v : nums) s ^= v;
- this->nums = nums;
+ int s = 0, s1 = 0;
+ int ans = INT_MAX;
+ for (int x : nums) {
+ s ^= x;
+ }
+ auto dfs = [&](this auto&& dfs, int i, int fa) -> int {
+ int res = nums[i];
+ for (int j : g[i]) {
+ if (j != fa) {
+ res ^= dfs(j, i);
+ }
+ }
+ return res;
+ };
+ auto dfs2 = [&](this auto&& dfs2, int i, int fa) -> int {
+ int res = nums[i];
+ for (int j : g[i]) {
+ if (j != fa) {
+ int s2 = dfs2(j, i);
+ res ^= s2;
+ int mx = max({s ^ s1, s2, s1 ^ s2});
+ int mn = min({s ^ s1, s2, s1 ^ s2});
+ ans = min(ans, mx - mn);
+ }
+ }
+ return res;
+ };
for (int i = 0; i < n; ++i) {
for (int j : g[i]) {
- s1 = dfs(i, -1, j);
- dfs2(i, -1, j);
+ s1 = dfs(i, j);
+ dfs2(i, j);
}
}
return ans;
}
-
- int dfs(int i, int fa, int x) {
- int res = nums[i];
- for (int j : g[i])
- if (j != fa && j != x) res ^= dfs(j, i, x);
- return res;
- }
-
- int dfs2(int i, int fa, int x) {
- int res = nums[i];
- for (int j : g[i])
- if (j != fa && j != x) {
- int a = dfs2(j, i, x);
- res ^= a;
- int b = s1 ^ a;
- int c = s ^ s1;
- int t = max(max(a, b), c) - min(min(a, b), c);
- ans = min(ans, t);
- }
- return res;
- }
};
```
@@ -262,47 +255,210 @@ func minimumScore(nums []int, edges [][]int) int {
g[a] = append(g[a], b)
g[b] = append(g[b], a)
}
- s := 0
- for _, v := range nums {
- s ^= v
- }
- s1 := 0
+ s, s1 := 0, 0
ans := math.MaxInt32
- var dfs func(int, int, int) int
- var dfs2 func(int, int, int) int
- dfs = func(i, fa, x int) int {
+ for _, x := range nums {
+ s ^= x
+ }
+ var dfs func(i, fa int) int
+ dfs = func(i, fa int) int {
res := nums[i]
for _, j := range g[i] {
- if j != fa && j != x {
- res ^= dfs(j, i, x)
+ if j != fa {
+ res ^= dfs(j, i)
}
}
return res
}
- dfs2 = func(i, fa, x int) int {
+ var dfs2 func(i, fa int) int
+ dfs2 = func(i, fa int) int {
res := nums[i]
for _, j := range g[i] {
- if j != fa && j != x {
- a := dfs2(j, i, x)
- res ^= a
- b := s1 ^ a
- c := s ^ s1
- t := max(max(a, b), c) - min(min(a, b), c)
- ans = min(ans, t)
+ if j != fa {
+ s2 := dfs2(j, i)
+ res ^= s2
+ mx := max(s^s1, s2, s1^s2)
+ mn := min(s^s1, s2, s1^s2)
+ ans = min(ans, mx-mn)
}
}
return res
}
for i := 0; i < n; i++ {
for _, j := range g[i] {
- s1 = dfs(i, -1, j)
- dfs2(i, -1, j)
+ s1 = dfs(i, j)
+ dfs2(i, j)
}
}
return ans
}
```
+#### TypeScript
+
+```ts
+function minimumScore(nums: number[], edges: number[][]): number {
+ const n = nums.length;
+ const g: number[][] = Array.from({ length: n }, () => []);
+ for (const [a, b] of edges) {
+ g[a].push(b);
+ g[b].push(a);
+ }
+ const s = nums.reduce((a, b) => a ^ b, 0);
+ let s1 = 0;
+ let ans = Number.MAX_SAFE_INTEGER;
+ function dfs(i: number, fa: number): number {
+ let res = nums[i];
+ for (const j of g[i]) {
+ if (j !== fa) {
+ res ^= dfs(j, i);
+ }
+ }
+ return res;
+ }
+ function dfs2(i: number, fa: number): number {
+ let res = nums[i];
+ for (const j of g[i]) {
+ if (j !== fa) {
+ const s2 = dfs2(j, i);
+ res ^= s2;
+ const mx = Math.max(s ^ s1, s2, s1 ^ s2);
+ const mn = Math.min(s ^ s1, s2, s1 ^ s2);
+ ans = Math.min(ans, mx - mn);
+ }
+ }
+ return res;
+ }
+ for (let i = 0; i < n; ++i) {
+ for (const j of g[i]) {
+ s1 = dfs(i, j);
+ dfs2(i, j);
+ }
+ }
+ return ans;
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+ pub fn minimum_score(nums: Vec, edges: Vec>) -> i32 {
+ let n = nums.len();
+ let mut g = vec![vec![]; n];
+ for e in edges.iter() {
+ let a = e[0] as usize;
+ let b = e[1] as usize;
+ g[a].push(b);
+ g[b].push(a);
+ }
+ let mut s1 = 0;
+ let mut ans = i32::MAX;
+ let s = nums.iter().fold(0, |acc, &x| acc ^ x);
+
+ fn dfs(i: usize, fa: usize, g: &Vec>, nums: &Vec) -> i32 {
+ let mut res = nums[i];
+ for &j in &g[i] {
+ if j != fa {
+ res ^= dfs(j, i, g, nums);
+ }
+ }
+ res
+ }
+
+ fn dfs2(
+ i: usize,
+ fa: usize,
+ g: &Vec>,
+ nums: &Vec,
+ s: i32,
+ s1: i32,
+ ans: &mut i32
+ ) -> i32 {
+ let mut res = nums[i];
+ for &j in &g[i] {
+ if j != fa {
+ let s2 = dfs2(j, i, g, nums, s, s1, ans);
+ res ^= s2;
+ let mx = (s ^ s1).max(s2).max(s1 ^ s2);
+ let mn = (s ^ s1).min(s2).min(s1 ^ s2);
+ *ans = (*ans).min(mx - mn);
+ }
+ }
+ res
+ }
+
+ for i in 0..n {
+ for &j in &g[i] {
+ s1 = dfs(i, j, &g, &nums);
+ dfs2(i, j, &g, &nums, s, s1, &mut ans);
+ }
+ }
+ ans
+ }
+}
+```
+
+#### C#
+
+```cs
+public class Solution {
+ public int MinimumScore(int[] nums, int[][] edges) {
+ int n = nums.Length;
+ List[] g = new List[n];
+ for (int i = 0; i < n; i++) {
+ g[i] = new List();
+ }
+ foreach (var e in edges) {
+ int a = e[0], b = e[1];
+ g[a].Add(b);
+ g[b].Add(a);
+ }
+
+ int s = 0;
+ foreach (int x in nums) {
+ s ^= x;
+ }
+
+ int ans = int.MaxValue;
+ int s1 = 0;
+
+ int Dfs(int i, int fa) {
+ int res = nums[i];
+ foreach (int j in g[i]) {
+ if (j != fa) {
+ res ^= Dfs(j, i);
+ }
+ }
+ return res;
+ }
+
+ int Dfs2(int i, int fa) {
+ int res = nums[i];
+ foreach (int j in g[i]) {
+ if (j != fa) {
+ int s2 = Dfs2(j, i);
+ res ^= s2;
+ int mx = Math.Max(Math.Max(s ^ s1, s2), s1 ^ s2);
+ int mn = Math.Min(Math.Min(s ^ s1, s2), s1 ^ s2);
+ ans = Math.Min(ans, mx - mn);
+ }
+ }
+ return res;
+ }
+
+ for (int i = 0; i < n; ++i) {
+ foreach (int j in g[i]) {
+ s1 = Dfs(i, j);
+ Dfs2(i, j);
+ }
+ }
+
+ return ans;
+ }
+}
+```
+
diff --git a/solution/2300-2399/2322.Minimum Score After Removals on a Tree/README_EN.md b/solution/2300-2399/2322.Minimum Score After Removals on a Tree/README_EN.md
index 693b479f9db27..a2e646213d544 100644
--- a/solution/2300-2399/2322.Minimum Score After Removals on a Tree/README_EN.md
+++ b/solution/2300-2399/2322.Minimum Score After Removals on a Tree/README_EN.md
@@ -85,7 +85,15 @@ We cannot obtain a smaller score than 0.
-### Solution 1
+### Solution 1: DFS + Subtree XOR Sum
+
+We denote the XOR sum of the tree as $s$, i.e., $s = \text{nums}[0] \oplus \text{nums}[1] \oplus \ldots \oplus \text{nums}[n-1]$.
+
+Next, we enumerate each node $i$ in $[0..n)$ as the root of the tree, and treat the edge connecting the root node to some child node $j$ as the first edge to be removed. This gives us two connected components. We denote the XOR sum of the connected component containing root node $i$ as $s_1$, then we perform DFS on the connected component containing root node $i$ to calculate the XOR sum of each subtree, denoting each XOR sum calculated by DFS as $s_2$. The XOR sums of the three connected components are $s \oplus s_1$, $s_2$, and $s_1 \oplus s_2$. We need to calculate the maximum and minimum values of these three XOR sums, denoted as $\textit{mx}$ and $\textit{mn}$. For each enumerated case, the score is $\textit{mx} - \textit{mn}$. We find the minimum value among all cases as the answer.
+
+The XOR sum of each subtree can be calculated through DFS. We define a function $\text{dfs}(i, fa)$, which represents starting DFS from node $i$, where $fa$ is the parent node of node $i$. The function returns the XOR sum of the subtree rooted at node $i$.
+
+The time complexity is $O(n^2)$, and the space complexity is $O(n)$, where $n$ is the number of nodes in the tree.
@@ -94,40 +102,36 @@ We cannot obtain a smaller score than 0.
```python
class Solution:
def minimumScore(self, nums: List[int], edges: List[List[int]]) -> int:
- def dfs(i, fa, x):
+ def dfs(i: int, fa: int) -> int:
res = nums[i]
for j in g[i]:
- if j != fa and j != x:
- res ^= dfs(j, i, x)
+ if j != fa:
+ res ^= dfs(j, i)
return res
- def dfs2(i, fa, x):
+ def dfs2(i: int, fa: int) -> int:
nonlocal s, s1, ans
res = nums[i]
for j in g[i]:
- if j != fa and j != x:
- a = dfs2(j, i, x)
- res ^= a
- b = s1 ^ a
- c = s ^ s1
- t = max(a, b, c) - min(a, b, c)
- ans = min(ans, t)
+ if j != fa:
+ s2 = dfs2(j, i)
+ res ^= s2
+ mx = max(s ^ s1, s2, s1 ^ s2)
+ mn = min(s ^ s1, s2, s1 ^ s2)
+ ans = min(ans, mx - mn)
return res
g = defaultdict(list)
for a, b in edges:
g[a].append(b)
g[b].append(a)
-
- s = 0
- for v in nums:
- s ^= v
+ s = reduce(lambda x, y: x ^ y, nums)
n = len(nums)
ans = inf
for i in range(n):
for j in g[i]:
- s1 = dfs(i, -1, j)
- dfs2(i, -1, j)
+ s1 = dfs(i, j)
+ dfs2(i, j)
return ans
```
@@ -135,55 +139,53 @@ class Solution:
```java
class Solution {
- private int s;
- private int s1;
- private int n;
- private int ans = Integer.MAX_VALUE;
private int[] nums;
private List[] g;
+ private int ans = Integer.MAX_VALUE;
+ private int s;
+ private int s1;
public int minimumScore(int[] nums, int[][] edges) {
- n = nums.length;
- g = new List[n];
+ int n = nums.length;
this.nums = nums;
+ g = new List[n];
Arrays.setAll(g, k -> new ArrayList<>());
for (int[] e : edges) {
int a = e[0], b = e[1];
g[a].add(b);
g[b].add(a);
}
- for (int v : nums) {
- s ^= v;
+ for (int x : nums) {
+ s ^= x;
}
for (int i = 0; i < n; ++i) {
for (int j : g[i]) {
- s1 = dfs(i, -1, j);
- dfs2(i, -1, j);
+ s1 = dfs(i, j);
+ dfs2(i, j);
}
}
return ans;
}
- private int dfs(int i, int fa, int x) {
+ private int dfs(int i, int fa) {
int res = nums[i];
for (int j : g[i]) {
- if (j != fa && j != x) {
- res ^= dfs(j, i, x);
+ if (j != fa) {
+ res ^= dfs(j, i);
}
}
return res;
}
- private int dfs2(int i, int fa, int x) {
+ private int dfs2(int i, int fa) {
int res = nums[i];
for (int j : g[i]) {
- if (j != fa && j != x) {
- int a = dfs2(j, i, x);
- res ^= a;
- int b = s1 ^ a;
- int c = s ^ s1;
- int t = Math.max(Math.max(a, b), c) - Math.min(Math.min(a, b), c);
- ans = Math.min(ans, t);
+ if (j != fa) {
+ int s2 = dfs2(j, i);
+ res ^= s2;
+ int mx = Math.max(Math.max(s ^ s1, s2), s1 ^ s2);
+ int mn = Math.min(Math.min(s ^ s1, s2), s1 ^ s2);
+ ans = Math.min(ans, mx - mn);
}
}
return res;
@@ -196,52 +198,49 @@ class Solution {
```cpp
class Solution {
public:
- vector nums;
- int s;
- int s1;
- int n;
- int ans = INT_MAX;
- vector> g;
-
int minimumScore(vector& nums, vector>& edges) {
- n = nums.size();
- g.resize(n, vector());
- for (auto& e : edges) {
+ int n = nums.size();
+ vector g[n];
+ for (const auto& e : edges) {
int a = e[0], b = e[1];
g[a].push_back(b);
g[b].push_back(a);
}
- for (int& v : nums) s ^= v;
- this->nums = nums;
+ int s = 0, s1 = 0;
+ int ans = INT_MAX;
+ for (int x : nums) {
+ s ^= x;
+ }
+ auto dfs = [&](this auto&& dfs, int i, int fa) -> int {
+ int res = nums[i];
+ for (int j : g[i]) {
+ if (j != fa) {
+ res ^= dfs(j, i);
+ }
+ }
+ return res;
+ };
+ auto dfs2 = [&](this auto&& dfs2, int i, int fa) -> int {
+ int res = nums[i];
+ for (int j : g[i]) {
+ if (j != fa) {
+ int s2 = dfs2(j, i);
+ res ^= s2;
+ int mx = max({s ^ s1, s2, s1 ^ s2});
+ int mn = min({s ^ s1, s2, s1 ^ s2});
+ ans = min(ans, mx - mn);
+ }
+ }
+ return res;
+ };
for (int i = 0; i < n; ++i) {
for (int j : g[i]) {
- s1 = dfs(i, -1, j);
- dfs2(i, -1, j);
+ s1 = dfs(i, j);
+ dfs2(i, j);
}
}
return ans;
}
-
- int dfs(int i, int fa, int x) {
- int res = nums[i];
- for (int j : g[i])
- if (j != fa && j != x) res ^= dfs(j, i, x);
- return res;
- }
-
- int dfs2(int i, int fa, int x) {
- int res = nums[i];
- for (int j : g[i])
- if (j != fa && j != x) {
- int a = dfs2(j, i, x);
- res ^= a;
- int b = s1 ^ a;
- int c = s ^ s1;
- int t = max(max(a, b), c) - min(min(a, b), c);
- ans = min(ans, t);
- }
- return res;
- }
};
```
@@ -256,47 +255,210 @@ func minimumScore(nums []int, edges [][]int) int {
g[a] = append(g[a], b)
g[b] = append(g[b], a)
}
- s := 0
- for _, v := range nums {
- s ^= v
- }
- s1 := 0
+ s, s1 := 0, 0
ans := math.MaxInt32
- var dfs func(int, int, int) int
- var dfs2 func(int, int, int) int
- dfs = func(i, fa, x int) int {
+ for _, x := range nums {
+ s ^= x
+ }
+ var dfs func(i, fa int) int
+ dfs = func(i, fa int) int {
res := nums[i]
for _, j := range g[i] {
- if j != fa && j != x {
- res ^= dfs(j, i, x)
+ if j != fa {
+ res ^= dfs(j, i)
}
}
return res
}
- dfs2 = func(i, fa, x int) int {
+ var dfs2 func(i, fa int) int
+ dfs2 = func(i, fa int) int {
res := nums[i]
for _, j := range g[i] {
- if j != fa && j != x {
- a := dfs2(j, i, x)
- res ^= a
- b := s1 ^ a
- c := s ^ s1
- t := max(max(a, b), c) - min(min(a, b), c)
- ans = min(ans, t)
+ if j != fa {
+ s2 := dfs2(j, i)
+ res ^= s2
+ mx := max(s^s1, s2, s1^s2)
+ mn := min(s^s1, s2, s1^s2)
+ ans = min(ans, mx-mn)
}
}
return res
}
for i := 0; i < n; i++ {
for _, j := range g[i] {
- s1 = dfs(i, -1, j)
- dfs2(i, -1, j)
+ s1 = dfs(i, j)
+ dfs2(i, j)
}
}
return ans
}
```
+#### TypeScript
+
+```ts
+function minimumScore(nums: number[], edges: number[][]): number {
+ const n = nums.length;
+ const g: number[][] = Array.from({ length: n }, () => []);
+ for (const [a, b] of edges) {
+ g[a].push(b);
+ g[b].push(a);
+ }
+ const s = nums.reduce((a, b) => a ^ b, 0);
+ let s1 = 0;
+ let ans = Number.MAX_SAFE_INTEGER;
+ function dfs(i: number, fa: number): number {
+ let res = nums[i];
+ for (const j of g[i]) {
+ if (j !== fa) {
+ res ^= dfs(j, i);
+ }
+ }
+ return res;
+ }
+ function dfs2(i: number, fa: number): number {
+ let res = nums[i];
+ for (const j of g[i]) {
+ if (j !== fa) {
+ const s2 = dfs2(j, i);
+ res ^= s2;
+ const mx = Math.max(s ^ s1, s2, s1 ^ s2);
+ const mn = Math.min(s ^ s1, s2, s1 ^ s2);
+ ans = Math.min(ans, mx - mn);
+ }
+ }
+ return res;
+ }
+ for (let i = 0; i < n; ++i) {
+ for (const j of g[i]) {
+ s1 = dfs(i, j);
+ dfs2(i, j);
+ }
+ }
+ return ans;
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+ pub fn minimum_score(nums: Vec, edges: Vec>) -> i32 {
+ let n = nums.len();
+ let mut g = vec![vec![]; n];
+ for e in edges.iter() {
+ let a = e[0] as usize;
+ let b = e[1] as usize;
+ g[a].push(b);
+ g[b].push(a);
+ }
+ let mut s1 = 0;
+ let mut ans = i32::MAX;
+ let s = nums.iter().fold(0, |acc, &x| acc ^ x);
+
+ fn dfs(i: usize, fa: usize, g: &Vec>, nums: &Vec) -> i32 {
+ let mut res = nums[i];
+ for &j in &g[i] {
+ if j != fa {
+ res ^= dfs(j, i, g, nums);
+ }
+ }
+ res
+ }
+
+ fn dfs2(
+ i: usize,
+ fa: usize,
+ g: &Vec>,
+ nums: &Vec,
+ s: i32,
+ s1: i32,
+ ans: &mut i32
+ ) -> i32 {
+ let mut res = nums[i];
+ for &j in &g[i] {
+ if j != fa {
+ let s2 = dfs2(j, i, g, nums, s, s1, ans);
+ res ^= s2;
+ let mx = (s ^ s1).max(s2).max(s1 ^ s2);
+ let mn = (s ^ s1).min(s2).min(s1 ^ s2);
+ *ans = (*ans).min(mx - mn);
+ }
+ }
+ res
+ }
+
+ for i in 0..n {
+ for &j in &g[i] {
+ s1 = dfs(i, j, &g, &nums);
+ dfs2(i, j, &g, &nums, s, s1, &mut ans);
+ }
+ }
+ ans
+ }
+}
+```
+
+#### C#
+
+```cs
+public class Solution {
+ public int MinimumScore(int[] nums, int[][] edges) {
+ int n = nums.Length;
+ List[] g = new List[n];
+ for (int i = 0; i < n; i++) {
+ g[i] = new List();
+ }
+ foreach (var e in edges) {
+ int a = e[0], b = e[1];
+ g[a].Add(b);
+ g[b].Add(a);
+ }
+
+ int s = 0;
+ foreach (int x in nums) {
+ s ^= x;
+ }
+
+ int ans = int.MaxValue;
+ int s1 = 0;
+
+ int Dfs(int i, int fa) {
+ int res = nums[i];
+ foreach (int j in g[i]) {
+ if (j != fa) {
+ res ^= Dfs(j, i);
+ }
+ }
+ return res;
+ }
+
+ int Dfs2(int i, int fa) {
+ int res = nums[i];
+ foreach (int j in g[i]) {
+ if (j != fa) {
+ int s2 = Dfs2(j, i);
+ res ^= s2;
+ int mx = Math.Max(Math.Max(s ^ s1, s2), s1 ^ s2);
+ int mn = Math.Min(Math.Min(s ^ s1, s2), s1 ^ s2);
+ ans = Math.Min(ans, mx - mn);
+ }
+ }
+ return res;
+ }
+
+ for (int i = 0; i < n; ++i) {
+ foreach (int j in g[i]) {
+ s1 = Dfs(i, j);
+ Dfs2(i, j);
+ }
+ }
+
+ return ans;
+ }
+}
+```
+
diff --git a/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.cpp b/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.cpp
index f802fca15468a..feb43c0045a46 100644
--- a/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.cpp
+++ b/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.cpp
@@ -1,49 +1,46 @@
class Solution {
public:
- vector nums;
- int s;
- int s1;
- int n;
- int ans = INT_MAX;
- vector> g;
-
int minimumScore(vector& nums, vector>& edges) {
- n = nums.size();
- g.resize(n, vector());
- for (auto& e : edges) {
+ int n = nums.size();
+ vector g[n];
+ for (const auto& e : edges) {
int a = e[0], b = e[1];
g[a].push_back(b);
g[b].push_back(a);
}
- for (int& v : nums) s ^= v;
- this->nums = nums;
+ int s = 0, s1 = 0;
+ int ans = INT_MAX;
+ for (int x : nums) {
+ s ^= x;
+ }
+ auto dfs = [&](this auto&& dfs, int i, int fa) -> int {
+ int res = nums[i];
+ for (int j : g[i]) {
+ if (j != fa) {
+ res ^= dfs(j, i);
+ }
+ }
+ return res;
+ };
+ auto dfs2 = [&](this auto&& dfs2, int i, int fa) -> int {
+ int res = nums[i];
+ for (int j : g[i]) {
+ if (j != fa) {
+ int s2 = dfs2(j, i);
+ res ^= s2;
+ int mx = max({s ^ s1, s2, s1 ^ s2});
+ int mn = min({s ^ s1, s2, s1 ^ s2});
+ ans = min(ans, mx - mn);
+ }
+ }
+ return res;
+ };
for (int i = 0; i < n; ++i) {
for (int j : g[i]) {
- s1 = dfs(i, -1, j);
- dfs2(i, -1, j);
+ s1 = dfs(i, j);
+ dfs2(i, j);
}
}
return ans;
}
-
- int dfs(int i, int fa, int x) {
- int res = nums[i];
- for (int j : g[i])
- if (j != fa && j != x) res ^= dfs(j, i, x);
- return res;
- }
-
- int dfs2(int i, int fa, int x) {
- int res = nums[i];
- for (int j : g[i])
- if (j != fa && j != x) {
- int a = dfs2(j, i, x);
- res ^= a;
- int b = s1 ^ a;
- int c = s ^ s1;
- int t = max(max(a, b), c) - min(min(a, b), c);
- ans = min(ans, t);
- }
- return res;
- }
};
\ No newline at end of file
diff --git a/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.cs b/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.cs
new file mode 100644
index 0000000000000..392ae45d1e65d
--- /dev/null
+++ b/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.cs
@@ -0,0 +1,55 @@
+public class Solution {
+ public int MinimumScore(int[] nums, int[][] edges) {
+ int n = nums.Length;
+ List[] g = new List[n];
+ for (int i = 0; i < n; i++) {
+ g[i] = new List();
+ }
+ foreach (var e in edges) {
+ int a = e[0], b = e[1];
+ g[a].Add(b);
+ g[b].Add(a);
+ }
+
+ int s = 0;
+ foreach (int x in nums) {
+ s ^= x;
+ }
+
+ int ans = int.MaxValue;
+ int s1 = 0;
+
+ int Dfs(int i, int fa) {
+ int res = nums[i];
+ foreach (int j in g[i]) {
+ if (j != fa) {
+ res ^= Dfs(j, i);
+ }
+ }
+ return res;
+ }
+
+ int Dfs2(int i, int fa) {
+ int res = nums[i];
+ foreach (int j in g[i]) {
+ if (j != fa) {
+ int s2 = Dfs2(j, i);
+ res ^= s2;
+ int mx = Math.Max(Math.Max(s ^ s1, s2), s1 ^ s2);
+ int mn = Math.Min(Math.Min(s ^ s1, s2), s1 ^ s2);
+ ans = Math.Min(ans, mx - mn);
+ }
+ }
+ return res;
+ }
+
+ for (int i = 0; i < n; ++i) {
+ foreach (int j in g[i]) {
+ s1 = Dfs(i, j);
+ Dfs2(i, j);
+ }
+ }
+
+ return ans;
+ }
+}
diff --git a/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.go b/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.go
index c6267c3f303c2..16c715f200d3d 100644
--- a/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.go
+++ b/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.go
@@ -6,41 +6,39 @@ func minimumScore(nums []int, edges [][]int) int {
g[a] = append(g[a], b)
g[b] = append(g[b], a)
}
- s := 0
- for _, v := range nums {
- s ^= v
- }
- s1 := 0
+ s, s1 := 0, 0
ans := math.MaxInt32
- var dfs func(int, int, int) int
- var dfs2 func(int, int, int) int
- dfs = func(i, fa, x int) int {
+ for _, x := range nums {
+ s ^= x
+ }
+ var dfs func(i, fa int) int
+ dfs = func(i, fa int) int {
res := nums[i]
for _, j := range g[i] {
- if j != fa && j != x {
- res ^= dfs(j, i, x)
+ if j != fa {
+ res ^= dfs(j, i)
}
}
return res
}
- dfs2 = func(i, fa, x int) int {
+ var dfs2 func(i, fa int) int
+ dfs2 = func(i, fa int) int {
res := nums[i]
for _, j := range g[i] {
- if j != fa && j != x {
- a := dfs2(j, i, x)
- res ^= a
- b := s1 ^ a
- c := s ^ s1
- t := max(max(a, b), c) - min(min(a, b), c)
- ans = min(ans, t)
+ if j != fa {
+ s2 := dfs2(j, i)
+ res ^= s2
+ mx := max(s^s1, s2, s1^s2)
+ mn := min(s^s1, s2, s1^s2)
+ ans = min(ans, mx-mn)
}
}
return res
}
for i := 0; i < n; i++ {
for _, j := range g[i] {
- s1 = dfs(i, -1, j)
- dfs2(i, -1, j)
+ s1 = dfs(i, j)
+ dfs2(i, j)
}
}
return ans
diff --git a/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.java b/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.java
index 4a1fd9246fc39..9f10f944cce9e 100644
--- a/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.java
+++ b/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.java
@@ -1,53 +1,51 @@
class Solution {
- private int s;
- private int s1;
- private int n;
- private int ans = Integer.MAX_VALUE;
private int[] nums;
private List[] g;
+ private int ans = Integer.MAX_VALUE;
+ private int s;
+ private int s1;
public int minimumScore(int[] nums, int[][] edges) {
- n = nums.length;
- g = new List[n];
+ int n = nums.length;
this.nums = nums;
+ g = new List[n];
Arrays.setAll(g, k -> new ArrayList<>());
for (int[] e : edges) {
int a = e[0], b = e[1];
g[a].add(b);
g[b].add(a);
}
- for (int v : nums) {
- s ^= v;
+ for (int x : nums) {
+ s ^= x;
}
for (int i = 0; i < n; ++i) {
for (int j : g[i]) {
- s1 = dfs(i, -1, j);
- dfs2(i, -1, j);
+ s1 = dfs(i, j);
+ dfs2(i, j);
}
}
return ans;
}
- private int dfs(int i, int fa, int x) {
+ private int dfs(int i, int fa) {
int res = nums[i];
for (int j : g[i]) {
- if (j != fa && j != x) {
- res ^= dfs(j, i, x);
+ if (j != fa) {
+ res ^= dfs(j, i);
}
}
return res;
}
- private int dfs2(int i, int fa, int x) {
+ private int dfs2(int i, int fa) {
int res = nums[i];
for (int j : g[i]) {
- if (j != fa && j != x) {
- int a = dfs2(j, i, x);
- res ^= a;
- int b = s1 ^ a;
- int c = s ^ s1;
- int t = Math.max(Math.max(a, b), c) - Math.min(Math.min(a, b), c);
- ans = Math.min(ans, t);
+ if (j != fa) {
+ int s2 = dfs2(j, i);
+ res ^= s2;
+ int mx = Math.max(Math.max(s ^ s1, s2), s1 ^ s2);
+ int mn = Math.min(Math.min(s ^ s1, s2), s1 ^ s2);
+ ans = Math.min(ans, mx - mn);
}
}
return res;
diff --git a/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.py b/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.py
index edf596f36d56f..cb5d0a0d65561 100644
--- a/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.py
+++ b/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.py
@@ -1,37 +1,33 @@
class Solution:
def minimumScore(self, nums: List[int], edges: List[List[int]]) -> int:
- def dfs(i, fa, x):
+ def dfs(i: int, fa: int) -> int:
res = nums[i]
for j in g[i]:
- if j != fa and j != x:
- res ^= dfs(j, i, x)
+ if j != fa:
+ res ^= dfs(j, i)
return res
- def dfs2(i, fa, x):
+ def dfs2(i: int, fa: int) -> int:
nonlocal s, s1, ans
res = nums[i]
for j in g[i]:
- if j != fa and j != x:
- a = dfs2(j, i, x)
- res ^= a
- b = s1 ^ a
- c = s ^ s1
- t = max(a, b, c) - min(a, b, c)
- ans = min(ans, t)
+ if j != fa:
+ s2 = dfs2(j, i)
+ res ^= s2
+ mx = max(s ^ s1, s2, s1 ^ s2)
+ mn = min(s ^ s1, s2, s1 ^ s2)
+ ans = min(ans, mx - mn)
return res
g = defaultdict(list)
for a, b in edges:
g[a].append(b)
g[b].append(a)
-
- s = 0
- for v in nums:
- s ^= v
+ s = reduce(lambda x, y: x ^ y, nums)
n = len(nums)
ans = inf
for i in range(n):
for j in g[i]:
- s1 = dfs(i, -1, j)
- dfs2(i, -1, j)
+ s1 = dfs(i, j)
+ dfs2(i, j)
return ans
diff --git a/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.rs b/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.rs
new file mode 100644
index 0000000000000..beda2b208ac07
--- /dev/null
+++ b/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.rs
@@ -0,0 +1,55 @@
+impl Solution {
+ pub fn minimum_score(nums: Vec, edges: Vec>) -> i32 {
+ let n = nums.len();
+ let mut g = vec![vec![]; n];
+ for e in edges.iter() {
+ let a = e[0] as usize;
+ let b = e[1] as usize;
+ g[a].push(b);
+ g[b].push(a);
+ }
+ let mut s1 = 0;
+ let mut ans = i32::MAX;
+ let s = nums.iter().fold(0, |acc, &x| acc ^ x);
+
+ fn dfs(i: usize, fa: usize, g: &Vec>, nums: &Vec) -> i32 {
+ let mut res = nums[i];
+ for &j in &g[i] {
+ if j != fa {
+ res ^= dfs(j, i, g, nums);
+ }
+ }
+ res
+ }
+
+ fn dfs2(
+ i: usize,
+ fa: usize,
+ g: &Vec>,
+ nums: &Vec,
+ s: i32,
+ s1: i32,
+ ans: &mut i32,
+ ) -> i32 {
+ let mut res = nums[i];
+ for &j in &g[i] {
+ if j != fa {
+ let s2 = dfs2(j, i, g, nums, s, s1, ans);
+ res ^= s2;
+ let mx = (s ^ s1).max(s2).max(s1 ^ s2);
+ let mn = (s ^ s1).min(s2).min(s1 ^ s2);
+ *ans = (*ans).min(mx - mn);
+ }
+ }
+ res
+ }
+
+ for i in 0..n {
+ for &j in &g[i] {
+ s1 = dfs(i, j, &g, &nums);
+ dfs2(i, j, &g, &nums, s, s1, &mut ans);
+ }
+ }
+ ans
+ }
+}
diff --git a/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.ts b/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.ts
new file mode 100644
index 0000000000000..8d260562099dc
--- /dev/null
+++ b/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.ts
@@ -0,0 +1,40 @@
+function minimumScore(nums: number[], edges: number[][]): number {
+ const n = nums.length;
+ const g: number[][] = Array.from({ length: n }, () => []);
+ for (const [a, b] of edges) {
+ g[a].push(b);
+ g[b].push(a);
+ }
+ const s = nums.reduce((a, b) => a ^ b, 0);
+ let s1 = 0;
+ let ans = Number.MAX_SAFE_INTEGER;
+ function dfs(i: number, fa: number): number {
+ let res = nums[i];
+ for (const j of g[i]) {
+ if (j !== fa) {
+ res ^= dfs(j, i);
+ }
+ }
+ return res;
+ }
+ function dfs2(i: number, fa: number): number {
+ let res = nums[i];
+ for (const j of g[i]) {
+ if (j !== fa) {
+ const s2 = dfs2(j, i);
+ res ^= s2;
+ const mx = Math.max(s ^ s1, s2, s1 ^ s2);
+ const mn = Math.min(s ^ s1, s2, s1 ^ s2);
+ ans = Math.min(ans, mx - mn);
+ }
+ }
+ return res;
+ }
+ for (let i = 0; i < n; ++i) {
+ for (const j of g[i]) {
+ s1 = dfs(i, j);
+ dfs2(i, j);
+ }
+ }
+ return ans;
+}
diff --git a/solution/2300-2399/2398.Maximum Number of Robots Within Budget/README.md b/solution/2300-2399/2398.Maximum Number of Robots Within Budget/README.md
index feeceb8d4cac1..88cd6ff3fd594 100644
--- a/solution/2300-2399/2398.Maximum Number of Robots Within Budget/README.md
+++ b/solution/2300-2399/2398.Maximum Number of Robots Within Budget/README.md
@@ -28,7 +28,7 @@ tags:
运行 k 个机器人 总开销 是 max(chargeTimes) + k * sum(runningCosts) ，其中 max(chargeTimes) 是这 k 个机器人中最大充电时间，sum(runningCosts) 是这 k 个机器人的运行时间之和。
-请你返回在 不超过 budget 的前提下，你 最多 可以 连续 运行的机器人数目为多少。
+请你返回在 不超过 budget 的前提下，你 最多 可以运行的 连续 的机器人数目为多少。
diff --git a/solution/2400-2499/2410.Maximum Matching of Players With Trainers/README.md b/solution/2400-2499/2410.Maximum Matching of Players With Trainers/README.md
index cfb76752d6645..f595b49b4cf72 100644
--- a/solution/2400-2499/2410.Maximum Matching of Players With Trainers/README.md
+++ b/solution/2400-2499/2410.Maximum Matching of Players With Trainers/README.md
@@ -174,6 +174,29 @@ function matchPlayersAndTrainers(players: number[], trainers: number[]): number
}
```
+#### Rust
+
+```rust
+impl Solution {
+ pub fn match_players_and_trainers(mut players: Vec, mut trainers: Vec) -> i32 {
+ players.sort();
+ trainers.sort();
+ let mut j = 0;
+ let n = trainers.len();
+ for (i, &p) in players.iter().enumerate() {
+ while j < n && trainers[j] < p {
+ j += 1;
+ }
+ if j == n {
+ return i as i32;
+ }
+ j += 1;
+ }
+ players.len() as i32
+ }
+}
+```
+
diff --git a/solution/2400-2499/2410.Maximum Matching of Players With Trainers/README_EN.md b/solution/2400-2499/2410.Maximum Matching of Players With Trainers/README_EN.md
index 66393a74c65a7..b359f7d080bbb 100644
--- a/solution/2400-2499/2410.Maximum Matching of Players With Trainers/README_EN.md
+++ b/solution/2400-2499/2410.Maximum Matching of Players With Trainers/README_EN.md
@@ -177,6 +177,29 @@ function matchPlayersAndTrainers(players: number[], trainers: number[]): number
}
```
+#### Rust
+
+```rust
+impl Solution {
+ pub fn match_players_and_trainers(mut players: Vec, mut trainers: Vec) -> i32 {
+ players.sort();
+ trainers.sort();
+ let mut j = 0;
+ let n = trainers.len();
+ for (i, &p) in players.iter().enumerate() {
+ while j < n && trainers[j] < p {
+ j += 1;
+ }
+ if j == n {
+ return i as i32;
+ }
+ j += 1;
+ }
+ players.len() as i32
+ }
+}
+```
+
diff --git a/solution/2400-2499/2410.Maximum Matching of Players With Trainers/Solution.rs b/solution/2400-2499/2410.Maximum Matching of Players With Trainers/Solution.rs
new file mode 100644
index 0000000000000..2d2906e9effd2
--- /dev/null
+++ b/solution/2400-2499/2410.Maximum Matching of Players With Trainers/Solution.rs
@@ -0,0 +1,18 @@
+impl Solution {
+ pub fn match_players_and_trainers(mut players: Vec, mut trainers: Vec) -> i32 {
+ players.sort();
+ trainers.sort();
+ let mut j = 0;
+ let n = trainers.len();
+ for (i, &p) in players.iter().enumerate() {
+ while j < n && trainers[j] < p {
+ j += 1;
+ }
+ if j == n {
+ return i as i32;
+ }
+ j += 1;
+ }
+ players.len() as i32
+ }
+}
diff --git a/solution/2400-2499/2411.Smallest Subarrays With Maximum Bitwise OR/README.md b/solution/2400-2499/2411.Smallest Subarrays With Maximum Bitwise OR/README.md
index 5324665f4dcf0..da598c53cd2f0 100644
--- a/solution/2400-2499/2411.Smallest Subarrays With Maximum Bitwise OR/README.md
+++ b/solution/2400-2499/2411.Smallest Subarrays With Maximum Bitwise OR/README.md
@@ -181,6 +181,56 @@ func smallestSubarrays(nums []int) []int {
}
```
+#### Typescript
+
+```ts
+function smallestSubarrays(nums: number[]): number[] {
+ const n = nums.length;
+ const ans: number[] = Array(n).fill(1);
+ const f: number[] = Array(32).fill(-1);
+
+ for (let i = n - 1; i >= 0; i--) {
+ let t = 1;
+ for (let j = 0; j < 32; j++) {
+ if ((nums[i] >> j) & 1) {
+ f[j] = i;
+ } else if (f[j] !== -1) {
+ t = Math.max(t, f[j] - i + 1);
+ }
+ }
+ ans[i] = t;
+ }
+
+ return ans;
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+ pub fn smallest_subarrays(nums: Vec) -> Vec {
+ let n = nums.len();
+ let mut ans = vec![1; n];
+ let mut f = vec![-1; 32];
+
+ for i in (0..n).rev() {
+ let mut t = 1;
+ for j in 0..32 {
+ if (nums[i] >> j) & 1 != 0 {
+ f[j] = i as i32;
+ } else if f[j] != -1 {
+ t = t.max(f[j] - i as i32 + 1);
+ }
+ }
+ ans[i] = t;
+ }
+
+ ans
+ }
+}
+```
+
diff --git a/solution/2400-2499/2411.Smallest Subarrays With Maximum Bitwise OR/README_EN.md b/solution/2400-2499/2411.Smallest Subarrays With Maximum Bitwise OR/README_EN.md
index 39e27135248b9..574891f90c461 100644
--- a/solution/2400-2499/2411.Smallest Subarrays With Maximum Bitwise OR/README_EN.md
+++ b/solution/2400-2499/2411.Smallest Subarrays With Maximum Bitwise OR/README_EN.md
@@ -181,6 +181,56 @@ func smallestSubarrays(nums []int) []int {
}
```
+#### TypeScript
+
+```ts
+function smallestSubarrays(nums: number[]): number[] {
+ const n = nums.length;
+ const ans: number[] = Array(n).fill(1);
+ const f: number[] = Array(32).fill(-1);
+
+ for (let i = n - 1; i >= 0; i--) {
+ let t = 1;
+ for (let j = 0; j < 32; j++) {
+ if ((nums[i] >> j) & 1) {
+ f[j] = i;
+ } else if (f[j] !== -1) {
+ t = Math.max(t, f[j] - i + 1);
+ }
+ }
+ ans[i] = t;
+ }
+
+ return ans;
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+ pub fn smallest_subarrays(nums: Vec) -> Vec {
+ let n = nums.len();
+ let mut ans = vec![1; n];
+ let mut f = vec![-1; 32];
+
+ for i in (0..n).rev() {
+ let mut t = 1;
+ for j in 0..32 {
+ if (nums[i] >> j) & 1 != 0 {
+ f[j] = i as i32;
+ } else if f[j] != -1 {
+ t = t.max(f[j] - i as i32 + 1);
+ }
+ }
+ ans[i] = t;
+ }
+
+ ans
+ }
+}
+```
+
diff --git a/solution/2400-2499/2411.Smallest Subarrays With Maximum Bitwise OR/Solution.rs b/solution/2400-2499/2411.Smallest Subarrays With Maximum Bitwise OR/Solution.rs
new file mode 100644
index 0000000000000..368c25620a92c
--- /dev/null
+++ b/solution/2400-2499/2411.Smallest Subarrays With Maximum Bitwise OR/Solution.rs
@@ -0,0 +1,21 @@
+impl Solution {
+ pub fn smallest_subarrays(nums: Vec) -> Vec {
+ let n = nums.len();
+ let mut ans = vec![1; n];
+ let mut f = vec![-1; 32];
+
+ for i in (0..n).rev() {
+ let mut t = 1;
+ for j in 0..32 {
+ if (nums[i] >> j) & 1 != 0 {
+ f[j] = i as i32;
+ } else if f[j] != -1 {
+ t = t.max(f[j] - i as i32 + 1);
+ }
+ }
+ ans[i] = t;
+ }
+
+ ans
+ }
+}
diff --git a/solution/2400-2499/2411.Smallest Subarrays With Maximum Bitwise OR/Solution.ts b/solution/2400-2499/2411.Smallest Subarrays With Maximum Bitwise OR/Solution.ts
new file mode 100644
index 0000000000000..c70a00bf5a1db
--- /dev/null
+++ b/solution/2400-2499/2411.Smallest Subarrays With Maximum Bitwise OR/Solution.ts
@@ -0,0 +1,19 @@
+function smallestSubarrays(nums: number[]): number[] {
+ const n = nums.length;
+ const ans: number[] = Array(n).fill(1);
+ const f: number[] = Array(32).fill(-1);
+
+ for (let i = n - 1; i >= 0; i--) {
+ let t = 1;
+ for (let j = 0; j < 32; j++) {
+ if ((nums[i] >> j) & 1) {
+ f[j] = i;
+ } else if (f[j] !== -1) {
+ t = Math.max(t, f[j] - i + 1);
+ }
+ }
+ ans[i] = t;
+ }
+
+ return ans;
+}
diff --git a/solution/2400-2499/2419.Longest Subarray With Maximum Bitwise AND/README.md b/solution/2400-2499/2419.Longest Subarray With Maximum Bitwise AND/README.md
index 1de9e92ed8677..f5b167c632c59 100644
--- a/solution/2400-2499/2419.Longest Subarray With Maximum Bitwise AND/README.md
+++ b/solution/2400-2499/2419.Longest Subarray With Maximum Bitwise AND/README.md
@@ -217,6 +217,51 @@ var longestSubarray = function (nums) {
};
```
+#### C#
+
+```cs
+public class Solution {
+ public int LongestSubarray(int[] nums) {
+ int mx = nums.Max();
+ int ans = 0, cnt = 0;
+ foreach (int x in nums) {
+ if (x == mx) {
+ ans = Math.Max(ans, ++cnt);
+ } else {
+ cnt = 0;
+ }
+ }
+ return ans;
+ }
+}
+```
+
+#### PHP
+
+```php
+class Solution {
+ /**
+ * @param Integer[] $nums
+ * @return Integer
+ */
+ function longestSubarray($nums) {
+ $mx = max($nums);
+ $ans = 0;
+ $cnt = 0;
+
+ foreach ($nums as $x) {
+ if ($x == $mx) {
+ $ans = max($ans, ++$cnt);
+ } else {
+ $cnt = 0;
+ }
+ }
+
+ return $ans;
+ }
+}
+```
+
diff --git a/solution/2400-2499/2419.Longest Subarray With Maximum Bitwise AND/README_EN.md b/solution/2400-2499/2419.Longest Subarray With Maximum Bitwise AND/README_EN.md
index c95729b44a910..e6d663d5fd01b 100644
--- a/solution/2400-2499/2419.Longest Subarray With Maximum Bitwise AND/README_EN.md
+++ b/solution/2400-2499/2419.Longest Subarray With Maximum Bitwise AND/README_EN.md
@@ -215,6 +215,51 @@ var longestSubarray = function (nums) {
};
```
+#### C#
+
+```cs
+public class Solution {
+ public int LongestSubarray(int[] nums) {
+ int mx = nums.Max();
+ int ans = 0, cnt = 0;
+ foreach (int x in nums) {
+ if (x == mx) {
+ ans = Math.Max(ans, ++cnt);
+ } else {
+ cnt = 0;
+ }
+ }
+ return ans;
+ }
+}
+```
+
+#### PHP
+
+```php
+class Solution {
+ /**
+ * @param Integer[] $nums
+ * @return Integer
+ */
+ function longestSubarray($nums) {
+ $mx = max($nums);
+ $ans = 0;
+ $cnt = 0;
+
+ foreach ($nums as $x) {
+ if ($x == $mx) {
+ $ans = max($ans, ++$cnt);
+ } else {
+ $cnt = 0;
+ }
+ }
+
+ return $ans;
+ }
+}
+```
+
diff --git a/solution/2400-2499/2419.Longest Subarray With Maximum Bitwise AND/Solution.cs b/solution/2400-2499/2419.Longest Subarray With Maximum Bitwise AND/Solution.cs
new file mode 100644
index 0000000000000..43ec08525037c
--- /dev/null
+++ b/solution/2400-2499/2419.Longest Subarray With Maximum Bitwise AND/Solution.cs
@@ -0,0 +1,14 @@
+public class Solution {
+ public int LongestSubarray(int[] nums) {
+ int mx = nums.Max();
+ int ans = 0, cnt = 0;
+ foreach (int x in nums) {
+ if (x == mx) {
+ ans = Math.Max(ans, ++cnt);
+ } else {
+ cnt = 0;
+ }
+ }
+ return ans;
+ }
+}
diff --git a/solution/2400-2499/2419.Longest Subarray With Maximum Bitwise AND/Solution.php b/solution/2400-2499/2419.Longest Subarray With Maximum Bitwise AND/Solution.php
new file mode 100644
index 0000000000000..390d95d2acbd8
--- /dev/null
+++ b/solution/2400-2499/2419.Longest Subarray With Maximum Bitwise AND/Solution.php
@@ -0,0 +1,21 @@
+class Solution {
+ /**
+ * @param Integer[] $nums
+ * @return Integer
+ */
+ function longestSubarray($nums) {
+ $mx = max($nums);
+ $ans = 0;
+ $cnt = 0;
+
+ foreach ($nums as $x) {
+ if ($x == $mx) {
+ $ans = max($ans, ++$cnt);
+ } else {
+ $cnt = 0;
+ }
+ }
+
+ return $ans;
+ }
+}
\ No newline at end of file
diff --git a/solution/2500-2599/2561.Rearranging Fruits/README.md b/solution/2500-2599/2561.Rearranging Fruits/README.md
index 29055569cca7d..9f4b96da07532 100644
--- a/solution/2500-2599/2561.Rearranging Fruits/README.md
+++ b/solution/2500-2599/2561.Rearranging Fruits/README.md
@@ -6,6 +6,7 @@ rating: 2221
source: 第 331 场周赛 Q4
tags:
- 贪心
+ - 排序
- 数组
- 哈希表
---
@@ -54,7 +55,7 @@ tags:
提示：
- basket1.length == bakste2.lengthbasket1.length == basket2.length1 <= basket1.length <= 10
