;
-};
+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/1236.Web Crawler/README.md b/solution/1200-1299/1236.Web Crawler/README.md
index b8576d0677d3b..02c0e243a2ce2 100644
--- a/solution/1200-1299/1236.Web Crawler/README.md
+++ b/solution/1200-1299/1236.Web Crawler/README.md
@@ -19,22 +19,22 @@ tags:
-给定一个链接 startUrl 和一个接口 HtmlParser ，请你实现一个网络爬虫，以实现爬取同 startUrl 拥有相同 主机名 的全部链接。
+给定一个网址 startUrl 和一个接口 HtmlParser ，请你实现一个网络爬虫，以实现爬取同 startUrl 拥有相同 主机名 的全部链接。
-该爬虫得到的全部链接可以 任何顺序 返回结果。
+该爬虫得到的全部网址可以 任何顺序 返回结果。
你的网络爬虫应当按照如下模式工作：
- - 自链接
startUrl 开始爬取
- - 调用
HtmlParser.getUrls(url) 来获得链接url页面中的全部链接
+ - 自页面
startUrl 开始爬取
+ - 调用
HtmlParser.getUrls(url) 来获得给定 url 网址中的全部链接
- 同一个链接最多只爬取一次
- - 只输出 域名 与
startUrl 相同 的链接集合
+ - 只浏览 域名 与
startUrl 相同 的链接集合
-如上所示的一个链接，其域名为 example.org。简单起见，你可以假设所有的链接都采用 http协议 并没有指定 端口。例如，链接 http://leetcode.com/problems 和 http://leetcode.com/contest 是同一个域名下的，而链接 http://example.org/test 和 http://example.com/abc 是不在同一域名下的。
+如上所示的一个网址，其域名为 example.org。简单起见，你可以假设所有的网址都采用 http协议 并没有指定 端口。例如，网址 http://leetcode.com/problems 和 http://leetcode.com/contest 是同一个域名下的，而网址 http://example.org/test 和 http://example.com/abc 是不在同一域名下的。
HtmlParser 接口定义如下：
@@ -46,7 +46,7 @@ interface HtmlParser {
下面是两个实例，用以解释该问题的设计功能，对于自定义测试，你可以使用三个变量 urls, edges 和 startUrl。注意在代码实现中，你只可以访问 startUrl ，而 urls 和 edges 不可以在你的代码中被直接访问。
-注意：将尾随斜线“/”的相同 URL 视为不同的 URL。例如，“http://news.yahoo.com” 和 “http://news.yahoo.com/” 是不同的域名。
+注意：将尾随斜线“/”的相同网址视为不同的网址。例如，“http://news.yahoo.com” 和 “http://news.yahoo.com/” 是不同的网址。
diff --git a/solution/1200-1299/1238.Circular Permutation in Binary Representation/README_EN.md b/solution/1200-1299/1238.Circular Permutation in Binary Representation/README_EN.md
index 57a0b48ed9325..f3d3a209aa212 100644
--- a/solution/1200-1299/1238.Circular Permutation in Binary Representation/README_EN.md
+++ b/solution/1200-1299/1238.Circular Permutation in Binary Representation/README_EN.md
@@ -23,35 +23,53 @@ tags:
Given 2 integers n and start. Your task is return any permutation p of (0,1,2.....,2^n -1) such that :
- p[0] = startp[i] and p[i+1] differ by only one bit in their binary representation.p[0] and p[2^n -1] must also differ by only one bit in their binary representation.p[0] = startp[i] and p[i+1] differ by only one bit in their binary representation.p[0] and p[2^n -1] must also differ by only one bit in their binary representation.
+
Example 1:
+
Input: n = 2, start = 3
+
Output: [3,2,0,1]
+
Explanation: The binary representation of the permutation is (11,10,00,01).
+
All the adjacent element differ by one bit. Another valid permutation is [3,1,0,2]
+
Example 2:
+
Input: n = 3, start = 2
+
Output: [2,6,7,5,4,0,1,3]
+
Explanation: The binary representation of the permutation is (010,110,111,101,100,000,001,011).
+
+
Constraints:
- 1 <= n <= 160 <= start < 2 ^ n1 <= n <= 160 <= start < 2 ^ n
diff --git a/solution/1200-1299/1256.Encode Number/README_EN.md b/solution/1200-1299/1256.Encode Number/README_EN.md
index 8793661958481..43b8d3ed61ded 100644
--- a/solution/1200-1299/1256.Encode Number/README_EN.md
+++ b/solution/1200-1299/1256.Encode Number/README_EN.md
@@ -27,25 +27,35 @@ tags:
+
Example 1:
+
Input: num = 23
+
Output: "1000"
+
Example 2:
+
Input: num = 107
+
Output: "101100"
+
+
Constraints:
- 0 <= num <= 10^90 <= num <= 10^9
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/1301.Number of Paths with Max Score/README_EN.md b/solution/1300-1399/1301.Number of Paths with Max Score/README_EN.md
index e9ae14167981a..42f8aab8492d8 100644
--- a/solution/1300-1399/1301.Number of Paths with Max Score/README_EN.md
+++ b/solution/1300-1399/1301.Number of Paths with Max Score/README_EN.md
@@ -29,21 +29,35 @@ tags:
In case there is no path, return [0, 0].
+
Example 1:
+
Input: board = ["E23","2X2","12S"]
+
Output: [7,1]
+
Example 2:
+
Input: board = ["E12","1X1","21S"]
+
Output: [4,2]
+
Example 3:
+
Input: board = ["E11","XXX","11S"]
+
Output: [0,0]
+
+
+
Constraints:
- 2 <= board.length == board[i].length <= 1002 <= board.length == board[i].length <= 100
diff --git a/solution/1300-1399/1318.Minimum Flips to Make a OR b Equal to c/README_EN.md b/solution/1300-1399/1318.Minimum Flips to Make a OR b Equal to c/README_EN.md
index 25cf3e136deec..5d94e91fb76df 100644
--- a/solution/1300-1399/1318.Minimum Flips to Make a OR b Equal to c/README_EN.md
+++ b/solution/1300-1399/1318.Minimum Flips to Make a OR b Equal to c/README_EN.md
@@ -19,39 +19,55 @@ tags:
Given 3 positives numbers a, b and c. Return the minimum flips required in some bits of a and b to make ( a OR b == c ). (bitwise OR operation).
+
Flip operation consists of change any single bit 1 to 0 or change the bit 0 to 1 in their binary representation.
+
Example 1:
+
Input: a = 2, b = 6, c = 5
+
Output: 3
+
Explanation: After flips a = 1 , b = 4 , c = 5 such that (a OR b == c)
Example 2:
+
Input: a = 4, b = 2, c = 7
+
Output: 1
+
Example 3:
+
Input: a = 1, b = 2, c = 3
+
Output: 0
+
+
Constraints:
- 1 <= a <= 10^91 <= b <= 10^91 <= c <= 10^91 <= a <= 10^91 <= b <= 10^91 <= c <= 10^9
diff --git a/solution/1300-1399/1324.Print Words Vertically/README_EN.md b/solution/1300-1399/1324.Print Words Vertically/README_EN.md
index e1542d061c72f..c86ec25b2c2cb 100644
--- a/solution/1300-1399/1324.Print Words Vertically/README_EN.md
+++ b/solution/1300-1399/1324.Print Words Vertically/README_EN.md
@@ -21,46 +21,71 @@ tags:
Given a string s. Return all the words vertically in the same order in which they appear in s.
+
Words are returned as a list of strings, complete with spaces when is necessary. (Trailing spaces are not allowed).
+
Each word would be put on only one column and that in one column there will be only one word.
+
Example 1:
+
Input: s = "HOW ARE YOU"
+
Output: ["HAY","ORO","WEU"]
+
Explanation: Each word is printed vertically.
+
"HAY"
+
"ORO"
+
"WEU"
+
Example 2:
+
Input: s = "TO BE OR NOT TO BE"
+
Output: ["TBONTB","OEROOE"," T"]
+
Explanation: Trailing spaces is not allowed.
+
"TBONTB"
+
"OEROOE"
+
" T"
+
Example 3:
+
Input: s = "CONTEST IS COMING"
+
Output: ["CIC","OSO","N M","T I","E N","S G","T"]
+
+
Constraints:
- 1 <= s.length <= 200s contains only upper case English letters.- It's guaranteed that there is only one space between 2 words.
+
+ 1 <= s.length <= 200s contains only upper case English letters.- It's guaranteed that there is only one space between 2 words.
+
diff --git a/solution/1300-1399/1334.Find the City With the Smallest Number of Neighbors at a Threshold Distance/README.md b/solution/1300-1399/1334.Find the City With the Smallest Number of Neighbors at a Threshold Distance/README.md
index 20c633d1c9fe2..83f740df319b5 100644
--- a/solution/1300-1399/1334.Find the City With the Smallest Number of Neighbors at a Threshold Distance/README.md
+++ b/solution/1300-1399/1334.Find the City With the Smallest Number of Neighbors at a Threshold Distance/README.md
@@ -30,7 +30,7 @@ tags:
示例 1：
-
+
输入：n = 4, edges = [[0,1,3],[1,2,1],[1,3,4],[2,3,1]], distanceThreshold = 4
@@ -46,7 +46,7 @@ tags:
示例 2：
-
+
输入：n = 5, edges = [[0,1,2],[0,4,8],[1,2,3],[1,4,2],[2,3,1],[3,4,1]], distanceThreshold = 2
diff --git a/solution/1300-1399/1340.Jump Game V/README.md b/solution/1300-1399/1340.Jump Game V/README.md
index 0660b49704759..b51d004488eaa 100644
--- a/solution/1300-1399/1340.Jump Game V/README.md
+++ b/solution/1300-1399/1340.Jump Game V/README.md
@@ -280,9 +280,7 @@ class Solution {
public int maxJumps(int[] arr, int d) {
int n = arr.length;
Integer[] idx = new Integer[n];
- for (int i = 0; i < n; ++i) {
- idx[i] = i;
- }
+ Arrays.setAll(idx, i -> i);
Arrays.sort(idx, (i, j) -> arr[i] - arr[j]);
int[] f = new int[n];
Arrays.fill(f, 1);
diff --git a/solution/1300-1399/1340.Jump Game V/README_EN.md b/solution/1300-1399/1340.Jump Game V/README_EN.md
index 96a1c9e3a29e9..d502c5e896373 100644
--- a/solution/1300-1399/1340.Jump Game V/README_EN.md
+++ b/solution/1300-1399/1340.Jump Game V/README_EN.md
@@ -251,9 +251,7 @@ class Solution {
public int maxJumps(int[] arr, int d) {
int n = arr.length;
Integer[] idx = new Integer[n];
- for (int i = 0; i < n; ++i) {
- idx[i] = i;
- }
+ Arrays.setAll(idx, i -> i);
Arrays.sort(idx, (i, j) -> arr[i] - arr[j]);
int[] f = new int[n];
Arrays.fill(f, 1);
diff --git a/solution/1300-1399/1340.Jump Game V/Solution2.java b/solution/1300-1399/1340.Jump Game V/Solution2.java
index 7eadbd4bb0a0a..9dd9b724cefe3 100644
--- a/solution/1300-1399/1340.Jump Game V/Solution2.java
+++ b/solution/1300-1399/1340.Jump Game V/Solution2.java
@@ -2,9 +2,7 @@ class Solution {
public int maxJumps(int[] arr, int d) {
int n = arr.length;
Integer[] idx = new Integer[n];
- for (int i = 0; i < n; ++i) {
- idx[i] = i;
- }
+ Arrays.setAll(idx, i -> i);
Arrays.sort(idx, (i, j) -> arr[i] - arr[j]);
int[] f = new int[n];
Arrays.fill(f, 1);
diff --git a/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/README.md b/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/README.md
index 1cbd1775a10f1..350c5c527eb1d 100644
--- a/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/README.md
+++ b/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/README.md
@@ -68,13 +68,17 @@ tags:
### 方法一：哈希表 + 贪心 + 优先队列
-定义哈希表记录每个会议的开始和结束时间，其中键为会议开始时间，值为结束时间列表。
+我们用一个哈希表 $\textit{g}$ 记录每个会议的开始和结束时间。键为会议的开始时间，值为一个列表，包含所有在该开始时间开始的会议的结束时间。用两个变量 $\textit{l}$ 和 $\textit{r}$ 分别记录会议的最小开始时间和最大结束时间。
-枚举当前时间 $s$，找出所有开始时间等于当前时间的会议，将其结束时间加入优先队列（小根堆）中。同时，优先队列要移除所有结束时间小于当前时间的会议。
+对于从小到大每个在 $\textit{l}$ 到 $\textit{r}$ 的时间点 $s$，我们需要做以下操作：
-然后从优先队列中取出结束时间最小的会议，即为当前时间可以参加的会议，累加答案数。如果优先队列为空，则说明当前时间没有可以参加的会议。
+1. 从优先队列中移除所有结束时间小于当前时间 $s$ 的会议。
+2. 将所有开始时间等于当前时间 $s$ 的会议的结束时间加入优先队列中。
+3. 如果优先队列不为空，则取出结束时间最小的会议，累加答案数，并从优先队列中移除该会议。
-时间复杂度 $O(m \times \log n)$，空间复杂度 $O(n)$。其中 $m$, $n$ 分别表示会议的最大结束时间，以及会议的数量。
+这样，我们可以确保在每个时间点 $s$，我们都能参加结束时间最早的会议，从而最大化参加的会议数。
+
+时间复杂度 $O(M \times \log n)$，空间复杂度 $O(n)$，其中 $M$ 和 $n$ 分别为会议的最大结束时间和会议的数量。
@@ -83,22 +87,22 @@ tags:
```python
class Solution:
def maxEvents(self, events: List[List[int]]) -> int:
- d = defaultdict(list)
- i, j = inf, 0
+ g = defaultdict(list)
+ l, r = inf, 0
for s, e in events:
- d[s].append(e)
- i = min(i, s)
- j = max(j, e)
- h = []
+ g[s].append(e)
+ l = min(l, s)
+ r = max(r, e)
+ pq = []
ans = 0
- for s in range(i, j + 1):
- while h and h[0] < s:
- heappop(h)
- for e in d[s]:
- heappush(h, e)
- if h:
+ for s in range(l, r + 1):
+ while pq and pq[0] < s:
+ heappop(pq)
+ for e in g[s]:
+ heappush(pq, e)
+ if pq:
+ heappop(pq)
ans += 1
- heappop(h)
return ans
```
@@ -107,26 +111,26 @@ class Solution:
```java
class Solution {
public int maxEvents(int[][] events) {
- Map> d = new HashMap<>();
- int i = Integer.MAX_VALUE, j = 0;
- for (var v : events) {
- int s = v[0], e = v[1];
- d.computeIfAbsent(s, k -> new ArrayList<>()).add(e);
- i = Math.min(i, s);
- j = Math.max(j, e);
+ Map> g = new HashMap<>();
+ int l = Integer.MAX_VALUE, r = 0;
+ for (int[] event : events) {
+ int s = event[0], e = event[1];
+ g.computeIfAbsent(s, k -> new ArrayList<>()).add(e);
+ l = Math.min(l, s);
+ r = Math.max(r, e);
}
- PriorityQueue q = new PriorityQueue<>();
+ PriorityQueue pq = new PriorityQueue<>();
int ans = 0;
- for (int s = i; s <= j; ++s) {
- while (!q.isEmpty() && q.peek() < s) {
- q.poll();
+ for (int s = l; s <= r; s++) {
+ while (!pq.isEmpty() && pq.peek() < s) {
+ pq.poll();
}
- for (int e : d.getOrDefault(s, Collections.emptyList())) {
- q.offer(e);
+ for (int e : g.getOrDefault(s, List.of())) {
+ pq.offer(e);
}
- if (!q.isEmpty()) {
- q.poll();
- ++ans;
+ if (!pq.isEmpty()) {
+ pq.poll();
+ ans++;
}
}
return ans;
@@ -140,26 +144,26 @@ class Solution {
class Solution {
public:
int maxEvents(vector>& events) {
- unordered_map> d;
- int i = INT_MAX, j = 0;
- for (auto& v : events) {
- int s = v[0], e = v[1];
- d[s].push_back(e);
- i = min(i, s);
- j = max(j, e);
+ unordered_map> g;
+ int l = INT_MAX, r = 0;
+ for (auto& event : events) {
+ int s = event[0], e = event[1];
+ g[s].push_back(e);
+ l = min(l, s);
+ r = max(r, e);
}
- priority_queue, greater> q;
+ priority_queue, greater> pq;
int ans = 0;
- for (int s = i; s <= j; ++s) {
- while (q.size() && q.top() < s) {
- q.pop();
+ for (int s = l; s <= r; ++s) {
+ while (!pq.empty() && pq.top() < s) {
+ pq.pop();
}
- for (int e : d[s]) {
- q.push(e);
+ for (int e : g[s]) {
+ pq.push(e);
}
- if (q.size()) {
+ if (!pq.empty()) {
+ pq.pop();
++ans;
- q.pop();
}
}
return ans;
@@ -170,44 +174,123 @@ public:
#### Go
```go
-func maxEvents(events [][]int) int {
- d := map[int][]int{}
- i, j := math.MaxInt32, 0
- for _, v := range events {
- s, e := v[0], v[1]
- d[s] = append(d[s], e)
- i = min(i, s)
- j = max(j, e)
+func maxEvents(events [][]int) (ans int) {
+ g := map[int][]int{}
+ l, r := math.MaxInt32, 0
+ for _, event := range events {
+ s, e := event[0], event[1]
+ g[s] = append(g[s], e)
+ l = min(l, s)
+ r = max(r, e)
}
- q := hp{}
- ans := 0
- for s := i; s <= j; s++ {
- for q.Len() > 0 && q.IntSlice[0] < s {
- heap.Pop(&q)
+
+ pq := &hp{}
+ heap.Init(pq)
+ for s := l; s <= r; s++ {
+ for pq.Len() > 0 && pq.IntSlice[0] < s {
+ heap.Pop(pq)
}
- for _, e := range d[s] {
- heap.Push(&q, e)
+ for _, e := range g[s] {
+ heap.Push(pq, e)
}
- if q.Len() > 0 {
- heap.Pop(&q)
+ if pq.Len() > 0 {
+ heap.Pop(pq)
ans++
}
}
- return ans
+ return
}
type hp struct{ sort.IntSlice }
func (h *hp) Push(v any) { h.IntSlice = append(h.IntSlice, v.(int)) }
func (h *hp) Pop() any {
- a := h.IntSlice
- v := a[len(a)-1]
- h.IntSlice = a[:len(a)-1]
+ n := len(h.IntSlice)
+ v := h.IntSlice[n-1]
+ h.IntSlice = h.IntSlice[:n-1]
return v
}
func (h *hp) Less(i, j int) bool { return h.IntSlice[i] < h.IntSlice[j] }
```
+#### TypeScript
+
+```ts
+function maxEvents(events: number[][]): number {
+ const g: Map = new Map();
+ let l = Infinity,
+ r = 0;
+ for (const [s, e] of events) {
+ if (!g.has(s)) g.set(s, []);
+ g.get(s)!.push(e);
+ l = Math.min(l, s);
+ r = Math.max(r, e);
+ }
+
+ const pq = new MinPriorityQueue();
+ let ans = 0;
+ for (let s = l; s <= r; s++) {
+ while (!pq.isEmpty() && pq.front() < s) {
+ pq.dequeue();
+ }
+ for (const e of g.get(s) || []) {
+ pq.enqueue(e);
+ }
+ if (!pq.isEmpty()) {
+ pq.dequeue();
+ ans++;
+ }
+ }
+ return ans;
+}
+```
+
+#### Rust
+
+```rust
+use std::collections::{BinaryHeap, HashMap};
+use std::cmp::Reverse;
+
+impl Solution {
+ pub fn max_events(events: Vec>) -> i32 {
+ let mut g: HashMap> = HashMap::new();
+ let mut l = i32::MAX;
+ let mut r = 0;
+
+ for event in events {
+ let s = event[0];
+ let e = event[1];
+ g.entry(s).or_default().push(e);
+ l = l.min(s);
+ r = r.max(e);
+ }
+
+ let mut pq = BinaryHeap::new();
+ let mut ans = 0;
+
+ for s in l..=r {
+ while let Some(&Reverse(top)) = pq.peek() {
+ if top < s {
+ pq.pop();
+ } else {
+ break;
+ }
+ }
+ if let Some(ends) = g.get(&s) {
+ for &e in ends {
+ pq.push(Reverse(e));
+ }
+ }
+ if pq.pop().is_some() {
+ ans += 1;
+ }
+ }
+
+ 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 42234ff46dddb..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.
@@ -64,13 +64,17 @@ Attend the third event on day 3.
### Solution 1: Hash Table + Greedy + Priority Queue
-Define a hash table to record the start and end times of each meeting, where the key is the start time of the meeting, and the value is a list of end times.
+We use a hash table $\textit{g}$ to record the start and end times of each event. The key is the start time of the event, and the value is a list containing the end times of all events that start at that time. Two variables, $\textit{l}$ and $\textit{r}$, are used to record the minimum start time and the maximum end time among all events.
-Enumerate the current time $s$, find all meetings that start at the current time, and add their end times to the priority queue (min heap). At the same time, the priority queue needs to remove all meetings that end before the current time.
+For each time point $s$ from $\textit{l}$ to $\textit{r}$ in increasing order, we perform the following steps:
-Then, take out the meeting with the smallest end time from the priority queue, which is the meeting that can be attended at the current time, and accumulate the answer count. If the priority queue is empty, it means that there are no meetings that can be attended at the current time.
+1. Remove from the priority queue all events whose end time is less than the current time $s$.
+2. Add the end times of all events that start at the current time $s$ to the priority queue.
+3. If the priority queue is not empty, take out the event with the earliest end time, increment the answer count, and remove this event from the priority queue.
-The time complexity is $O(m \times \log n)$, and the space complexity is $O(n)$. Where $m$ and $n$ represent the maximum end time of the meetings and the number of meetings, respectively.
+In this way, we ensure that at each time point $s$, we always attend the event that ends the earliest, thus maximizing the number of events attended.
+
+The time complexity is $O(M \times \log n)$, and the space complexity is $O(n)$, where $M$ is the maximum end time and $n$ is the number of events.
@@ -79,22 +83,22 @@ The time complexity is $O(m \times \log n)$, and the space complexity is $O(n)$.
```python
class Solution:
def maxEvents(self, events: List[List[int]]) -> int:
- d = defaultdict(list)
- i, j = inf, 0
+ g = defaultdict(list)
+ l, r = inf, 0
for s, e in events:
- d[s].append(e)
- i = min(i, s)
- j = max(j, e)
- h = []
+ g[s].append(e)
+ l = min(l, s)
+ r = max(r, e)
+ pq = []
ans = 0
- for s in range(i, j + 1):
- while h and h[0] < s:
- heappop(h)
- for e in d[s]:
- heappush(h, e)
- if h:
+ for s in range(l, r + 1):
+ while pq and pq[0] < s:
+ heappop(pq)
+ for e in g[s]:
+ heappush(pq, e)
+ if pq:
+ heappop(pq)
ans += 1
- heappop(h)
return ans
```
@@ -103,26 +107,26 @@ class Solution:
```java
class Solution {
public int maxEvents(int[][] events) {
- Map> d = new HashMap<>();
- int i = Integer.MAX_VALUE, j = 0;
- for (var v : events) {
- int s = v[0], e = v[1];
- d.computeIfAbsent(s, k -> new ArrayList<>()).add(e);
- i = Math.min(i, s);
- j = Math.max(j, e);
+ Map> g = new HashMap<>();
+ int l = Integer.MAX_VALUE, r = 0;
+ for (int[] event : events) {
+ int s = event[0], e = event[1];
+ g.computeIfAbsent(s, k -> new ArrayList<>()).add(e);
+ l = Math.min(l, s);
+ r = Math.max(r, e);
}
- PriorityQueue q = new PriorityQueue<>();
+ PriorityQueue pq = new PriorityQueue<>();
int ans = 0;
- for (int s = i; s <= j; ++s) {
- while (!q.isEmpty() && q.peek() < s) {
- q.poll();
+ for (int s = l; s <= r; s++) {
+ while (!pq.isEmpty() && pq.peek() < s) {
+ pq.poll();
}
- for (int e : d.getOrDefault(s, Collections.emptyList())) {
- q.offer(e);
+ for (int e : g.getOrDefault(s, List.of())) {
+ pq.offer(e);
}
- if (!q.isEmpty()) {
- q.poll();
- ++ans;
+ if (!pq.isEmpty()) {
+ pq.poll();
+ ans++;
}
}
return ans;
@@ -136,26 +140,26 @@ class Solution {
class Solution {
public:
int maxEvents(vector>& events) {
- unordered_map> d;
- int i = INT_MAX, j = 0;
- for (auto& v : events) {
- int s = v[0], e = v[1];
- d[s].push_back(e);
- i = min(i, s);
- j = max(j, e);
+ unordered_map> g;
+ int l = INT_MAX, r = 0;
+ for (auto& event : events) {
+ int s = event[0], e = event[1];
+ g[s].push_back(e);
+ l = min(l, s);
+ r = max(r, e);
}
- priority_queue, greater> q;
+ priority_queue, greater> pq;
int ans = 0;
- for (int s = i; s <= j; ++s) {
- while (q.size() && q.top() < s) {
- q.pop();
+ for (int s = l; s <= r; ++s) {
+ while (!pq.empty() && pq.top() < s) {
+ pq.pop();
}
- for (int e : d[s]) {
- q.push(e);
+ for (int e : g[s]) {
+ pq.push(e);
}
- if (q.size()) {
+ if (!pq.empty()) {
+ pq.pop();
++ans;
- q.pop();
}
}
return ans;
@@ -166,44 +170,123 @@ public:
#### Go
```go
-func maxEvents(events [][]int) int {
- d := map[int][]int{}
- i, j := math.MaxInt32, 0
- for _, v := range events {
- s, e := v[0], v[1]
- d[s] = append(d[s], e)
- i = min(i, s)
- j = max(j, e)
+func maxEvents(events [][]int) (ans int) {
+ g := map[int][]int{}
+ l, r := math.MaxInt32, 0
+ for _, event := range events {
+ s, e := event[0], event[1]
+ g[s] = append(g[s], e)
+ l = min(l, s)
+ r = max(r, e)
}
- q := hp{}
- ans := 0
- for s := i; s <= j; s++ {
- for q.Len() > 0 && q.IntSlice[0] < s {
- heap.Pop(&q)
+
+ pq := &hp{}
+ heap.Init(pq)
+ for s := l; s <= r; s++ {
+ for pq.Len() > 0 && pq.IntSlice[0] < s {
+ heap.Pop(pq)
}
- for _, e := range d[s] {
- heap.Push(&q, e)
+ for _, e := range g[s] {
+ heap.Push(pq, e)
}
- if q.Len() > 0 {
- heap.Pop(&q)
+ if pq.Len() > 0 {
+ heap.Pop(pq)
ans++
}
}
- return ans
+ return
}
type hp struct{ sort.IntSlice }
func (h *hp) Push(v any) { h.IntSlice = append(h.IntSlice, v.(int)) }
func (h *hp) Pop() any {
- a := h.IntSlice
- v := a[len(a)-1]
- h.IntSlice = a[:len(a)-1]
+ n := len(h.IntSlice)
+ v := h.IntSlice[n-1]
+ h.IntSlice = h.IntSlice[:n-1]
return v
}
func (h *hp) Less(i, j int) bool { return h.IntSlice[i] < h.IntSlice[j] }
```
+#### TypeScript
+
+```ts
+function maxEvents(events: number[][]): number {
+ const g: Map = new Map();
+ let l = Infinity,
+ r = 0;
+ for (const [s, e] of events) {
+ if (!g.has(s)) g.set(s, []);
+ g.get(s)!.push(e);
+ l = Math.min(l, s);
+ r = Math.max(r, e);
+ }
+
+ const pq = new MinPriorityQueue();
+ let ans = 0;
+ for (let s = l; s <= r; s++) {
+ while (!pq.isEmpty() && pq.front() < s) {
+ pq.dequeue();
+ }
+ for (const e of g.get(s) || []) {
+ pq.enqueue(e);
+ }
+ if (!pq.isEmpty()) {
+ pq.dequeue();
+ ans++;
+ }
+ }
+ return ans;
+}
+```
+
+#### Rust
+
+```rust
+use std::collections::{BinaryHeap, HashMap};
+use std::cmp::Reverse;
+
+impl Solution {
+ pub fn max_events(events: Vec>) -> i32 {
+ let mut g: HashMap> = HashMap::new();
+ let mut l = i32::MAX;
+ let mut r = 0;
+
+ for event in events {
+ let s = event[0];
+ let e = event[1];
+ g.entry(s).or_default().push(e);
+ l = l.min(s);
+ r = r.max(e);
+ }
+
+ let mut pq = BinaryHeap::new();
+ let mut ans = 0;
+
+ for s in l..=r {
+ while let Some(&Reverse(top)) = pq.peek() {
+ if top < s {
+ pq.pop();
+ } else {
+ break;
+ }
+ }
+ if let Some(ends) = g.get(&s) {
+ for &e in ends {
+ pq.push(Reverse(e));
+ }
+ }
+ if pq.pop().is_some() {
+ ans += 1;
+ }
+ }
+
+ ans
+ }
+}
+```
+
diff --git a/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/Solution.cpp b/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/Solution.cpp
index b606f12f54a94..bff232aed16a4 100644
--- a/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/Solution.cpp
+++ b/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/Solution.cpp
@@ -1,28 +1,28 @@
class Solution {
public:
int maxEvents(vector>& events) {
- unordered_map> d;
- int i = INT_MAX, j = 0;
- for (auto& v : events) {
- int s = v[0], e = v[1];
- d[s].push_back(e);
- i = min(i, s);
- j = max(j, e);
+ unordered_map> g;
+ int l = INT_MAX, r = 0;
+ for (auto& event : events) {
+ int s = event[0], e = event[1];
+ g[s].push_back(e);
+ l = min(l, s);
+ r = max(r, e);
}
- priority_queue, greater> q;
+ priority_queue, greater> pq;
int ans = 0;
- for (int s = i; s <= j; ++s) {
- while (q.size() && q.top() < s) {
- q.pop();
+ for (int s = l; s <= r; ++s) {
+ while (!pq.empty() && pq.top() < s) {
+ pq.pop();
}
- for (int e : d[s]) {
- q.push(e);
+ for (int e : g[s]) {
+ pq.push(e);
}
- if (q.size()) {
+ if (!pq.empty()) {
+ pq.pop();
++ans;
- q.pop();
}
}
return ans;
}
-};
\ No newline at end of file
+};
diff --git a/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/Solution.go b/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/Solution.go
index df48690182d72..1b5722cd4a3a2 100644
--- a/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/Solution.go
+++ b/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/Solution.go
@@ -1,36 +1,37 @@
-func maxEvents(events [][]int) int {
- d := map[int][]int{}
- i, j := math.MaxInt32, 0
- for _, v := range events {
- s, e := v[0], v[1]
- d[s] = append(d[s], e)
- i = min(i, s)
- j = max(j, e)
+func maxEvents(events [][]int) (ans int) {
+ g := map[int][]int{}
+ l, r := math.MaxInt32, 0
+ for _, event := range events {
+ s, e := event[0], event[1]
+ g[s] = append(g[s], e)
+ l = min(l, s)
+ r = max(r, e)
}
- q := hp{}
- ans := 0
- for s := i; s <= j; s++ {
- for q.Len() > 0 && q.IntSlice[0] < s {
- heap.Pop(&q)
+
+ pq := &hp{}
+ heap.Init(pq)
+ for s := l; s <= r; s++ {
+ for pq.Len() > 0 && pq.IntSlice[0] < s {
+ heap.Pop(pq)
}
- for _, e := range d[s] {
- heap.Push(&q, e)
+ for _, e := range g[s] {
+ heap.Push(pq, e)
}
- if q.Len() > 0 {
- heap.Pop(&q)
+ if pq.Len() > 0 {
+ heap.Pop(pq)
ans++
}
}
- return ans
+ return
}
type hp struct{ sort.IntSlice }
func (h *hp) Push(v any) { h.IntSlice = append(h.IntSlice, v.(int)) }
func (h *hp) Pop() any {
- a := h.IntSlice
- v := a[len(a)-1]
- h.IntSlice = a[:len(a)-1]
+ n := len(h.IntSlice)
+ v := h.IntSlice[n-1]
+ h.IntSlice = h.IntSlice[:n-1]
return v
}
-func (h *hp) Less(i, j int) bool { return h.IntSlice[i] < h.IntSlice[j] }
\ No newline at end of file
+func (h *hp) Less(i, j int) bool { return h.IntSlice[i] < h.IntSlice[j] }
diff --git a/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/Solution.java b/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/Solution.java
index 55ae438150200..f85ae216d53f4 100644
--- a/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/Solution.java
+++ b/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/Solution.java
@@ -1,27 +1,27 @@
class Solution {
public int maxEvents(int[][] events) {
- Map> d = new HashMap<>();
- int i = Integer.MAX_VALUE, j = 0;
- for (var v : events) {
- int s = v[0], e = v[1];
- d.computeIfAbsent(s, k -> new ArrayList<>()).add(e);
- i = Math.min(i, s);
- j = Math.max(j, e);
+ Map> g = new HashMap<>();
+ int l = Integer.MAX_VALUE, r = 0;
+ for (int[] event : events) {
+ int s = event[0], e = event[1];
+ g.computeIfAbsent(s, k -> new ArrayList<>()).add(e);
+ l = Math.min(l, s);
+ r = Math.max(r, e);
}
- PriorityQueue q = new PriorityQueue<>();
+ PriorityQueue pq = new PriorityQueue<>();
int ans = 0;
- for (int s = i; s <= j; ++s) {
- while (!q.isEmpty() && q.peek() < s) {
- q.poll();
+ for (int s = l; s <= r; s++) {
+ while (!pq.isEmpty() && pq.peek() < s) {
+ pq.poll();
}
- for (int e : d.getOrDefault(s, Collections.emptyList())) {
- q.offer(e);
+ for (int e : g.getOrDefault(s, List.of())) {
+ pq.offer(e);
}
- if (!q.isEmpty()) {
- q.poll();
- ++ans;
+ if (!pq.isEmpty()) {
+ pq.poll();
+ ans++;
}
}
return ans;
}
-}
\ No newline at end of file
+}
diff --git a/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/Solution.py b/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/Solution.py
index c8f9fd352a5b7..0d32d73265ae6 100644
--- a/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/Solution.py
+++ b/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/Solution.py
@@ -1,19 +1,19 @@
class Solution:
def maxEvents(self, events: List[List[int]]) -> int:
- d = defaultdict(list)
- i, j = inf, 0
+ g = defaultdict(list)
+ l, r = inf, 0
for s, e in events:
- d[s].append(e)
- i = min(i, s)
- j = max(j, e)
- h = []
+ g[s].append(e)
+ l = min(l, s)
+ r = max(r, e)
+ pq = []
ans = 0
- for s in range(i, j + 1):
- while h and h[0] < s:
- heappop(h)
- for e in d[s]:
- heappush(h, e)
- if h:
+ for s in range(l, r + 1):
+ while pq and pq[0] < s:
+ heappop(pq)
+ for e in g[s]:
+ heappush(pq, e)
+ if pq:
+ heappop(pq)
ans += 1
- heappop(h)
return ans
diff --git a/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/Solution.rs b/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/Solution.rs
new file mode 100644
index 0000000000000..8655f8f45b8c3
--- /dev/null
+++ b/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/Solution.rs
@@ -0,0 +1,41 @@
+use std::cmp::Reverse;
+use std::collections::{BinaryHeap, HashMap};
+
+impl Solution {
+ pub fn max_events(events: Vec>) -> i32 {
+ let mut g: HashMap> = HashMap::new();
+ let mut l = i32::MAX;
+ let mut r = 0;
+
+ for event in events {
+ let s = event[0];
+ let e = event[1];
+ g.entry(s).or_default().push(e);
+ l = l.min(s);
+ r = r.max(e);
+ }
+
+ let mut pq = BinaryHeap::new();
+ let mut ans = 0;
+
+ for s in l..=r {
+ while let Some(&Reverse(top)) = pq.peek() {
+ if top < s {
+ pq.pop();
+ } else {
+ break;
+ }
+ }
+ if let Some(ends) = g.get(&s) {
+ for &e in ends {
+ pq.push(Reverse(e));
+ }
+ }
+ if pq.pop().is_some() {
+ ans += 1;
+ }
+ }
+
+ ans
+ }
+}
diff --git a/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/Solution.ts b/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/Solution.ts
new file mode 100644
index 0000000000000..fe09e3bbc62a7
--- /dev/null
+++ b/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/Solution.ts
@@ -0,0 +1,27 @@
+function maxEvents(events: number[][]): number {
+ const g: Map = new Map();
+ let l = Infinity,
+ r = 0;
+ for (const [s, e] of events) {
+ if (!g.has(s)) g.set(s, []);
+ g.get(s)!.push(e);
+ l = Math.min(l, s);
+ r = Math.max(r, e);
+ }
+
+ const pq = new MinPriorityQueue();
+ let ans = 0;
+ for (let s = l; s <= r; s++) {
+ while (!pq.isEmpty() && pq.front() < s) {
+ pq.dequeue();
+ }
+ for (const e of g.get(s) || []) {
+ pq.enqueue(e);
+ }
+ if (!pq.isEmpty()) {
+ pq.dequeue();
+ ans++;
+ }
+ }
+ return ans;
+}
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/1300-1399/1375.Number of Times Binary String Is Prefix-Aligned/README_EN.md b/solution/1300-1399/1375.Number of Times Binary String Is Prefix-Aligned/README_EN.md
index 85728f8ff86c4..6ee738a4c99d0 100644
--- a/solution/1300-1399/1375.Number of Times Binary String Is Prefix-Aligned/README_EN.md
+++ b/solution/1300-1399/1375.Number of Times Binary String Is Prefix-Aligned/README_EN.md
@@ -18,7 +18,7 @@ tags:
-You have a 1-indexed binary string of length n where all the bits are 0 initially. We will flip all the bits of this binary string (i.e., change them from 0 to 1) one by one. You are given a 1-indexed integer array flips where flips[i] indicates that the bit at index i will be flipped in the ith step.
+You have a 1-indexed binary string of length n where all the bits are 0 initially. We will flip all the bits of this binary string (i.e., change them from 0 to 1) one by one. You are given a 1-indexed integer array flips where flips[i] indicates that the bit at index flips[i] will be flipped in the ith step.
A binary string is prefix-aligned if, after the ith step, all the bits in the inclusive range [1, i] are ones and all the other bits are zeros.
diff --git a/solution/1300-1399/1394.Find Lucky Integer in an Array/README.md b/solution/1300-1399/1394.Find Lucky Integer in an Array/README.md
index ad8e3171ec677..e2aab03d4d2ff 100644
--- a/solution/1300-1399/1394.Find Lucky Integer in an Array/README.md
+++ b/solution/1300-1399/1394.Find Lucky Integer in an Array/README.md
@@ -81,9 +81,9 @@ tags:
### 方法一：计数
-我们可以用哈希表或数组 $cnt$ 统计 $arr$ 中每个数字出现的次数，然后遍历 $cnt$，找到满足 $cnt[x] = x$ 的最大的 $x$ 即可。如果没有这样的 $x$，则返回 $-1$。
+我们可以用哈希表或数组 $\textit{cnt}$ 统计 $\textit{arr}$ 中每个数字出现的次数，然后遍历 $\textit{cnt}$，找到满足 $\textit{cnt}[x] = x$ 的最大的 $x$ 即可。如果没有这样的 $x$，则返回 $-1$。
-时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为 $arr$ 的长度。
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为 $\textit{arr}$ 的长度。
@@ -93,11 +93,7 @@ tags:
class Solution:
def findLucky(self, arr: List[int]) -> int:
cnt = Counter(arr)
- ans = -1
- for x, v in cnt.items():
- if x == v and ans < x:
- ans = x
- return ans
+ return max((x for x, v in cnt.items() if x == v), default=-1)
```
#### Java
@@ -105,17 +101,16 @@ class Solution:
```java
class Solution {
public int findLucky(int[] arr) {
- int[] cnt = new int[510];
- for (int x : cnt) {
+ int[] cnt = new int[501];
+ for (int x : arr) {
++cnt[x];
}
- int ans = -1;
- for (int x = 1; x < cnt.length; ++x) {
- if (cnt[x] == x) {
- ans = x;
+ for (int x = cnt.length - 1; x > 0; --x) {
+ if (x == cnt[x]) {
+ return x;
}
}
- return ans;
+ return -1;
}
}
```
@@ -126,18 +121,16 @@ class Solution {
class Solution {
public:
int findLucky(vector& arr) {
- int cnt[510];
- memset(cnt, 0, sizeof(cnt));
+ int cnt[501]{};
for (int x : arr) {
++cnt[x];
}
- int ans = -1;
- for (int x = 1; x < 510; ++x) {
- if (cnt[x] == x) {
- ans = x;
+ for (int x = 500; x; --x) {
+ if (x == cnt[x]) {
+ return x;
}
}
- return ans;
+ return -1;
}
};
```
@@ -146,17 +139,16 @@ public:
```go
func findLucky(arr []int) int {
- cnt := [510]int{}
+ cnt := [501]int{}
for _, x := range arr {
cnt[x]++
}
- ans := -1
- for x := 1; x < len(cnt); x++ {
- if cnt[x] == x {
- ans = x
+ for x := len(cnt) - 1; x > 0; x-- {
+ if x == cnt[x] {
+ return x
}
}
- return ans
+ return -1
}
```
@@ -164,17 +156,34 @@ func findLucky(arr []int) int {
```ts
function findLucky(arr: number[]): number {
- const cnt = Array(510).fill(0);
+ const cnt: number[] = Array(501).fill(0);
for (const x of arr) {
++cnt[x];
}
- let ans = -1;
- for (let x = 1; x < cnt.length; ++x) {
- if (cnt[x] === x) {
- ans = x;
+ for (let x = cnt.length - 1; x; --x) {
+ if (x === cnt[x]) {
+ return x;
}
}
- return ans;
+ return -1;
+}
+```
+
+#### Rust
+
+```rust
+use std::collections::HashMap;
+
+impl Solution {
+ pub fn find_lucky(arr: Vec) -> i32 {
+ let mut cnt = HashMap::new();
+ arr.iter().for_each(|&x| *cnt.entry(x).or_insert(0) += 1);
+ cnt.iter()
+ .filter(|(&x, &v)| x == v)
+ .map(|(&x, _)| x)
+ .max()
+ .unwrap_or(-1)
+ }
}
```
@@ -187,17 +196,16 @@ class Solution {
* @return Integer
*/
function findLucky($arr) {
- $max = -1;
- for ($i = 0; $i < count($arr); $i++) {
- $hashtable[$arr[$i]] += 1;
+ $cnt = array_fill(0, 501, 0);
+ foreach ($arr as $x) {
+ $cnt[$x]++;
}
- $keys = array_keys($hashtable);
- for ($j = 0; $j < count($keys); $j++) {
- if ($hashtable[$keys[$j]] == $keys[$j]) {
- $max = max($max, $keys[$j]);
+ for ($x = 500; $x > 0; $x--) {
+ if ($cnt[$x] === $x) {
+ return $x;
}
}
- return $max;
+ return -1;
}
}
```
diff --git a/solution/1300-1399/1394.Find Lucky Integer in an Array/README_EN.md b/solution/1300-1399/1394.Find Lucky Integer in an Array/README_EN.md
index 0150e92bf8adf..cf0c8ede706fc 100644
--- a/solution/1300-1399/1394.Find Lucky Integer in an Array/README_EN.md
+++ b/solution/1300-1399/1394.Find Lucky Integer in an Array/README_EN.md
@@ -65,9 +65,9 @@ tags:
### Solution 1: Counting
-We can use a hash table or array $cnt$ to count the occurrences of each number in $arr$, then traverse $cnt$ to find the largest $x$ that satisfies $cnt[x] = x$. If there is no such $x$, return $-1$.
+We can use a hash table or an array $\textit{cnt}$ to count the occurrences of each number in $\textit{arr}$. Then, we iterate through $\textit{cnt}$ to find the largest $x$ such that $\textit{cnt}[x] = x$. If there is no such $x$, return $-1$.
-The time complexity is $O(n)$, and the space complexity is $O(n)$. Where $n$ is the length of $arr$.
+The time complexity is $O(n)$, and the space complexity is $O(n)$, where $n$ is the length of the $\textit{arr}$.
@@ -77,11 +77,7 @@ The time complexity is $O(n)$, and the space complexity is $O(n)$. Where $n$ is
class Solution:
def findLucky(self, arr: List[int]) -> int:
cnt = Counter(arr)
- ans = -1
- for x, v in cnt.items():
- if x == v and ans < x:
- ans = x
- return ans
+ return max((x for x, v in cnt.items() if x == v), default=-1)
```
#### Java
@@ -89,17 +85,16 @@ class Solution:
```java
class Solution {
public int findLucky(int[] arr) {
- int[] cnt = new int[510];
- for (int x : cnt) {
+ int[] cnt = new int[501];
+ for (int x : arr) {
++cnt[x];
}
- int ans = -1;
- for (int x = 1; x < cnt.length; ++x) {
- if (cnt[x] == x) {
- ans = x;
+ for (int x = cnt.length - 1; x > 0; --x) {
+ if (x == cnt[x]) {
+ return x;
}
}
- return ans;
+ return -1;
}
}
```
@@ -110,18 +105,16 @@ class Solution {
class Solution {
public:
int findLucky(vector& arr) {
- int cnt[510];
- memset(cnt, 0, sizeof(cnt));
+ int cnt[501]{};
for (int x : arr) {
++cnt[x];
}
- int ans = -1;
- for (int x = 1; x < 510; ++x) {
- if (cnt[x] == x) {
- ans = x;
+ for (int x = 500; x; --x) {
+ if (x == cnt[x]) {
+ return x;
}
}
- return ans;
+ return -1;
}
};
```
@@ -130,17 +123,16 @@ public:
```go
func findLucky(arr []int) int {
- cnt := [510]int{}
+ cnt := [501]int{}
for _, x := range arr {
cnt[x]++
}
- ans := -1
- for x := 1; x < len(cnt); x++ {
- if cnt[x] == x {
- ans = x
+ for x := len(cnt) - 1; x > 0; x-- {
+ if x == cnt[x] {
+ return x
}
}
- return ans
+ return -1
}
```
@@ -148,17 +140,34 @@ func findLucky(arr []int) int {
```ts
function findLucky(arr: number[]): number {
- const cnt = Array(510).fill(0);
+ const cnt: number[] = Array(501).fill(0);
for (const x of arr) {
++cnt[x];
}
- let ans = -1;
- for (let x = 1; x < cnt.length; ++x) {
- if (cnt[x] === x) {
- ans = x;
+ for (let x = cnt.length - 1; x; --x) {
+ if (x === cnt[x]) {
+ return x;
}
}
- return ans;
+ return -1;
+}
+```
+
+#### Rust
+
+```rust
+use std::collections::HashMap;
+
+impl Solution {
+ pub fn find_lucky(arr: Vec) -> i32 {
+ let mut cnt = HashMap::new();
+ arr.iter().for_each(|&x| *cnt.entry(x).or_insert(0) += 1);
+ cnt.iter()
+ .filter(|(&x, &v)| x == v)
+ .map(|(&x, _)| x)
+ .max()
+ .unwrap_or(-1)
+ }
}
```
@@ -171,17 +180,16 @@ class Solution {
* @return Integer
*/
function findLucky($arr) {
- $max = -1;
- for ($i = 0; $i < count($arr); $i++) {
- $hashtable[$arr[$i]] += 1;
+ $cnt = array_fill(0, 501, 0);
+ foreach ($arr as $x) {
+ $cnt[$x]++;
}
- $keys = array_keys($hashtable);
- for ($j = 0; $j < count($keys); $j++) {
- if ($hashtable[$keys[$j]] == $keys[$j]) {
- $max = max($max, $keys[$j]);
+ for ($x = 500; $x > 0; $x--) {
+ if ($cnt[$x] === $x) {
+ return $x;
}
}
- return $max;
+ return -1;
}
}
```
diff --git a/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.cpp b/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.cpp
index fc249af1dfb56..bd184b1b614af 100644
--- a/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.cpp
+++ b/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.cpp
@@ -1,17 +1,15 @@
class Solution {
public:
int findLucky(vector& arr) {
- int cnt[510];
- memset(cnt, 0, sizeof(cnt));
+ int cnt[501]{};
for (int x : arr) {
++cnt[x];
}
- int ans = -1;
- for (int x = 1; x < 510; ++x) {
- if (cnt[x] == x) {
- ans = x;
+ for (int x = 500; x; --x) {
+ if (x == cnt[x]) {
+ return x;
}
}
- return ans;
+ return -1;
}
};
\ No newline at end of file
diff --git a/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.go b/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.go
index c7cc0cf11c3d8..2065349fea7da 100644
--- a/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.go
+++ b/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.go
@@ -1,13 +1,12 @@
func findLucky(arr []int) int {
- cnt := [510]int{}
+ cnt := [501]int{}
for _, x := range arr {
cnt[x]++
}
- ans := -1
- for x := 1; x < len(cnt); x++ {
- if cnt[x] == x {
- ans = x
+ for x := len(cnt) - 1; x > 0; x-- {
+ if x == cnt[x] {
+ return x
}
}
- return ans
+ return -1
}
\ No newline at end of file
diff --git a/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.java b/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.java
index b46b186230051..e032656eb678a 100644
--- a/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.java
+++ b/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.java
@@ -1,15 +1,14 @@
class Solution {
public int findLucky(int[] arr) {
- int[] cnt = new int[510];
- for (int x : cnt) {
+ int[] cnt = new int[501];
+ for (int x : arr) {
++cnt[x];
}
- int ans = -1;
- for (int x = 1; x < cnt.length; ++x) {
- if (cnt[x] == x) {
- ans = x;
+ for (int x = cnt.length - 1; x > 0; --x) {
+ if (x == cnt[x]) {
+ return x;
}
}
- return ans;
+ return -1;
}
}
\ No newline at end of file
diff --git a/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.php b/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.php
index 978bf0079a7ce..d75690dce4b15 100644
--- a/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.php
+++ b/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.php
@@ -4,16 +4,15 @@ class Solution {
* @return Integer
*/
function findLucky($arr) {
- $max = -1;
- for ($i = 0; $i < count($arr); $i++) {
- $hashtable[$arr[$i]] += 1;
+ $cnt = array_fill(0, 501, 0);
+ foreach ($arr as $x) {
+ $cnt[$x]++;
}
- $keys = array_keys($hashtable);
- for ($j = 0; $j < count($keys); $j++) {
- if ($hashtable[$keys[$j]] == $keys[$j]) {
- $max = max($max, $keys[$j]);
+ for ($x = 500; $x > 0; $x--) {
+ if ($cnt[$x] === $x) {
+ return $x;
}
}
- return $max;
+ return -1;
}
-}
+}
\ No newline at end of file
diff --git a/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.py b/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.py
index 1c1d2594cc4e6..d374650ec8dab 100644
--- a/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.py
+++ b/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.py
@@ -1,8 +1,4 @@
class Solution:
def findLucky(self, arr: List[int]) -> int:
cnt = Counter(arr)
- ans = -1
- for x, v in cnt.items():
- if x == v and ans < x:
- ans = x
- return ans
+ return max((x for x, v in cnt.items() if x == v), default=-1)
diff --git a/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.rs b/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.rs
new file mode 100644
index 0000000000000..89dbef71a7a4d
--- /dev/null
+++ b/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.rs
@@ -0,0 +1,13 @@
+use std::collections::HashMap;
+
+impl Solution {
+ pub fn find_lucky(arr: Vec) -> i32 {
+ let mut cnt = HashMap::new();
+ arr.iter().for_each(|&x| *cnt.entry(x).or_insert(0) += 1);
+ cnt.iter()
+ .filter(|(&x, &v)| x == v)
+ .map(|(&x, _)| x)
+ .max()
+ .unwrap_or(-1)
+ }
+}
diff --git a/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.ts b/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.ts
index 2effea7d2bc38..719deeeba14a6 100644
--- a/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.ts
+++ b/solution/1300-1399/1394.Find Lucky Integer in an Array/Solution.ts
@@ -1,13 +1,12 @@
function findLucky(arr: number[]): number {
- const cnt = Array(510).fill(0);
+ const cnt: number[] = Array(501).fill(0);
for (const x of arr) {
++cnt[x];
}
- let ans = -1;
- for (let x = 1; x < cnt.length; ++x) {
- if (cnt[x] === x) {
- ans = x;
+ for (let x = cnt.length - 1; x; --x) {
+ if (x === cnt[x]) {
+ return x;
}
}
- return ans;
+ return -1;
}
diff --git a/solution/1400-1499/1412.Find the Quiet Students in All Exams/README_EN.md b/solution/1400-1499/1412.Find the Quiet Students in All Exams/README_EN.md
index a4a1d7cc7a00c..ab9f361afba34 100644
--- a/solution/1400-1499/1412.Find the Quiet Students in All Exams/README_EN.md
+++ b/solution/1400-1499/1412.Find the Quiet Students in All Exams/README_EN.md
@@ -93,7 +93,7 @@ Exam table:
Explanation:
For exam 1: Student 1 and 3 hold the lowest and high scores respectively.
For exam 2: Student 1 hold both highest and lowest score.
-For exam 3 and 4: Studnet 1 and 4 hold the lowest and high scores respectively.
+For exam 3 and 4: Student 1 and 4 hold the lowest and high scores respectively.
Student 2 and 5 have never got the highest or lowest in any of the exams.
Since student 5 is not taking any exam, he is excluded from the result.
So, we only return the information of Student 2.
diff --git a/solution/1400-1499/1418.Display Table of Food Orders in a Restaurant/README_EN.md b/solution/1400-1499/1418.Display Table of Food Orders in a Restaurant/README_EN.md
index 809ec164c6da3..dd6bc86d1a53a 100644
--- a/solution/1400-1499/1418.Display Table of Food Orders in a Restaurant/README_EN.md
+++ b/solution/1400-1499/1418.Display Table of Food Orders in a Restaurant/README_EN.md
@@ -27,48 +27,77 @@ tags:
Return the restaurant's “display table”. The “display table” is a table whose row entries denote how many of each food item each table ordered. The first column is the table number and the remaining columns correspond to each food item in alphabetical order. The first row should be a header whose first column is “Table”, followed by the names of the food items. Note that the customer names are not part of the table. Additionally, the rows should be sorted in numerically increasing order.
+
Example 1:
+
Input: orders = [["David","3","Ceviche"],["Corina","10","Beef Burrito"],["David","3","Fried Chicken"],["Carla","5","Water"],["Carla","5","Ceviche"],["Rous","3","Ceviche"]]
+
Output: [["Table","Beef Burrito","Ceviche","Fried Chicken","Water"],["3","0","2","1","0"],["5","0","1","0","1"],["10","1","0","0","0"]]
+
Explanation:
+
The displaying table looks like:
+
Table,Beef Burrito,Ceviche,Fried Chicken,Water
+
3 ,0 ,2 ,1 ,0
+
5 ,0 ,1 ,0 ,1
+
10 ,1 ,0 ,0 ,0
+
For the table 3: David orders "Ceviche" and "Fried Chicken", and Rous orders "Ceviche".
+
For the table 5: Carla orders "Water" and "Ceviche".
+
For the table 10: Corina orders "Beef Burrito".
+
Example 2:
+
Input: orders = [["James","12","Fried Chicken"],["Ratesh","12","Fried Chicken"],["Amadeus","12","Fried Chicken"],["Adam","1","Canadian Waffles"],["Brianna","1","Canadian Waffles"]]
+
Output: [["Table","Canadian Waffles","Fried Chicken"],["1","2","0"],["12","0","3"]]
+
Explanation:
+
For the table 1: Adam and Brianna order "Canadian Waffles".
+
For the table 12: James, Ratesh and Amadeus order "Fried Chicken".
+
Example 3:
+
Input: orders = [["Laura","2","Bean Burrito"],["Jhon","2","Beef Burrito"],["Melissa","2","Soda"]]
+
Output: [["Table","Bean Burrito","Beef Burrito","Soda"],["2","1","1","1"]]
+
+
Constraints:
- 1 <= orders.length <= 5 * 10^4orders[i].length == 31 <= customerNamei.length, foodItemi.length <= 20customerNamei and foodItemi consist of lowercase and uppercase English letters and the space character.tableNumberi is a valid integer between 1 and 500.1 <= orders.length <= 5 * 10^4orders[i].length == 31 <= customerNamei.length, foodItemi.length <= 20customerNamei and foodItemi consist of lowercase and uppercase English letters and the space character.tableNumberi is a valid integer between 1 and 500.
diff --git a/solution/1400-1499/1432.Max Difference You Can Get From Changing an Integer/README.md b/solution/1400-1499/1432.Max Difference You Can Get From Changing an Integer/README.md
index 2d6da8186663c..d8bc71a7ce113 100644
--- a/solution/1400-1499/1432.Max Difference You Can Get From Changing an Integer/README.md
+++ b/solution/1400-1499/1432.Max Difference You Can Get From Changing an Integer/README.md
@@ -31,7 +31,7 @@ tags:
请你返回 a 和 b 的 最大差值 。
-注意，新的整数（a 或 b）必须不能 含有前导 0，并且 非 0。
+注意，a 和 b 必须不能 含有前导 0，并且 不为 0。
@@ -94,13 +94,13 @@ tags:
要想得到最大差值，那么我们应该拿到最大值与最小值，这样差值最大。
-因此，我们先从高到低枚举 $nums$ 每个位置上的数，如果数字不为 `9`，就将所有该数字替换为 `9`，得到最大整数 $a$。
+因此，我们先从高到低枚举 $\textit{nums}$ 每个位置上的数，如果数字不为 `9`，就将所有该数字替换为 `9`，得到最大整数 $a$。
-接下来，我们再从高到低枚举 `nums` 每个位置上的数，首位不能为 `0`，因此如果首位不为 `1`，我们将其替换为 `1`；如果非首位，且数字不与首位相同，我们将其替换为 `0`，得到最大整数 $b$。
+接下来，我们再从高到低枚举 $\textit{nums}$ 每个位置上的数，首位不能为 `0`，因此如果首位不为 `1`，我们将其替换为 `1`；如果非首位，且数字不与首位相同，我们将其替换为 `0`，得到最大整数 $b$。
答案为差值 $a - b$。
-时间复杂度 $O(\log num)$，空间复杂度 $O(\log num)$。其中 $num$ 为给定整数。
+时间复杂度 $O(\log \textit{num})$，空间复杂度 $O(\log \textit{num})$。其中 $\textit{nums}$ 为给定整数。
@@ -214,6 +214,65 @@ func maxDiff(num int) int {
}
```
+#### TypeScript
+
+```ts
+function maxDiff(num: number): number {
+ let a = num.toString();
+ let b = a;
+ for (let i = 0; i < a.length; ++i) {
+ if (a[i] !== '9') {
+ a = a.split(a[i]).join('9');
+ break;
+ }
+ }
+ if (b[0] !== '1') {
+ b = b.split(b[0]).join('1');
+ } else {
+ for (let i = 1; i < b.length; ++i) {
+ if (b[i] !== '0' && b[i] !== '1') {
+ b = b.split(b[i]).join('0');
+ break;
+ }
+ }
+ }
+ return +a - +b;
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+ pub fn max_diff(num: i32) -> i32 {
+ let a = num.to_string();
+ let mut a = a.clone();
+ let mut b = a.clone();
+
+ for c in a.chars() {
+ if c != '9' {
+ a = a.replace(c, "9");
+ break;
+ }
+ }
+
+ let chars: Vec = b.chars().collect();
+ if chars[0] != '1' {
+ b = b.replace(chars[0], "1");
+ } else {
+ for &c in &chars[1..] {
+ if c != '0' && c != '1' {
+ b = b.replace(c, "0");
+ break;
+ }
+ }
+ }
+
+ a.parse::().unwrap() - b.parse::().unwrap()
+ }
+}
+```
+
diff --git a/solution/1400-1499/1432.Max Difference You Can Get From Changing an Integer/README_EN.md b/solution/1400-1499/1432.Max Difference You Can Get From Changing an Integer/README_EN.md
index d31d01cb1c408..2aad266c5b7ff 100644
--- a/solution/1400-1499/1432.Max Difference You Can Get From Changing an Integer/README_EN.md
+++ b/solution/1400-1499/1432.Max Difference You Can Get From Changing an Integer/README_EN.md
@@ -19,7 +19,7 @@ tags:
-You are given an integer num. You will apply the following steps to nums two times independently:
+You are given an integer num. You will apply the following steps to num two separate times:
- Pick a digit
x (0 <= x <= 9).
@@ -31,7 +31,7 @@ tags:
Return the max difference between a and b.
-Note that the new integer (either a or b) must not have any leading zeros, and it must not be 0.
+Note that neither a nor b may have any leading zeros, and must not be 0.
Example 1:
@@ -67,7 +67,17 @@ We have now a = 9 and b = 1 and max difference = 8
-### Solution 1
+### Solution 1: Greedy
+
+To obtain the maximum difference, we should take the maximum and minimum values, as this yields the largest difference.
+
+Therefore, we first enumerate each digit in $\textit{nums}$ from high to low. If a digit is not `9`, we replace all occurrences of that digit with `9` to obtain the maximum integer $a$.
+
+Next, we enumerate each digit in $\textit{nums}$ from high to low again. The first digit cannot be `0`, so if the first digit is not `1`, we replace it with `1`; for non-leading digits that are different from the first digit, we replace them with `0` to obtain the minimum integer $b$.
+
+The answer is the difference $a - b$.
+
+The time complexity is $O(\log \textit{num})$, and the space complexity is $O(\log \textit{num})$, where $\textit{nums}$ is the given integer.
@@ -181,6 +191,65 @@ func maxDiff(num int) int {
}
```
+#### TypeScript
+
+```ts
+function maxDiff(num: number): number {
+ let a = num.toString();
+ let b = a;
+ for (let i = 0; i < a.length; ++i) {
+ if (a[i] !== '9') {
+ a = a.split(a[i]).join('9');
+ break;
+ }
+ }
+ if (b[0] !== '1') {
+ b = b.split(b[0]).join('1');
+ } else {
+ for (let i = 1; i < b.length; ++i) {
+ if (b[i] !== '0' && b[i] !== '1') {
+ b = b.split(b[i]).join('0');
+ break;
+ }
+ }
+ }
+ return +a - +b;
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+ pub fn max_diff(num: i32) -> i32 {
+ let a = num.to_string();
+ let mut a = a.clone();
+ let mut b = a.clone();
+
+ for c in a.chars() {
+ if c != '9' {
+ a = a.replace(c, "9");
+ break;
+ }
+ }
+
+ let chars: Vec = b.chars().collect();
+ if chars[0] != '1' {
+ b = b.replace(chars[0], "1");
+ } else {
+ for &c in &chars[1..] {
+ if c != '0' && c != '1' {
+ b = b.replace(c, "0");
+ break;
+ }
+ }
+ }
+
+ a.parse::().unwrap() - b.parse::().unwrap()
+ }
+}
+```
+
diff --git a/solution/1400-1499/1432.Max Difference You Can Get From Changing an Integer/Solution.rs b/solution/1400-1499/1432.Max Difference You Can Get From Changing an Integer/Solution.rs
new file mode 100644
index 0000000000000..17cbc4f0dd6bc
--- /dev/null
+++ b/solution/1400-1499/1432.Max Difference You Can Get From Changing an Integer/Solution.rs
@@ -0,0 +1,28 @@
+impl Solution {
+ pub fn max_diff(num: i32) -> i32 {
+ let a = num.to_string();
+ let mut a = a.clone();
+ let mut b = a.clone();
+
+ for c in a.chars() {
+ if c != '9' {
+ a = a.replace(c, "9");
+ break;
+ }
+ }
+
+ let chars: Vec = b.chars().collect();
+ if chars[0] != '1' {
+ b = b.replace(chars[0], "1");
+ } else {
+ for &c in &chars[1..] {
+ if c != '0' && c != '1' {
+ b = b.replace(c, "0");
+ break;
+ }
+ }
+ }
+
+ a.parse::().unwrap() - b.parse::().unwrap()
+ }
+}
diff --git a/solution/1400-1499/1432.Max Difference You Can Get From Changing an Integer/Solution.ts b/solution/1400-1499/1432.Max Difference You Can Get From Changing an Integer/Solution.ts
new file mode 100644
index 0000000000000..b83ebad41364b
--- /dev/null
+++ b/solution/1400-1499/1432.Max Difference You Can Get From Changing an Integer/Solution.ts
@@ -0,0 +1,21 @@
+function maxDiff(num: number): number {
+ let a = num.toString();
+ let b = a;
+ for (let i = 0; i < a.length; ++i) {
+ if (a[i] !== '9') {
+ a = a.split(a[i]).join('9');
+ break;
+ }
+ }
+ if (b[0] !== '1') {
+ b = b.split(b[0]).join('1');
+ } else {
+ for (let i = 1; i < b.length; ++i) {
+ if (b[i] !== '0' && b[i] !== '1') {
+ b = b.split(b[i]).join('0');
+ break;
+ }
+ }
+ }
+ return +a - +b;
+}
diff --git a/solution/1400-1499/1441.Build an Array With Stack Operations/README.md b/solution/1400-1499/1441.Build an Array With Stack Operations/README.md
index 40a72da78f311..e2a66d57660c2 100644
--- a/solution/1400-1499/1441.Build an Array With Stack Operations/README.md
+++ b/solution/1400-1499/1441.Build an Array With Stack Operations/README.md
@@ -20,19 +20,26 @@ tags:
-给你一个数组 target 和一个整数 n。每次迭代，需要从 list = { 1 , 2 , 3 ..., n } 中依次读取一个数字。
+给你一个数组 target 和一个整数 n。
-请使用下述操作来构建目标数组 target ：
+给你一个空栈和两种操作：
- "Push"：从 list 中读取一个新元素， 并将其推入数组中。"Pop"：删除数组中的最后一个元素。- 如果目标数组构建完成，就停止读取更多元素。
+ "Push"：将一个整数加到栈顶。"Pop"：从栈顶删除一个整数。
-题目数据保证目标数组严格递增，并且只包含 1 到 n 之间的数字。
+同时给定一个范围 [1, n] 中的整数流。
-请返回构建目标数组所用的操作序列。如果存在多个可行方案，返回任一即可。
+使用两个栈操作使栈中的数字（从底部到顶部）等于 target。你应该遵循以下规则：
+
+
+ - 如果整数流不为空，从流中选取下一个整数并将其推送到栈顶。
+ - 如果栈不为空，弹出栈顶的整数。
+ - 如果，在任何时刻，栈中的元素（从底部到顶部）等于
target，则不要从流中读取新的整数，也不要对栈进行更多操作。
+
+
+请返回遵循上述规则构建 target 所用的操作序列。如果存在多个合法答案，返回 任一 即可。
@@ -41,10 +48,11 @@ tags:
输入：target = [1,3], n = 3
输出：["Push","Push","Pop","Push"]
-解释：
-读取 1 并自动推入数组 -> [1]
-读取 2 并自动推入数组，然后删除它 -> [1]
-读取 3 并自动推入数组 -> [1,3]
+解释：一开始栈为空。最后一个元素是栈顶。
+从流中读取 1 并推入数组 -> [1]
+从流中读取 2 并推入数组 -> [1,2]
+从栈顶删除整数 -> [1]
+从流中读取 3 并推入数组 -> [1,3]
示例 2：
@@ -52,6 +60,10 @@ tags:
输入：target = [1,2,3], n = 3
输出：["Push","Push","Push"]
+解释：一开始栈为空。最后一个元素是栈顶。
+从流中读取 1 并推入数组 -> [1]
+从流中读取 2 并推入数组 -> [1,2]
+从流中读取 3 并推入数组 -> [1,2,3]
示例 3：
@@ -59,7 +71,11 @@ tags:
输入：target = [1,2], n = 4
输出：["Push","Push"]
-解释：只需要读取前 2 个数字就可以停止。
+解释：一开始栈为空。最后一个元素是栈顶。
+从流中读取 1 并推入数组 -> [1]
+从流中读取 2 并推入数组 -> [1,2]
+由于栈（从底部到顶部）等于 target，我们停止栈操作。
+从流中读取整数 3 的答案不被接受。
diff --git a/solution/1400-1499/1448.Count Good Nodes in Binary Tree/README_EN.md b/solution/1400-1499/1448.Count Good Nodes in Binary Tree/README_EN.md
index 75f9d52c74990..4a07c72b0b946 100644
--- a/solution/1400-1499/1448.Count Good Nodes in Binary Tree/README_EN.md
+++ b/solution/1400-1499/1448.Count Good Nodes in Binary Tree/README_EN.md
@@ -26,17 +26,25 @@ tags:
Return the number of good nodes in the binary tree.
+
Example 1:
+
Input: root = [3,1,4,3,null,1,5]
+
Output: 4
+
Explanation: Nodes in blue are good.
+
Root Node (3) is always a good node.
+
Node 4 -> (3,4) is the maximum value in the path starting from the root.
+
Node 5 -> (3,4,5) is the maximum value in the path
+
Node 3 -> (3,1,3) is the maximum value in the path.
Example 2:
@@ -44,23 +52,33 @@ Node 3 -> (3,1,3) is the maximum value in the path.
+
Input: root = [3,3,null,4,2]
+
Output: 3
+
Explanation: Node 2 -> (3, 3, 2) is not good, because "3" is higher than it.
Example 3:
+
Input: root = [1]
+
Output: 1
+
Explanation: Root is considered as good.
+
Constraints:
- - The number of nodes in the binary tree is in the range
[1, 10^5].
- - Each node's value is between
[-10^4, 10^4].
+
+ - The number of nodes in the binary tree is in the range
[1, 10^5].
+
+ - Each node's value is between
[-10^4, 10^4].
+
diff --git a/solution/1400-1499/1470.Shuffle the Array/README_EN.md b/solution/1400-1499/1470.Shuffle the Array/README_EN.md
index 9246c35a92d80..8a806cd3fd73d 100644
--- a/solution/1400-1499/1470.Shuffle the Array/README_EN.md
+++ b/solution/1400-1499/1470.Shuffle the Array/README_EN.md
@@ -23,35 +23,51 @@ tags:
Return the array in the form [x1,y1,x2,y2,...,xn,yn].
+
Example 1:
+
Input: nums = [2,5,1,3,4,7], n = 3
+
Output: [2,3,5,4,1,7]
+
Explanation: Since x1=2, x2=5, x3=1, y1=3, y2=4, y3=7 then the answer is [2,3,5,4,1,7].
+
Example 2:
+
Input: nums = [1,2,3,4,4,3,2,1], n = 4
+
Output: [1,4,2,3,3,2,4,1]
+
Example 3:
+
Input: nums = [1,1,2,2], n = 2
+
Output: [1,2,1,2]
+
+
Constraints:
- 1 <= n <= 500nums.length == 2n1 <= nums[i] <= 10^31 <= n <= 500nums.length == 2n1 <= nums[i] <= 10^3
diff --git a/solution/1400-1499/1481.Least Number of Unique Integers after K Removals/README_EN.md b/solution/1400-1499/1481.Least Number of Unique Integers after K Removals/README_EN.md
index 00dee15fada33..d367cf0458c18 100644
--- a/solution/1400-1499/1481.Least Number of Unique Integers after K Removals/README_EN.md
+++ b/solution/1400-1499/1481.Least Number of Unique Integers after K Removals/README_EN.md
@@ -25,31 +25,45 @@ tags:
Given an array of integers arr and an integer k. Find the least number of unique integers after removing exactly k elements.
+
+
Example 1:
+
Input: arr = [5,5,4], k = 1
+
Output: 1
+
Explanation: Remove the single 4, only 5 is left.
+
Example 2:
+
Input: arr = [4,3,1,1,3,3,2], k = 3
+
Output: 2
+
Explanation: Remove 4, 2 and either one of the two 1s or three 3s. 1 and 3 will be left.
+
Constraints:
- 1 <= arr.length <= 10^51 <= arr[i] <= 10^90 <= k <= arr.length1 <= arr.length <= 10^51 <= arr[i] <= 10^90 <= k <= arr.length
diff --git a/solution/1400-1499/1498.Number of Subsequences That Satisfy the Given Sum Condition/README.md b/solution/1400-1499/1498.Number of Subsequences That Satisfy the Given Sum Condition/README.md
index e6ace5471b0df..238ee9e8a551f 100644
--- a/solution/1400-1499/1498.Number of Subsequences That Satisfy the Given Sum Condition/README.md
+++ b/solution/1400-1499/1498.Number of Subsequences That Satisfy the Given Sum Condition/README.md
@@ -74,13 +74,13 @@ tags:
-### 方法一：排序 + 枚举贡献 + 二分查找
+### 方法一：排序 + 二分查找
-由于题目中描述的是子序列，并且涉及到最小元素与最大元素的和，因此我们可以先对数组 `nums` 进行排序。
+由于题目中描述的是子序列，并且涉及到最小元素与最大元素的和，因此我们可以先对数组 $\textit{nums}$ 进行排序。
-然后我们枚举最小元素 $nums[i]$，对于每个 $nums[i]$，我们可以在 $nums[i + 1]$ 到 $nums[n - 1]$ 中找到最大元素 $nums[j]$，使得 $nums[i] + nums[j] \leq target$，此时满足条件的子序列数目为 $2^{j - i}$，其中 $2^{j - i}$ 表示从 $nums[i + 1]$ 到 $nums[j]$ 的所有子序列的数目。我们将所有的子序列数目累加即可。
+然后我们枚举最小元素 $\textit{nums}[i]$，对于每个 $\textit{nums}[i]$，我们可以在 $\textit{nums}[i + 1]$ 到 $\textit{nums}[n - 1]$ 中找到最大元素 $\textit{nums}[j]$，使得 $\textit{nums}[i] + \textit{nums}[j] \leq \textit{target}$，此时满足条件的子序列数目为 $2^{j - i}$，其中 $2^{j - i}$ 表示从 $\textit{nums}[i + 1]$ 到 $\textit{nums}[j]$ 的所有子序列的数目。我们将所有的子序列数目累加即可。
-时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 `nums` 的长度。
+时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $\textit{nums}$ 的长度。
@@ -118,10 +118,7 @@ class Solution {
f[i] = (f[i - 1] * 2) % mod;
}
int ans = 0;
- for (int i = 0; i < n; ++i) {
- if (nums[i] * 2L > target) {
- break;
- }
+ for (int i = 0; i < n && nums[i] * 2 <= target; ++i) {
int j = search(nums, target - nums[i], i + 1) - 1;
ans = (ans + f[j - i]) % mod;
}
@@ -158,10 +155,7 @@ public:
f[i] = (f[i - 1] * 2) % mod;
}
int ans = 0;
- for (int i = 0; i < n; ++i) {
- if (nums[i] * 2L > target) {
- break;
- }
+ for (int i = 0; i < n && nums[i] * 2 <= target; ++i) {
int j = upper_bound(nums.begin() + i + 1, nums.end(), target - nums[i]) - nums.begin() - 1;
ans = (ans + f[j - i]) % mod;
}
@@ -193,6 +187,77 @@ func numSubseq(nums []int, target int) (ans int) {
}
```
+#### TypeScript
+
+```ts
+function numSubseq(nums: number[], target: number): number {
+ nums.sort((a, b) => a - b);
+ const mod = 1e9 + 7;
+ const n = nums.length;
+ const f: number[] = Array(n + 1).fill(1);
+ for (let i = 1; i <= n; ++i) {
+ f[i] = (f[i - 1] * 2) % mod;
+ }
+
+ let ans = 0;
+ for (let i = 0; i < n && nums[i] * 2 <= target; ++i) {
+ const j = search(nums, target - nums[i], i + 1) - 1;
+ if (j >= i) {
+ ans = (ans + f[j - i]) % mod;
+ }
+ }
+ return ans;
+}
+
+function search(nums: number[], x: number, left: number): number {
+ let right = nums.length;
+ while (left < right) {
+ const mid = (left + right) >> 1;
+ if (nums[mid] > x) {
+ right = mid;
+ } else {
+ left = mid + 1;
+ }
+ }
+ return left;
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+ pub fn num_subseq(mut nums: Vec, target: i32) -> i32 {
+ nums.sort();
+ const MOD: i32 = 1_000_000_007;
+ let n = nums.len();
+ let mut f = vec![1; n + 1];
+ for i in 1..=n {
+ f[i] = (f[i - 1] * 2) % MOD;
+ }
+ let mut ans = 0;
+ for i in 0..n {
+ if nums[i] * 2 > target {
+ break;
+ }
+ let mut l = i + 1;
+ let mut r = n;
+ while l < r {
+ let m = (l + r) / 2;
+ if nums[m] > target - nums[i] {
+ r = m;
+ } else {
+ l = m + 1;
+ }
+ }
+ let j = l - 1;
+ ans = (ans + f[j - i]) % MOD;
+ }
+ ans
+ }
+}
+```
+
diff --git a/solution/1400-1499/1498.Number of Subsequences That Satisfy the Given Sum Condition/README_EN.md b/solution/1400-1499/1498.Number of Subsequences That Satisfy the Given Sum Condition/README_EN.md
index 82d339744f91b..9e42491529171 100644
--- a/solution/1400-1499/1498.Number of Subsequences That Satisfy the Given Sum Condition/README_EN.md
+++ b/solution/1400-1499/1498.Number of Subsequences That Satisfy the Given Sum Condition/README_EN.md
@@ -71,7 +71,13 @@ Number of valid subsequences (63 - 2 = 61).
-### Solution 1
+### Solution 1: Sorting + Binary Search
+
+Since the problem is about subsequences and involves the sum of the minimum and maximum elements, we can first sort the array $\textit{nums}$.
+
+Then we enumerate the minimum element $\textit{nums}[i]$. For each $\textit{nums}[i]$, we can find the maximum element $\textit{nums}[j]$ in $\textit{nums}[i + 1]$ to $\textit{nums}[n - 1]$ such that $\textit{nums}[i] + \textit{nums}[j] \leq \textit{target}$. The number of valid subsequences in this case is $2^{j - i}$, where $2^{j - i}$ represents all possible subsequences from $\textit{nums}[i + 1]$ to $\textit{nums}[j]$. We sum up the counts of all such subsequences.
+
+The time complexity is $O(n \times \log n)$, and the space complexity is $O(n)$, where $n$ is the length of the array $\textit{nums}$.
@@ -109,10 +115,7 @@ class Solution {
f[i] = (f[i - 1] * 2) % mod;
}
int ans = 0;
- for (int i = 0; i < n; ++i) {
- if (nums[i] * 2L > target) {
- break;
- }
+ for (int i = 0; i < n && nums[i] * 2 <= target; ++i) {
int j = search(nums, target - nums[i], i + 1) - 1;
ans = (ans + f[j - i]) % mod;
}
@@ -149,10 +152,7 @@ public:
f[i] = (f[i - 1] * 2) % mod;
}
int ans = 0;
- for (int i = 0; i < n; ++i) {
- if (nums[i] * 2L > target) {
- break;
- }
+ for (int i = 0; i < n && nums[i] * 2 <= target; ++i) {
int j = upper_bound(nums.begin() + i + 1, nums.end(), target - nums[i]) - nums.begin() - 1;
ans = (ans + f[j - i]) % mod;
}
@@ -184,6 +184,77 @@ func numSubseq(nums []int, target int) (ans int) {
}
```
+#### TypeScript
+
+```ts
+function numSubseq(nums: number[], target: number): number {
+ nums.sort((a, b) => a - b);
+ const mod = 1e9 + 7;
+ const n = nums.length;
+ const f: number[] = Array(n + 1).fill(1);
+ for (let i = 1; i <= n; ++i) {
+ f[i] = (f[i - 1] * 2) % mod;
+ }
+
+ let ans = 0;
+ for (let i = 0; i < n && nums[i] * 2 <= target; ++i) {
+ const j = search(nums, target - nums[i], i + 1) - 1;
+ if (j >= i) {
+ ans = (ans + f[j - i]) % mod;
+ }
+ }
+ return ans;
+}
+
+function search(nums: number[], x: number, left: number): number {
+ let right = nums.length;
+ while (left < right) {
+ const mid = (left + right) >> 1;
+ if (nums[mid] > x) {
+ right = mid;
+ } else {
+ left = mid + 1;
+ }
+ }
+ return left;
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+ pub fn num_subseq(mut nums: Vec, target: i32) -> i32 {
+ nums.sort();
+ const MOD: i32 = 1_000_000_007;
+ let n = nums.len();
+ let mut f = vec![1; n + 1];
+ for i in 1..=n {
+ f[i] = (f[i - 1] * 2) % MOD;
+ }
+ let mut ans = 0;
+ for i in 0..n {
+ if nums[i] * 2 > target {
+ break;
+ }
+ let mut l = i + 1;
+ let mut r = n;
+ while l < r {
+ let m = (l + r) / 2;
+ if nums[m] > target - nums[i] {
+ r = m;
+ } else {
+ l = m + 1;
+ }
+ }
+ let j = l - 1;
+ ans = (ans + f[j - i]) % MOD;
+ }
+ ans
+ }
+}
+```
+
diff --git a/solution/1400-1499/1498.Number of Subsequences That Satisfy the Given Sum Condition/Solution.cpp b/solution/1400-1499/1498.Number of Subsequences That Satisfy the Given Sum Condition/Solution.cpp
index 4c4d4dc630bac..f599d59527261 100644
--- a/solution/1400-1499/1498.Number of Subsequences That Satisfy the Given Sum Condition/Solution.cpp
+++ b/solution/1400-1499/1498.Number of Subsequences That Satisfy the Given Sum Condition/Solution.cpp
@@ -10,10 +10,7 @@ class Solution {
f[i] = (f[i - 1] * 2) % mod;
}
int ans = 0;
- for (int i = 0; i < n; ++i) {
- if (nums[i] * 2L > target) {
- break;
- }
+ for (int i = 0; i < n && nums[i] * 2 <= target; ++i) {
int j = upper_bound(nums.begin() + i + 1, nums.end(), target - nums[i]) - nums.begin() - 1;
ans = (ans + f[j - i]) % mod;
}
diff --git a/solution/1400-1499/1498.Number of Subsequences That Satisfy the Given Sum Condition/Solution.java b/solution/1400-1499/1498.Number of Subsequences That Satisfy the Given Sum Condition/Solution.java
index 73cd951a7968b..d5ceb81f59e9f 100644
--- a/solution/1400-1499/1498.Number of Subsequences That Satisfy the Given Sum Condition/Solution.java
+++ b/solution/1400-1499/1498.Number of Subsequences That Satisfy the Given Sum Condition/Solution.java
@@ -9,10 +9,7 @@ public int numSubseq(int[] nums, int target) {
f[i] = (f[i - 1] * 2) % mod;
}
int ans = 0;
- for (int i = 0; i < n; ++i) {
- if (nums[i] * 2L > target) {
- break;
- }
+ for (int i = 0; i < n && nums[i] * 2 <= target; ++i) {
int j = search(nums, target - nums[i], i + 1) - 1;
ans = (ans + f[j - i]) % mod;
}
diff --git a/solution/1400-1499/1498.Number of Subsequences That Satisfy the Given Sum Condition/Solution.rs b/solution/1400-1499/1498.Number of Subsequences That Satisfy the Given Sum Condition/Solution.rs
new file mode 100644
index 0000000000000..7e07c8502443a
--- /dev/null
+++ b/solution/1400-1499/1498.Number of Subsequences That Satisfy the Given Sum Condition/Solution.rs
@@ -0,0 +1,30 @@
+impl Solution {
+ pub fn num_subseq(mut nums: Vec, target: i32) -> i32 {
+ nums.sort();
+ const MOD: i32 = 1_000_000_007;
+ let n = nums.len();
+ let mut f = vec![1; n + 1];
+ for i in 1..=n {
+ f[i] = (f[i - 1] * 2) % MOD;
+ }
+ let mut ans = 0;
+ for i in 0..n {
+ if nums[i] * 2 > target {
+ break;
+ }
+ let mut l = i + 1;
+ let mut r = n;
+ while l < r {
+ let m = (l + r) / 2;
+ if nums[m] > target - nums[i] {
+ r = m;
+ } else {
+ l = m + 1;
+ }
+ }
+ let j = l - 1;
+ ans = (ans + f[j - i]) % MOD;
+ }
+ ans
+ }
+}
diff --git a/solution/1400-1499/1498.Number of Subsequences That Satisfy the Given Sum Condition/Solution.ts b/solution/1400-1499/1498.Number of Subsequences That Satisfy the Given Sum Condition/Solution.ts
new file mode 100644
index 0000000000000..e05c6d19d421c
--- /dev/null
+++ b/solution/1400-1499/1498.Number of Subsequences That Satisfy the Given Sum Condition/Solution.ts
@@ -0,0 +1,31 @@
+function numSubseq(nums: number[], target: number): number {
+ nums.sort((a, b) => a - b);
+ const mod = 1e9 + 7;
+ const n = nums.length;
+ const f: number[] = Array(n + 1).fill(1);
+ for (let i = 1; i <= n; ++i) {
+ f[i] = (f[i - 1] * 2) % mod;
+ }
+
+ let ans = 0;
+ for (let i = 0; i < n && nums[i] * 2 <= target; ++i) {
+ const j = search(nums, target - nums[i], i + 1) - 1;
+ if (j >= i) {
+ ans = (ans + f[j - i]) % mod;
+ }
+ }
+ return ans;
+}
+
+function search(nums: number[], x: number, left: number): number {
+ let right = nums.length;
+ while (left < right) {
+ const mid = (left + right) >> 1;
+ if (nums[mid] > x) {
+ right = mid;
+ } else {
+ left = mid + 1;
+ }
+ }
+ return left;
+}
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 ddda78859db1a..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' 。
@@ -86,6 +86,8 @@ Users 表:
### 方法一：REGEXP 正则匹配
+我们可以使用正则表达式来匹配有效的电子邮件格式。正则表达式可以确保前缀名称符合要求，并且域名是固定的 `@leetcode.com`。
+
#### MySQL
@@ -94,7 +96,19 @@ Users 表:
# Write your MySQL query statement below
SELECT *
FROM Users
-WHERE mail REGEXP '^[a-zA-Z][a-zA-Z0-9_.-]*@leetcode[.]com$';
+WHERE mail REGEXP '^[a-zA-Z][a-zA-Z0-9_.-]*@leetcode\\.com$' AND BINARY mail LIKE '%@leetcode.com';
+```
+
+#### Pandas
+
+```python
+import pandas as pd
+
+
+def valid_emails(users: pd.DataFrame) -> pd.DataFrame:
+ pattern = r"^[A-Za-z][A-Za-z0-9_.-]*@leetcode\.com$"
+ mask = users["mail"].str.match(pattern, flags=0, na=False)
+ return users.loc[mask, ["user_id", "name", "mail"]]
```
diff --git a/solution/1500-1599/1517.Find Users With Valid E-Mails/README_EN.md b/solution/1500-1599/1517.Find Users With Valid E-Mails/README_EN.md
index 8bf7f75cf573a..a4b7d76d920b6 100644
--- a/solution/1500-1599/1517.Find Users With Valid E-Mails/README_EN.md
+++ b/solution/1500-1599/1517.Find Users With Valid E-Mails/README_EN.md
@@ -83,7 +83,9 @@ The mail of user 7 starts with a period.
-### Solution 1
+### Solution 1: REGEXP Pattern Matching
+
+We can use a regular expression to match valid email formats. The expression ensures that the username part meets the required rules and that the domain is fixed as `@leetcode.com`.
@@ -93,7 +95,19 @@ The mail of user 7 starts with a period.
# Write your MySQL query statement below
SELECT *
FROM Users
-WHERE mail REGEXP '^[a-zA-Z][a-zA-Z0-9_.-]*@leetcode[.]com$';
+WHERE mail REGEXP '^[a-zA-Z][a-zA-Z0-9_.-]*@leetcode\\.com$' AND BINARY mail LIKE '%@leetcode.com';
+```
+
+#### Pandas
+
+```python
+import pandas as pd
+
+
+def valid_emails(users: pd.DataFrame) -> pd.DataFrame:
+ pattern = r"^[A-Za-z][A-Za-z0-9_.-]*@leetcode\.com$"
+ mask = users["mail"].str.match(pattern, flags=0, na=False)
+ return users.loc[mask, ["user_id", "name", "mail"]]
```
diff --git a/solution/1500-1599/1517.Find Users With Valid E-Mails/Solution.py b/solution/1500-1599/1517.Find Users With Valid E-Mails/Solution.py
new file mode 100644
index 0000000000000..ef6a579e6fc9b
--- /dev/null
+++ b/solution/1500-1599/1517.Find Users With Valid E-Mails/Solution.py
@@ -0,0 +1,7 @@
+import pandas as pd
+
+
+def valid_emails(users: pd.DataFrame) -> pd.DataFrame:
+ pattern = r"^[A-Za-z][A-Za-z0-9_.-]*@leetcode\.com$"
+ mask = users["mail"].str.match(pattern, flags=0, na=False)
+ return users.loc[mask, ["user_id", "name", "mail"]]
diff --git a/solution/1500-1599/1517.Find Users With Valid E-Mails/Solution.sql b/solution/1500-1599/1517.Find Users With Valid E-Mails/Solution.sql
index a9ac512c1444e..b76bec68f8fbe 100644
--- a/solution/1500-1599/1517.Find Users With Valid E-Mails/Solution.sql
+++ b/solution/1500-1599/1517.Find Users With Valid E-Mails/Solution.sql
@@ -1,4 +1,4 @@
# Write your MySQL query statement below
SELECT *
FROM Users
-WHERE mail REGEXP '^[a-zA-Z][a-zA-Z0-9_.-]*@leetcode[.]com$';
+WHERE mail REGEXP '^[a-zA-Z][a-zA-Z0-9_.-]*@leetcode\\.com$' AND BINARY mail LIKE '%@leetcode.com';
diff --git a/solution/1500-1599/1523.Count Odd Numbers in an Interval Range/README_EN.md b/solution/1500-1599/1523.Count Odd Numbers in an Interval Range/README_EN.md
index d1eea923bf055..03cb439cf8dbc 100644
--- a/solution/1500-1599/1523.Count Odd Numbers in an Interval Range/README_EN.md
+++ b/solution/1500-1599/1523.Count Odd Numbers in an Interval Range/README_EN.md
@@ -21,25 +21,35 @@ tags:
Given two non-negative integers low and high. Return the count of odd numbers between low and high (inclusive).
+
Example 1:
+
Input: low = 3, high = 7
+
Output: 3
+
Explanation: The odd numbers between 3 and 7 are [3,5,7].
Example 2:
+
Input: low = 8, high = 10
+
Output: 1
+
Explanation: The odd numbers between 8 and 10 are [9].
+
Constraints:
- 0 <= low <= high <= 10^90 <= low <= high <= 10^9
diff --git a/solution/1500-1599/1534.Count Good Triplets/README_EN.md b/solution/1500-1599/1534.Count Good Triplets/README_EN.md
index e1d64f2f7cc9b..5e8224082f55c 100644
--- a/solution/1500-1599/1534.Count Good Triplets/README_EN.md
+++ b/solution/1500-1599/1534.Count Good Triplets/README_EN.md
@@ -24,10 +24,15 @@ tags:
A triplet (arr[i], arr[j], arr[k]) is good if the following conditions are true:
- 0 <= i < j < k < arr.length|arr[i] - arr[j]| <= a|arr[j] - arr[k]| <= b|arr[i] - arr[k]| <= c0 <= i < j < k < arr.length|arr[i] - arr[j]| <= a|arr[j] - arr[k]| <= b|arr[i] - arr[k]| <= c
Where |x| denotes the absolute value of x.
@@ -35,29 +40,43 @@ tags:
Return the number of good triplets.
+
Example 1:
+
Input: arr = [3,0,1,1,9,7], a = 7, b = 2, c = 3
+
Output: 4
+
Explanation: There are 4 good triplets: [(3,0,1), (3,0,1), (3,1,1), (0,1,1)].
+
Example 2:
+
Input: arr = [1,1,2,2,3], a = 0, b = 0, c = 1
+
Output: 0
+
Explanation: No triplet satisfies all conditions.
+
+
Constraints:
- 3 <= arr.length <= 1000 <= arr[i] <= 10000 <= a, b, c <= 10003 <= arr.length <= 1000 <= arr[i] <= 10000 <= a, b, c <= 1000
diff --git a/solution/1500-1599/1563.Stone Game V/README.md b/solution/1500-1599/1563.Stone Game V/README.md
index 7f64cdd5f56c9..097ba6421ccd9 100644
--- a/solution/1500-1599/1563.Stone Game V/README.md
+++ b/solution/1500-1599/1563.Stone Game V/README.md
@@ -33,7 +33,8 @@ tags:
示例 1：
-输入：stoneValue = [6,2,3,4,5,5]
+
+输入：stoneValue = [6,2,3,4,5,5]
输出：18
解释：在第一轮中，Alice 将行划分为 [6，2，3]，[4，5，5] 。左行的值是 11 ，右行的值是 14 。Bob 丢弃了右行，Alice 的分数现在是 11 。
在第二轮中，Alice 将行分成 [6]，[2，3] 。这一次 Bob 扔掉了左行，Alice 的分数变成了 16（11 + 5）。
@@ -42,13 +43,15 @@ tags:
示例 2：
-输入：stoneValue = [7,7,7,7,7,7,7]
+
+输入：stoneValue = [7,7,7,7,7,7,7]
输出：28
示例 3：
-输入：stoneValue = [4]
+
+输入：stoneValue = [4]
输出：0
@@ -58,7 +61,7 @@ tags:
1 <= stoneValue.length <= 5001 <= stoneValue[i] <= 10^61 <= stoneValue[i] <= 106
diff --git a/solution/1500-1599/1563.Stone Game V/README_EN.md b/solution/1500-1599/1563.Stone Game V/README_EN.md
index c5255f765cc1a..2968c599999aa 100644
--- a/solution/1500-1599/1563.Stone Game V/README_EN.md
+++ b/solution/1500-1599/1563.Stone Game V/README_EN.md
@@ -25,7 +25,7 @@ tags:
In each round of the game, Alice divides the row into two non-empty rows (i.e. left row and right row), then Bob calculates the value of each row which is the sum of the values of all the stones in this row. Bob throws away the row which has the maximum value, and Alice's score increases by the value of the remaining row. If the value of the two rows are equal, Bob lets Alice decide which row will be thrown away. The next round starts with the remaining row.
-The game ends when there is only one stone remaining. Alice's is initially zero.
+The game ends when there is only one stone remaining. Alice's score is initially zero.
Return the maximum score that Alice can obtain.
diff --git a/solution/1600-1699/1617.Count Subtrees With Max Distance Between Cities/README_EN.md b/solution/1600-1699/1617.Count Subtrees With Max Distance Between Cities/README_EN.md
index 58a5aa233655e..a39d7dd0a4861 100644
--- a/solution/1600-1699/1617.Count Subtrees With Max Distance Between Cities/README_EN.md
+++ b/solution/1600-1699/1617.Count Subtrees With Max Distance Between Cities/README_EN.md
@@ -33,42 +33,63 @@ tags:
Notice that the distance between the two cities is the number of edges in the path between them.
+
Example 1:
+
Input: n = 4, edges = [[1,2],[2,3],[2,4]]
+
Output: [3,4,0]
+
Explanation:
+
The subtrees with subsets {1,2}, {2,3} and {2,4} have a max distance of 1.
+
The subtrees with subsets {1,2,3}, {1,2,4}, {2,3,4} and {1,2,3,4} have a max distance of 2.
+
No subtree has two nodes where the max distance between them is 3.
+
Example 2:
+
Input: n = 2, edges = [[1,2]]
+
Output: [1]
+
Example 3:
+
Input: n = 3, edges = [[1,2],[2,3]]
+
Output: [2,1]
+
+
Constraints:
- 2 <= n <= 15edges.length == n-1edges[i].length == 21 <= ui, vi <= n- All pairs
(ui, vi) are distinct.
+
+ 2 <= n <= 15edges.length == n-1edges[i].length == 21 <= ui, vi <= n- All pairs
(ui, vi) are distinct.
+
diff --git a/solution/1600-1699/1618.Maximum Font to Fit a Sentence in a Screen/README_EN.md b/solution/1600-1699/1618.Maximum Font to Fit a Sentence in a Screen/README_EN.md
index 637b3531cdded..86b831b8cd79f 100644
--- a/solution/1600-1699/1618.Maximum Font to Fit a Sentence in a Screen/README_EN.md
+++ b/solution/1600-1699/1618.Maximum Font to Fit a Sentence in a Screen/README_EN.md
@@ -26,14 +26,23 @@ tags:
The FontInfo interface is defined as such:
+
interface FontInfo {
+
// Returns the width of character ch on the screen using font size fontSize.
+
// O(1) per call
+
public int getWidth(int fontSize, char ch);
+
+
// Returns the height of any character on the screen using font size fontSize.
+
// O(1) per call
+
public int getHeight(int fontSize);
+
}
The calculated width of text for some fontSize is the sum of every getWidth(fontSize, text[i]) call for each 0 <= i < text.length (0-indexed). The calculated height of text for some fontSize is getHeight(fontSize). Note that text is displayed on a single line.
@@ -43,45 +52,67 @@ interface FontInfo {
It is also guaranteed that for any font size fontSize and any character ch:
- getHeight(fontSize) <= getHeight(fontSize+1)getWidth(fontSize, ch) <= getWidth(fontSize+1, ch)getHeight(fontSize) <= getHeight(fontSize+1)getWidth(fontSize, ch) <= getWidth(fontSize+1, ch)
Return the maximum font size you can use to display text on the screen. If text cannot fit on the display with any font size, return -1.
+
Example 1:
+
Input: text = "helloworld", w = 80, h = 20, fonts = [6,8,10,12,14,16,18,24,36]
+
Output: 6
+
Example 2:
+
Input: text = "leetcode", w = 1000, h = 50, fonts = [1,2,4]
+
Output: 4
+
Example 3:
+
Input: text = "easyquestion", w = 100, h = 100, fonts = [10,15,20,25]
+
Output: -1
+
+
Constraints:
- 1 <= text.length <= 50000text contains only lowercase English letters.1 <= w <= 1071 <= h <= 1041 <= fonts.length <= 1051 <= fonts[i] <= 105fonts is sorted in ascending order and does not contain duplicates.1 <= text.length <= 50000text contains only lowercase English letters.1 <= w <= 1071 <= h <= 1041 <= fonts.length <= 1051 <= fonts[i] <= 105fonts is sorted in ascending order and does not contain duplicates.
diff --git a/solution/1600-1699/1634.Add Two Polynomials Represented as Linked Lists/README_EN.md b/solution/1600-1699/1634.Add Two Polynomials Represented as Linked Lists/README_EN.md
index b5a4c41d13436..107929af544fa 100644
--- a/solution/1600-1699/1634.Add Two Polynomials Represented as Linked Lists/README_EN.md
+++ b/solution/1600-1699/1634.Add Two Polynomials Represented as Linked Lists/README_EN.md
@@ -23,9 +23,13 @@ tags:
Each node has three attributes:
- coefficient: an integer representing the number multiplier of the term. The coefficient of the term 9x4 is 9.power: an integer representing the exponent. The power of the term 9x4 is 4.next: a pointer to the next node in the list, or null if it is the last node of the list.coefficient: an integer representing the number multiplier of the term. The coefficient of the term 9x4 is 9.power: an integer representing the exponent. The power of the term 9x4 is 4.next: a pointer to the next node in the list, or null if it is the last node of the list.
For example, the polynomial 5x3 + 4x - 7 is represented by the polynomial linked list illustrated below:
@@ -41,41 +45,61 @@ tags:
The input/output format is as a list of n nodes, where each node is represented as its [coefficient, power]. For example, the polynomial 5x3 + 4x - 7 would be represented as: [[5,3],[4,1],[-7,0]].
+
Example 1:
+
Input: poly1 = [[1,1]], poly2 = [[1,0]]
+
Output: [[1,1],[1,0]]
+
Explanation: poly1 = x. poly2 = 1. The sum is x + 1.
+
Example 2:
+
Input: poly1 = [[2,2],[4,1],[3,0]], poly2 = [[3,2],[-4,1],[-1,0]]
+
Output: [[5,2],[2,0]]
+
Explanation: poly1 = 2x2 + 4x + 3. poly2 = 3x2 - 4x - 1. The sum is 5x2 + 2. Notice that we omit the "0x" term.
+
Example 3:
+
Input: poly1 = [[1,2]], poly2 = [[-1,2]]
+
Output: []
+
Explanation: The sum is 0. We return an empty list.
+
+
Constraints:
- 0 <= n <= 104-109 <= PolyNode.coefficient <= 109PolyNode.coefficient != 00 <= PolyNode.power <= 109PolyNode.power > PolyNode.next.power0 <= n <= 104-109 <= PolyNode.coefficient <= 109PolyNode.coefficient != 00 <= PolyNode.power <= 109PolyNode.power > PolyNode.next.power
diff --git a/solution/1600-1699/1645.Hopper Company Queries II/README.md b/solution/1600-1699/1645.Hopper Company Queries II/README.md
index 6c8f6c4717934..7d6973ef7fbae 100644
--- a/solution/1600-1699/1645.Hopper Company Queries II/README.md
+++ b/solution/1600-1699/1645.Hopper Company Queries II/README.md
@@ -151,16 +151,16 @@ ride_id 是该表具有唯一值的列。
解释：
截至 1 月底 --> 2 个活跃的驾驶员 (10, 8)，无被接受的行程。百分比是0%。
截至 2 月底 --> 3 个活跃的驾驶员 (10, 8, 5)，无被接受的行程。百分比是0%。
-截至 3 月底 --> 4 个活跃的驾驶员 (10, 8, 5, 7)，1 个被接受的行程 (10)。百分比是 (1 / 4) * 100 = 25%。
+截至 3 月底 --> 4 个活跃的驾驶员 (10, 8, 5, 7)，1 个被驾驶员 (10) 接受的行程。百分比是 (1 / 4) * 100 = 25%。
截至 4 月底 --> 4 个活跃的驾驶员 (10, 8, 5, 7)，无被接受的行程。百分比是 0%。
截至 5 月底 --> 5 个活跃的驾驶员 (10, 8, 5, 7, 4)，无被接受的行程。百分比是 0%。
-截至 6 月底 --> 5 个活跃的驾驶员 (10, 8, 5, 7, 4)，1 个被接受的行程 (10)。 百分比是 (1 / 5) * 100 = 20%。
-截至 7 月底 --> 5 个活跃的驾驶员 (10, 8, 5, 7, 4)，1 个被接受的行程 (8)。百分比是 (1 / 5) * 100 = 20%。
-截至 8 月底 --> 5 个活跃的驾驶员 (10, 8, 5, 7, 4)，1 个被接受的行程 (7)。百分比是 (1 / 5) * 100 = 20%。
+截至 6 月底 --> 5 个活跃的驾驶员 (10, 8, 5, 7, 4)，1 个被驾驶员 (10) 接受的行程。 百分比是 (1 / 5) * 100 = 20%。
+截至 7 月底 --> 5 个活跃的驾驶员 (10, 8, 5, 7, 4)，1 个被驾驶员 (8) 接受的行程。百分比是 (1 / 5) * 100 = 20%。
+截至 8 月底 --> 5 个活跃的驾驶员 (10, 8, 5, 7, 4)，1 个被驾驶员 (7) 接受的行程。百分比是 (1 / 5) * 100 = 20%。
截至 9 月底 --> 5 个活跃的驾驶员 (10, 8, 5, 7, 4)，无被接受的行程。百分比是 0%。
截至 10 月底 --> 6 个活跃的驾驶员 (10, 8, 5, 7, 4, 1) 无被接受的行程。百分比是 0%。
-截至 11 月底 --> 6 个活跃的驾驶员 (10, 8, 5, 7, 4, 1)，2 个被接受的行程 (1, 7)。百分比是 (2 / 6) * 100 = 33.33%。
-截至 12 月底 --> 6 个活跃的驾驶员 (10, 8, 5, 7, 4, 1)，1 个被接受的行程 (4)。百分比是 (1 / 6) * 100 = 16.67%。
+截至 11 月底 --> 6 个活跃的驾驶员 (10, 8, 5, 7, 4, 1)，2 个被不同驾驶员 (1, 7) 接受的行程。百分比是 (2 / 6) * 100 = 33.33%。
+截至 12 月底 --> 6 个活跃的驾驶员 (10, 8, 5, 7, 4, 1)，1 个被驾驶员 (4) 接受的行程。百分比是 (1 / 6) * 100 = 16.67%。
diff --git a/solution/1600-1699/1649.Create Sorted Array through Instructions/README_EN.md b/solution/1600-1699/1649.Create Sorted Array through Instructions/README_EN.md
index 429cfe2142d4e..d7708d65d82ee 100644
--- a/solution/1600-1699/1649.Create Sorted Array through Instructions/README_EN.md
+++ b/solution/1600-1699/1649.Create Sorted Array through Instructions/README_EN.md
@@ -27,8 +27,11 @@ tags:
Given an integer array instructions, you are asked to create a sorted array from the elements in instructions. You start with an empty container nums. For each element from left to right in instructions, insert it into nums. The cost of each insertion is the minimum of the following:
- - The number of elements currently in
nums that are strictly less than instructions[i].
- - The number of elements currently in
nums that are strictly greater than instructions[i].
+
+ - The number of elements currently in
nums that are strictly less than instructions[i].
+
+ - The number of elements currently in
nums that are strictly greater than instructions[i].
+
For example, if inserting element 3 into nums = [1,2,3,5], the cost of insertion is min(2, 1) (elements 1 and 2 are less than 3, element 5 is greater than 3) and nums will become [1,2,3,3,5].
@@ -36,57 +39,95 @@ tags:
Return the total cost to insert all elements from instructions into nums. Since the answer may be large, return it modulo 109 + 7
+
Example 1:
+
Input: instructions = [1,5,6,2]
+
Output: 1
+
Explanation: Begin with nums = [].
+
Insert 1 with cost min(0, 0) = 0, now nums = [1].
+
Insert 5 with cost min(1, 0) = 0, now nums = [1,5].
+
Insert 6 with cost min(2, 0) = 0, now nums = [1,5,6].
+
Insert 2 with cost min(1, 2) = 1, now nums = [1,2,5,6].
+
The total cost is 0 + 0 + 0 + 1 = 1.
Example 2:
+
Input: instructions = [1,2,3,6,5,4]
+
Output: 3
+
Explanation: Begin with nums = [].
+
Insert 1 with cost min(0, 0) = 0, now nums = [1].
+
Insert 2 with cost min(1, 0) = 0, now nums = [1,2].
+
Insert 3 with cost min(2, 0) = 0, now nums = [1,2,3].
+
Insert 6 with cost min(3, 0) = 0, now nums = [1,2,3,6].
+
Insert 5 with cost min(3, 1) = 1, now nums = [1,2,3,5,6].
+
Insert 4 with cost min(3, 2) = 2, now nums = [1,2,3,4,5,6].
+
The total cost is 0 + 0 + 0 + 0 + 1 + 2 = 3.
+
Example 3:
+
Input: instructions = [1,3,3,3,2,4,2,1,2]
+
Output: 4
+
Explanation: Begin with nums = [].
+
Insert 1 with cost min(0, 0) = 0, now nums = [1].
+
Insert 3 with cost min(1, 0) = 0, now nums = [1,3].
+
Insert 3 with cost min(1, 0) = 0, now nums = [1,3,3].
+
Insert 3 with cost min(1, 0) = 0, now nums = [1,3,3,3].
+
Insert 2 with cost min(1, 3) = 1, now nums = [1,2,3,3,3].
+
Insert 4 with cost min(5, 0) = 0, now nums = [1,2,3,3,3,4].
+
Insert 2 with cost min(1, 4) = 1, now nums = [1,2,2,3,3,3,4].
+
Insert 1 with cost min(0, 6) = 0, now nums = [1,1,2,2,3,3,3,4].
+
Insert 2 with cost min(2, 4) = 2, now nums = [1,1,2,2,2,3,3,3,4].
+
The total cost is 0 + 0 + 0 + 0 + 1 + 0 + 1 + 0 + 2 = 4.
+
+
Constraints:
- 1 <= instructions.length <= 1051 <= instructions[i] <= 1051 <= instructions.length <= 1051 <= instructions[i] <= 105
diff --git a/solution/1600-1699/1660.Correct a Binary Tree/README_EN.md b/solution/1600-1699/1660.Correct a Binary Tree/README_EN.md
index 4a5e058ed554d..4c4926392dd0d 100644
--- a/solution/1600-1699/1660.Correct a Binary Tree/README_EN.md
+++ b/solution/1600-1699/1660.Correct a Binary Tree/README_EN.md
@@ -29,22 +29,31 @@ tags:
The test input is read as 3 lines:
- TreeNode rootint fromNode (not available to correctBinaryTree)int toNode (not available to correctBinaryTree)TreeNode rootint fromNode (not available to correctBinaryTree)int toNode (not available to correctBinaryTree)
After the binary tree rooted at root is parsed, the TreeNode with value of fromNode will have its right child pointer pointing to the TreeNode with a value of toNode. Then, root is passed to correctBinaryTree.
+
Example 1:
+
Input: root = [1,2,3], fromNode = 2, toNode = 3
+
Output: [1,null,3]
+
Explanation: The node with value 2 is invalid, so remove it.
+
Example 2:
@@ -52,22 +61,35 @@ tags:
+
Input: root = [8,3,1,7,null,9,4,2,null,null,null,5,6], fromNode = 7, toNode = 4
+
Output: [8,3,1,null,null,9,4,null,null,5,6]
+
Explanation: The node with value 7 is invalid, so remove it and the node underneath it, node 2.
+
+
Constraints:
- - The number of nodes in the tree is in the range
[3, 104].
- -109 <= Node.val <= 109- All
Node.val are unique.
- fromNode != toNodefromNode and toNode will exist in the tree and will be on the same depth.toNode is to the right of fromNode.fromNode.right is null in the initial tree from the test data.- The number of nodes in the tree is in the range
[3, 104].
+
+ -109 <= Node.val <= 109- All
Node.val are unique.
+
+ fromNode != toNodefromNode and toNode will exist in the tree and will be on the same depth.toNode is to the right of fromNode.fromNode.right is null in the initial tree from the test data.
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/1707.Maximum XOR With an Element From Array/README.md b/solution/1700-1799/1707.Maximum XOR With an Element From Array/README.md
index 26dcf2fea57a6..7d844099664f8 100644
--- a/solution/1700-1799/1707.Maximum XOR With an Element From Array/README.md
+++ b/solution/1700-1799/1707.Maximum XOR With an Element From Array/README.md
@@ -156,9 +156,7 @@ class Solution {
Arrays.sort(nums);
int n = queries.length;
Integer[] idx = new Integer[n];
- for (int i = 0; i < n; ++i) {
- idx[i] = i;
- }
+ Arrays.setAll(idx, i -> i);
Arrays.sort(idx, (i, j) -> queries[i][1] - queries[j][1]);
int[] ans = new int[n];
Trie trie = new Trie();
diff --git a/solution/1700-1799/1707.Maximum XOR With an Element From Array/README_EN.md b/solution/1700-1799/1707.Maximum XOR With an Element From Array/README_EN.md
index 48b6e43efcc4e..5bfcb9d83a61c 100644
--- a/solution/1700-1799/1707.Maximum XOR With an Element From Array/README_EN.md
+++ b/solution/1700-1799/1707.Maximum XOR With an Element From Array/README_EN.md
@@ -156,9 +156,7 @@ class Solution {
Arrays.sort(nums);
int n = queries.length;
Integer[] idx = new Integer[n];
- for (int i = 0; i < n; ++i) {
- idx[i] = i;
- }
+ Arrays.setAll(idx, i -> i);
Arrays.sort(idx, (i, j) -> queries[i][1] - queries[j][1]);
int[] ans = new int[n];
Trie trie = new Trie();
diff --git a/solution/1700-1799/1707.Maximum XOR With an Element From Array/Solution.java b/solution/1700-1799/1707.Maximum XOR With an Element From Array/Solution.java
index ddaca27459a9d..7eff272997151 100644
--- a/solution/1700-1799/1707.Maximum XOR With an Element From Array/Solution.java
+++ b/solution/1700-1799/1707.Maximum XOR With an Element From Array/Solution.java
@@ -35,9 +35,7 @@ public int[] maximizeXor(int[] nums, int[][] queries) {
Arrays.sort(nums);
int n = queries.length;
Integer[] idx = new Integer[n];
- for (int i = 0; i < n; ++i) {
- idx[i] = i;
- }
+ Arrays.setAll(idx, i -> i);
Arrays.sort(idx, (i, j) -> queries[i][1] - queries[j][1]);
int[] ans = new int[n];
Trie trie = new Trie();
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/1725.Number Of Rectangles That Can Form The Largest Square/README_EN.md b/solution/1700-1799/1725.Number Of Rectangles That Can Form The Largest Square/README_EN.md
index cbb623295007f..34f00129f2a96 100644
--- a/solution/1700-1799/1725.Number Of Rectangles That Can Form The Largest Square/README_EN.md
+++ b/solution/1700-1799/1725.Number Of Rectangles That Can Form The Largest Square/README_EN.md
@@ -27,30 +27,45 @@ tags:
Return the number of rectangles that can make a square with a side length of maxLen.
+
Example 1:
+
Input: rectangles = [[5,8],[3,9],[5,12],[16,5]]
+
Output: 3
+
Explanation: The largest squares you can get from each rectangle are of lengths [5,3,5,5].
+
The largest possible square is of length 5, and you can get it out of 3 rectangles.
+
Example 2:
+
Input: rectangles = [[2,3],[3,7],[4,3],[3,7]]
+
Output: 3
+
+
Constraints:
- 1 <= rectangles.length <= 1000rectangles[i].length == 21 <= li, wi <= 109li != wi1 <= rectangles.length <= 1000rectangles[i].length == 21 <= li, wi <= 109li != wi
diff --git a/solution/1700-1799/1746.Maximum Subarray Sum After One Operation/README_EN.md b/solution/1700-1799/1746.Maximum Subarray Sum After One Operation/README_EN.md
index a96cde7d700f3..2ae33ffa3a49c 100644
--- a/solution/1700-1799/1746.Maximum Subarray Sum After One Operation/README_EN.md
+++ b/solution/1700-1799/1746.Maximum Subarray Sum After One Operation/README_EN.md
@@ -22,26 +22,37 @@ tags:
Return the maximum possible subarray sum after exactly one operation. The subarray must be non-empty.
+
Example 1:
+
Input: nums = [2,-1,-4,-3]
+
Output: 17
+
Explanation: You can perform the operation on index 2 (0-indexed) to make nums = [2,-1,16,-3]. Now, the maximum subarray sum is 2 + -1 + 16 = 17.
Example 2:
+
Input: nums = [1,-1,1,1,-1,-1,1]
+
Output: 4
+
Explanation: You can perform the operation on index 1 (0-indexed) to make nums = [1,1,1,1,-1,-1,1]. Now, the maximum subarray sum is 1 + 1 + 1 + 1 = 4.
+
Constraints:
- 1 <= nums.length <= 105-104 <= nums[i] <= 1041 <= nums.length <= 105-104 <= nums[i] <= 104
diff --git a/solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/README.md b/solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/README.md
index 97bd26ee00b3a..6b6997b781b93 100644
--- a/solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/README.md
+++ b/solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/README.md
@@ -76,21 +76,21 @@ tags:
### 方法一：记忆化搜索 + 二分查找
-我们先将会议按照开始时间从小到大排序，然后设计一个函数 $dfs(i, k)$ 表示从第 $i$ 个会议开始，最多参加 $k$ 个会议的最大价值和。答案即为 $dfs(0, k)$。
+我们先将会议按照开始时间从小到大排序，然后设计一个函数 $\text{dfs}(i, k)$ 表示从第 $i$ 个会议开始，最多参加 $k$ 个会议的最大价值和。答案即为 $\text{dfs}(0, k)$。
-函数 $dfs(i, k)$ 的计算过程如下：
+函数 $\text{dfs}(i, k)$ 的计算过程如下：
-对于第 $i$ 个会议，我们可以选择参加或者不参加。如果不参加，那么最大价值和就是 $dfs(i + 1, k)$，如果参加，我们可以通过二分查找，找到第一个开始时间大于第 $i$ 个会议结束时间的会议，记为 $j$，那么最大价值和就是 $dfs(j, k - 1) + value[i]$。取二者的较大值即可。即：
+如果不参加第 $i$ 个会议，那么最大价值和就是 $\text{dfs}(i + 1, k)$；如果参加第 $i$ 个会议，我们可以通过二分查找，找到第一个开始时间大于第 $i$ 个会议结束时间的会议，记为 $j$，那么最大价值和就是 $\text{dfs}(j, k - 1) + \text{value}[i]$。取二者的较大值即可。即：
$$
-dfs(i, k) = \max(dfs(i + 1, k), dfs(j, k - 1) + value[i])
+\text{dfs}(i, k) = \max(\text{dfs}(i + 1, k), \text{dfs}(j, k - 1) + \text{value}[i])
$$
其中 $j$ 为第一个开始时间大于第 $i$ 个会议结束时间的会议，可以通过二分查找得到。
-由于函数 $dfs(i, k)$ 的计算过程中，会调用 $dfs(i + 1, k)$ 和 $dfs(j, k - 1)$，因此我们可以使用记忆化搜索，将计算过的值保存下来，避免重复计算。
+由于函数 $\text{dfs}(i, k)$ 的计算过程中，会调用 $\text{dfs}(i + 1, k)$ 和 $\text{dfs}(j, k - 1)$，因此我们可以使用记忆化搜索，将计算过的值保存下来，避免重复计算。
-时间复杂度 $O(n\times \log n + n\times k)$，其中 $n$ 为会议数量。
+时间复杂度 $O(n \times \log n + n \times k)$，空间复杂度 $O(n \times k)$，其中 $n$ 为会议数量。
@@ -163,23 +163,29 @@ class Solution {
class Solution {
public:
int maxValue(vector>& events, int k) {
- sort(events.begin(), events.end());
+ ranges::sort(events);
int n = events.size();
int f[n][k + 1];
memset(f, 0, sizeof(f));
- function dfs = [&](int i, int k) -> int {
+ auto dfs = [&](this auto&& dfs, int i, int k) -> int {
if (i >= n || k <= 0) {
return 0;
}
if (f[i][k] > 0) {
return f[i][k];
}
+
int ed = events[i][1], val = events[i][2];
vector t = {ed};
- int p = upper_bound(events.begin() + i + 1, events.end(), t, [](const auto& a, const auto& b) { return a[0] < b[0]; }) - events.begin();
+
+ int p = upper_bound(events.begin() + i + 1, events.end(), t,
+ [](const auto& a, const auto& b) { return a[0] < b[0]; })
+ - events.begin();
+
f[i][k] = max(dfs(i + 1, k), dfs(p, k - 1) + val);
return f[i][k];
};
+
return dfs(0, k);
}
};
@@ -216,30 +222,79 @@ func maxValue(events [][]int, k int) int {
```ts
function maxValue(events: number[][], k: number): number {
- events.sort((a, b) => a[1] - b[1]);
+ events.sort((a, b) => a[0] - b[0]);
const n = events.length;
- const f: number[][] = new Array(n + 1).fill(0).map(() => new Array(k + 1).fill(0));
- const search = (x: number, hi: number): number => {
- let l = 0;
- let r = hi;
- while (l < r) {
- const mid = (l + r) >> 1;
- if (events[mid][1] >= x) {
- r = mid;
+ const f: number[][] = Array.from({ length: n }, () => Array(k + 1).fill(0));
+
+ const dfs = (i: number, k: number): number => {
+ if (i >= n || k <= 0) {
+ return 0;
+ }
+ if (f[i][k] > 0) {
+ return f[i][k];
+ }
+
+ const ed = events[i][1],
+ val = events[i][2];
+
+ let left = i + 1,
+ right = n;
+ while (left < right) {
+ const mid = (left + right) >> 1;
+ if (events[mid][0] > ed) {
+ right = mid;
} else {
- l = mid + 1;
+ left = mid + 1;
}
}
- return l;
+ const p = left;
+
+ f[i][k] = Math.max(dfs(i + 1, k), dfs(p, k - 1) + val);
+ return f[i][k];
};
- for (let i = 1; i <= n; ++i) {
- const [st, _, val] = events[i - 1];
- const p = search(st, i - 1);
- for (let j = 1; j <= k; ++j) {
- f[i][j] = Math.max(f[i - 1][j], f[p][j - 1] + val);
+
+ return dfs(0, k);
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+ pub fn max_value(mut events: Vec>, k: i32) -> i32 {
+ events.sort_by_key(|e| e[0]);
+ let n = events.len();
+ let mut f = vec![vec![0; (k + 1) as usize]; n];
+
+ fn dfs(i: usize, k: i32, events: &Vec>, f: &mut Vec>, n: usize) -> i32 {
+ if i >= n || k <= 0 {
+ return 0;
+ }
+ if f[i][k as usize] != 0 {
+ return f[i][k as usize];
+ }
+ let j = search(events, events[i][1], i + 1, n);
+ let ans = dfs(i + 1, k, events, f, n).max(dfs(j, k - 1, events, f, n) + events[i][2]);
+ f[i][k as usize] = ans;
+ ans
}
+
+ fn search(events: &Vec>, x: i32, lo: usize, n: usize) -> usize {
+ let mut l = lo;
+ let mut r = n;
+ while l < r {
+ let mid = (l + r) / 2;
+ if events[mid][0] > x {
+ r = mid;
+ } else {
+ l = mid + 1;
+ }
+ }
+ l
+ }
+
+ dfs(0, k, &events, &mut f, n)
}
- return f[n][k];
}
```
@@ -255,15 +310,15 @@ function maxValue(events: number[][], k: number): number {
先将会议排序，这次我们按照结束时间从小到大排序。然后定义 $f[i][j]$ 表示前 $i$ 个会议中，最多参加 $j$ 个会议的最大价值和。答案即为 $f[n][k]$。
-对于第 $i$ 个会议，我们可以选择参加或者不参加。如果不参加，那么最大价值和就是 $f[i][j]$，如果参加，我们可以通过二分查找，找到最后一个结束时间小于第 $i$ 个会议开始时间的会议，记为 $h$，那么最大价值和就是 $f[h+1][j - 1] + value[i]$。取二者的较大值即可。即：
+对于第 $i$ 个会议，我们可以选择参加或者不参加。如果不参加，那么最大价值和就是 $f[i][j]$，如果参加，我们可以通过二分查找，找到最后一个结束时间小于第 $i$ 个会议开始时间的会议，记为 $h$，那么最大价值和就是 $f[h + 1][j - 1] + \text{value}[i]$。取二者的较大值即可。即：
$$
-f[i+1][j] = \max(f[i][j], f[h+1][j - 1] + value[i])
+f[i + 1][j] = \max(f[i][j], f[h + 1][j - 1] + \text{value}[i])
$$
其中 $h$ 为最后一个结束时间小于第 $i$ 个会议开始时间的会议，可以通过二分查找得到。
-时间复杂度 $O(n\times \log n + n\times k)$，其中 $n$ 为会议数量。
+时间复杂度 $O(n \times \log n + n \times k)$，空间复杂度 $O(n \times k)$，其中 $n$ 为会议数量。
相似题目：
@@ -364,6 +419,74 @@ func maxValue(events [][]int, k int) int {
}
```
+#### TypeScript
+
+```ts
+function maxValue(events: number[][], k: number): number {
+ events.sort((a, b) => a[1] - b[1]);
+ const n = events.length;
+ const f: number[][] = new Array(n + 1).fill(0).map(() => new Array(k + 1).fill(0));
+ const search = (x: number, hi: number): number => {
+ let l = 0;
+ let r = hi;
+ while (l < r) {
+ const mid = (l + r) >> 1;
+ if (events[mid][1] >= x) {
+ r = mid;
+ } else {
+ l = mid + 1;
+ }
+ }
+ return l;
+ };
+ for (let i = 1; i <= n; ++i) {
+ const [st, _, val] = events[i - 1];
+ const p = search(st, i - 1);
+ for (let j = 1; j <= k; ++j) {
+ f[i][j] = Math.max(f[i - 1][j], f[p][j - 1] + val);
+ }
+ }
+ return f[n][k];
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+ pub fn max_value(mut events: Vec>, k: i32) -> i32 {
+ events.sort_by_key(|e| e[1]);
+ let n = events.len();
+ let mut f = vec![vec![0; (k + 1) as usize]; n + 1];
+
+ for i in 1..=n {
+ let st = events[i - 1][0];
+ let val = events[i - 1][2];
+ let p = search(&events, st, i - 1);
+ for j in 1..=k as usize {
+ f[i][j] = f[i - 1][j].max(f[p][j - 1] + val);
+ }
+ }
+
+ f[n][k as usize]
+ }
+}
+
+fn search(events: &Vec>, x: i32, hi: usize) -> usize {
+ let mut l = 0;
+ let mut r = hi;
+ while l < r {
+ let mid = (l + r) / 2;
+ if events[mid][1] >= x {
+ r = mid;
+ } else {
+ l = mid + 1;
+ }
+ }
+ l
+}
+```
+
diff --git a/solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/README_EN.md b/solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/README_EN.md
index a8a515dca126a..6f87bd6062aad 100644
--- a/solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/README_EN.md
+++ b/solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/README_EN.md
@@ -72,7 +72,23 @@ Notice that you cannot attend any other event as they overlap, and that you do <
-### Solution 1
+### Solution 1: Memoization + Binary Search
+
+First, we sort the events by their start time in ascending order. Then, we define a function $\text{dfs}(i, k)$, which represents the maximum total value achievable by attending at most $k$ events starting from the $i$-th event. The answer is $\text{dfs}(0, k)$.
+
+The calculation process of the function $\text{dfs}(i, k)$ is as follows:
+
+If we do not attend the $i$-th event, the maximum value is $\text{dfs}(i + 1, k)$. If we attend the $i$-th event, we can use binary search to find the first event whose start time is greater than the end time of the $i$-th event, denoted as $j$. Then, the maximum value is $\text{dfs}(j, k - 1) + \text{value}[i]$. We take the maximum of the two options:
+
+$$
+\text{dfs}(i, k) = \max(\text{dfs}(i + 1, k), \text{dfs}(j, k - 1) + \text{value}[i])
+$$
+
+Here, $j$ is the index of the first event whose start time is greater than the end time of the $i$-th event, which can be found using binary search.
+
+Since the calculation of $\text{dfs}(i, k)$ involves calls to $\text{dfs}(i + 1, k)$ and $\text{dfs}(j, k - 1)$, we can use memoization to store the computed values and avoid redundant calculations.
+
+The time complexity is $O(n \times \log n + n \times k)$, and the space complexity is $O(n \times k)$, where $n$ is the number of events.
@@ -145,23 +161,29 @@ class Solution {
class Solution {
public:
int maxValue(vector>& events, int k) {
- sort(events.begin(), events.end());
+ ranges::sort(events);
int n = events.size();
int f[n][k + 1];
memset(f, 0, sizeof(f));
- function dfs = [&](int i, int k) -> int {
+ auto dfs = [&](this auto&& dfs, int i, int k) -> int {
if (i >= n || k <= 0) {
return 0;
}
if (f[i][k] > 0) {
return f[i][k];
}
+
int ed = events[i][1], val = events[i][2];
vector t = {ed};
- int p = upper_bound(events.begin() + i + 1, events.end(), t, [](const auto& a, const auto& b) { return a[0] < b[0]; }) - events.begin();
+
+ int p = upper_bound(events.begin() + i + 1, events.end(), t,
+ [](const auto& a, const auto& b) { return a[0] < b[0]; })
+ - events.begin();
+
f[i][k] = max(dfs(i + 1, k), dfs(p, k - 1) + val);
return f[i][k];
};
+
return dfs(0, k);
}
};
@@ -198,30 +220,79 @@ func maxValue(events [][]int, k int) int {
```ts
function maxValue(events: number[][], k: number): number {
- events.sort((a, b) => a[1] - b[1]);
+ events.sort((a, b) => a[0] - b[0]);
const n = events.length;
- const f: number[][] = new Array(n + 1).fill(0).map(() => new Array(k + 1).fill(0));
- const search = (x: number, hi: number): number => {
- let l = 0;
- let r = hi;
- while (l < r) {
- const mid = (l + r) >> 1;
- if (events[mid][1] >= x) {
- r = mid;
+ const f: number[][] = Array.from({ length: n }, () => Array(k + 1).fill(0));
+
+ const dfs = (i: number, k: number): number => {
+ if (i >= n || k <= 0) {
+ return 0;
+ }
+ if (f[i][k] > 0) {
+ return f[i][k];
+ }
+
+ const ed = events[i][1],
+ val = events[i][2];
+
+ let left = i + 1,
+ right = n;
+ while (left < right) {
+ const mid = (left + right) >> 1;
+ if (events[mid][0] > ed) {
+ right = mid;
} else {
- l = mid + 1;
+ left = mid + 1;
}
}
- return l;
+ const p = left;
+
+ f[i][k] = Math.max(dfs(i + 1, k), dfs(p, k - 1) + val);
+ return f[i][k];
};
- for (let i = 1; i <= n; ++i) {
- const [st, _, val] = events[i - 1];
- const p = search(st, i - 1);
- for (let j = 1; j <= k; ++j) {
- f[i][j] = Math.max(f[i - 1][j], f[p][j - 1] + val);
+
+ return dfs(0, k);
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+ pub fn max_value(mut events: Vec>, k: i32) -> i32 {
+ events.sort_by_key(|e| e[0]);
+ let n = events.len();
+ let mut f = vec![vec![0; (k + 1) as usize]; n];
+
+ fn dfs(i: usize, k: i32, events: &Vec>, f: &mut Vec>, n: usize) -> i32 {
+ if i >= n || k <= 0 {
+ return 0;
+ }
+ if f[i][k as usize] != 0 {
+ return f[i][k as usize];
+ }
+ let j = search(events, events[i][1], i + 1, n);
+ let ans = dfs(i + 1, k, events, f, n).max(dfs(j, k - 1, events, f, n) + events[i][2]);
+ f[i][k as usize] = ans;
+ ans
+ }
+
+ fn search(events: &Vec>, x: i32, lo: usize, n: usize) -> usize {
+ let mut l = lo;
+ let mut r = n;
+ while l < r {
+ let mid = (l + r) / 2;
+ if events[mid][0] > x {
+ r = mid;
+ } else {
+ l = mid + 1;
+ }
+ }
+ l
}
+
+ dfs(0, k, &events, &mut f, n)
}
- return f[n][k];
}
```
@@ -231,7 +302,26 @@ function maxValue(events: number[][], k: number): number {
-### Solution 2
+### Solution 2: Dynamic Programming + Binary Search
+
+We can convert the memoization approach in Solution 1 to dynamic programming.
+
+First, sort the events, this time by end time in ascending order. Then define $f[i][j]$ as the maximum total value by attending at most $j$ events among the first $i$ events. The answer is $f[n][k]$.
+
+For the $i$-th event, we can choose to attend it or not. If we do not attend, the maximum value is $f[i][j]$. If we attend, we can use binary search to find the last event whose end time is less than the start time of the $i$-th event, denoted as $h$. Then the maximum value is $f[h + 1][j - 1] + \text{value}[i]$. We take the maximum of the two options:
+
+$$
+f[i + 1][j] = \max(f[i][j], f[h + 1][j - 1] + \text{value}[i])
+$$
+
+Here, $h$ is the last event whose end time is less than the start time of the $i$-th event, which can be found by binary search.
+
+The time complexity is $O(n \times \log n + n \times k)$, and the space complexity is $O(n \times k)$, where $n$ is the number of events.
+
+Related problems:
+
+- [1235. Maximum Profit in Job Scheduling](https://github.com/doocs/leetcode/blob/main/solution/1200-1299/1235.Maximum%20Profit%20in%20Job%20Scheduling/README_EN.md)
+- [2008. Maximum Earnings From Taxi](https://github.com/doocs/leetcode/blob/main/solution/2000-2099/2008.Maximum%20Earnings%20From%20Taxi/README_EN.md)
@@ -327,6 +417,74 @@ func maxValue(events [][]int, k int) int {
}
```
+#### TypeScript
+
+```ts
+function maxValue(events: number[][], k: number): number {
+ events.sort((a, b) => a[1] - b[1]);
+ const n = events.length;
+ const f: number[][] = new Array(n + 1).fill(0).map(() => new Array(k + 1).fill(0));
+ const search = (x: number, hi: number): number => {
+ let l = 0;
+ let r = hi;
+ while (l < r) {
+ const mid = (l + r) >> 1;
+ if (events[mid][1] >= x) {
+ r = mid;
+ } else {
+ l = mid + 1;
+ }
+ }
+ return l;
+ };
+ for (let i = 1; i <= n; ++i) {
+ const [st, _, val] = events[i - 1];
+ const p = search(st, i - 1);
+ for (let j = 1; j <= k; ++j) {
+ f[i][j] = Math.max(f[i - 1][j], f[p][j - 1] + val);
+ }
+ }
+ return f[n][k];
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+ pub fn max_value(mut events: Vec>, k: i32) -> i32 {
+ events.sort_by_key(|e| e[1]);
+ let n = events.len();
+ let mut f = vec![vec![0; (k + 1) as usize]; n + 1];
+
+ for i in 1..=n {
+ let st = events[i - 1][0];
+ let val = events[i - 1][2];
+ let p = search(&events, st, i - 1);
+ for j in 1..=k as usize {
+ f[i][j] = f[i - 1][j].max(f[p][j - 1] + val);
+ }
+ }
+
+ f[n][k as usize]
+ }
+}
+
+fn search(events: &Vec>, x: i32, hi: usize) -> usize {
+ let mut l = 0;
+ let mut r = hi;
+ while l < r {
+ let mid = (l + r) / 2;
+ if events[mid][1] >= x {
+ r = mid;
+ } else {
+ l = mid + 1;
+ }
+ }
+ l
+}
+```
+
diff --git a/solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/Solution.cpp b/solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/Solution.cpp
index 42e112883fae4..c854e716cef7b 100644
--- a/solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/Solution.cpp
+++ b/solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/Solution.cpp
@@ -1,23 +1,29 @@
class Solution {
public:
int maxValue(vector>& events, int k) {
- sort(events.begin(), events.end());
+ ranges::sort(events);
int n = events.size();
int f[n][k + 1];
memset(f, 0, sizeof(f));
- function dfs = [&](int i, int k) -> int {
+ auto dfs = [&](this auto&& dfs, int i, int k) -> int {
if (i >= n || k <= 0) {
return 0;
}
if (f[i][k] > 0) {
return f[i][k];
}
+
int ed = events[i][1], val = events[i][2];
vector t = {ed};
- int p = upper_bound(events.begin() + i + 1, events.end(), t, [](const auto& a, const auto& b) { return a[0] < b[0]; }) - events.begin();
+
+ int p = upper_bound(events.begin() + i + 1, events.end(), t,
+ [](const auto& a, const auto& b) { return a[0] < b[0]; })
+ - events.begin();
+
f[i][k] = max(dfs(i + 1, k), dfs(p, k - 1) + val);
return f[i][k];
};
+
return dfs(0, k);
}
-};
\ No newline at end of file
+};
diff --git a/solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/Solution.rs b/solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/Solution.rs
new file mode 100644
index 0000000000000..d5a8276d68778
--- /dev/null
+++ b/solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/Solution.rs
@@ -0,0 +1,36 @@
+impl Solution {
+ pub fn max_value(mut events: Vec>, k: i32) -> i32 {
+ events.sort_by_key(|e| e[0]);
+ let n = events.len();
+ let mut f = vec![vec![0; (k + 1) as usize]; n];
+
+ fn dfs(i: usize, k: i32, events: &Vec>, f: &mut Vec>, n: usize) -> i32 {
+ if i >= n || k <= 0 {
+ return 0;
+ }
+ if f[i][k as usize] != 0 {
+ return f[i][k as usize];
+ }
+ let j = search(events, events[i][1], i + 1, n);
+ let ans = dfs(i + 1, k, events, f, n).max(dfs(j, k - 1, events, f, n) + events[i][2]);
+ f[i][k as usize] = ans;
+ ans
+ }
+
+ fn search(events: &Vec>, x: i32, lo: usize, n: usize) -> usize {
+ let mut l = lo;
+ let mut r = n;
+ while l < r {
+ let mid = (l + r) / 2;
+ if events[mid][0] > x {
+ r = mid;
+ } else {
+ l = mid + 1;
+ }
+ }
+ l
+ }
+
+ dfs(0, k, &events, &mut f, n)
+ }
+}
diff --git a/solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/Solution.ts b/solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/Solution.ts
index c370b2cb5e927..169bcdab7d110 100644
--- a/solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/Solution.ts
+++ b/solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/Solution.ts
@@ -1,26 +1,34 @@
function maxValue(events: number[][], k: number): number {
- events.sort((a, b) => a[1] - b[1]);
+ events.sort((a, b) => a[0] - b[0]);
const n = events.length;
- const f: number[][] = new Array(n + 1).fill(0).map(() => new Array(k + 1).fill(0));
- const search = (x: number, hi: number): number => {
- let l = 0;
- let r = hi;
- while (l < r) {
- const mid = (l + r) >> 1;
- if (events[mid][1] >= x) {
- r = mid;
+ const f: number[][] = Array.from({ length: n }, () => Array(k + 1).fill(0));
+
+ const dfs = (i: number, k: number): number => {
+ if (i >= n || k <= 0) {
+ return 0;
+ }
+ if (f[i][k] > 0) {
+ return f[i][k];
+ }
+
+ const ed = events[i][1],
+ val = events[i][2];
+
+ let left = i + 1,
+ right = n;
+ while (left < right) {
+ const mid = (left + right) >> 1;
+ if (events[mid][0] > ed) {
+ right = mid;
} else {
- l = mid + 1;
+ left = mid + 1;
}
}
- return l;
+ const p = left;
+
+ f[i][k] = Math.max(dfs(i + 1, k), dfs(p, k - 1) + val);
+ return f[i][k];
};
- for (let i = 1; i <= n; ++i) {
- const [st, _, val] = events[i - 1];
- const p = search(st, i - 1);
- for (let j = 1; j <= k; ++j) {
- f[i][j] = Math.max(f[i - 1][j], f[p][j - 1] + val);
- }
- }
- return f[n][k];
+
+ return dfs(0, k);
}
diff --git a/solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/Solution2.rs b/solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/Solution2.rs
new file mode 100644
index 0000000000000..c908d6ad6baba
--- /dev/null
+++ b/solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/Solution2.rs
@@ -0,0 +1,32 @@
+impl Solution {
+ pub fn max_value(mut events: Vec>, k: i32) -> i32 {
+ events.sort_by_key(|e| e[1]);
+ let n = events.len();
+ let mut f = vec![vec![0; (k + 1) as usize]; n + 1];
+
+ for i in 1..=n {
+ let st = events[i - 1][0];
+ let val = events[i - 1][2];
+ let p = search(&events, st, i - 1);
+ for j in 1..=k as usize {
+ f[i][j] = f[i - 1][j].max(f[p][j - 1] + val);
+ }
+ }
+
+ f[n][k as usize]
+ }
+}
+
+fn search(events: &Vec>, x: i32, hi: usize) -> usize {
+ let mut l = 0;
+ let mut r = hi;
+ while l < r {
+ let mid = (l + r) / 2;
+ if events[mid][1] >= x {
+ r = mid;
+ } else {
+ l = mid + 1;
+ }
+ }
+ l
+}
diff --git a/solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/Solution2.ts b/solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/Solution2.ts
new file mode 100644
index 0000000000000..c370b2cb5e927
--- /dev/null
+++ b/solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/Solution2.ts
@@ -0,0 +1,26 @@
+function maxValue(events: number[][], k: number): number {
+ events.sort((a, b) => a[1] - b[1]);
+ const n = events.length;
+ const f: number[][] = new Array(n + 1).fill(0).map(() => new Array(k + 1).fill(0));
+ const search = (x: number, hi: number): number => {
+ let l = 0;
+ let r = hi;
+ while (l < r) {
+ const mid = (l + r) >> 1;
+ if (events[mid][1] >= x) {
+ r = mid;
+ } else {
+ l = mid + 1;
+ }
+ }
+ return l;
+ };
+ for (let i = 1; i <= n; ++i) {
+ const [st, _, val] = events[i - 1];
+ const p = search(st, i - 1);
+ for (let j = 1; j <= k; ++j) {
+ f[i][j] = Math.max(f[i - 1][j], f[p][j - 1] + val);
+ }
+ }
+ return f[n][k];
+}
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/1768.Merge Strings Alternately/README_EN.md b/solution/1700-1799/1768.Merge Strings Alternately/README_EN.md
index 28ec43946435a..23f19bc99a475 100644
--- a/solution/1700-1799/1768.Merge Strings Alternately/README_EN.md
+++ b/solution/1700-1799/1768.Merge Strings Alternately/README_EN.md
@@ -24,45 +24,71 @@ tags:
Return the merged string.
+
Example 1:
+
Input: word1 = "abc", word2 = "pqr"
+
Output: "apbqcr"
+
Explanation: The merged string will be merged as so:
+
word1: a b c
+
word2: p q r
+
merged: a p b q c r
+
Example 2:
+
Input: word1 = "ab", word2 = "pqrs"
+
Output: "apbqrs"
+
Explanation: Notice that as word2 is longer, "rs" is appended to the end.
+
word1: a b
+
word2: p q r s
+
merged: a p b q r s
+
Example 3:
+
Input: word1 = "abcd", word2 = "pq"
+
Output: "apbqcd"
+
Explanation: Notice that as word1 is longer, "cd" is appended to the end.
+
word1: a b c d
+
word2: p q
+
merged: a p b q c d
+
+
Constraints:
- 1 <= word1.length, word2.length <= 100word1 and word2 consist of lowercase English letters.1 <= word1.length, word2.length <= 100word1 and word2 consist of lowercase English letters.
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/1700-1799/1788.Maximize the Beauty of the Garden/README_EN.md b/solution/1700-1799/1788.Maximize the Beauty of the Garden/README_EN.md
index 8060248067a33..08179c3e044b3 100644
--- a/solution/1700-1799/1788.Maximize the Beauty of the Garden/README_EN.md
+++ b/solution/1700-1799/1788.Maximize the Beauty of the Garden/README_EN.md
@@ -24,8 +24,11 @@ tags:
A garden is valid if it meets these conditions:
- - The garden has at least two flowers.
- - The first and the last flower of the garden have the same beauty value.
+
+ - The garden has at least two flowers.
+
+ - The first and the last flower of the garden have the same beauty value.
+
As the appointed gardener, you have the ability to remove any (possibly none) flowers from the garden. You want to remove flowers in a way that makes the remaining garden valid. The beauty of the garden is the sum of the beauty of all the remaining flowers.
@@ -33,36 +36,53 @@ tags:
Return the maximum possible beauty of some valid garden after you have removed any (possibly none) flowers.
+
Example 1:
+
Input: flowers = [1,2,3,1,2]
+
Output: 8
+
Explanation: You can produce the valid garden [2,3,1,2] to have a total beauty of 2 + 3 + 1 + 2 = 8.
Example 2:
+
Input: flowers = [100,1,1,-3,1]
+
Output: 3
+
Explanation: You can produce the valid garden [1,1,1] to have a total beauty of 1 + 1 + 1 = 3.
+
Example 3:
+
Input: flowers = [-1,-2,0,-1]
+
Output: -2
+
Explanation: You can produce the valid garden [-1,-1] to have a total beauty of -1 + -1 = -2.
+
+
Constraints:
- 2 <= flowers.length <= 105-104 <= flowers[i] <= 104- It is possible to create a valid garden by removing some (possibly none) flowers.
+
+ 2 <= flowers.length <= 105-104 <= flowers[i] <= 104- It is possible to create a valid garden by removing some (possibly none) flowers.
+
diff --git a/solution/1800-1899/1801.Number of Orders in the Backlog/README_EN.md b/solution/1800-1899/1801.Number of Orders in the Backlog/README_EN.md
index 858710a6203f7..fb8b1f0df8967 100644
--- a/solution/1800-1899/1801.Number of Orders in the Backlog/README_EN.md
+++ b/solution/1800-1899/1801.Number of Orders in the Backlog/README_EN.md
@@ -23,8 +23,11 @@ tags:
You are given a 2D integer array orders, where each orders[i] = [pricei, amounti, orderTypei] denotes that amounti orders have been placed of type orderTypei at the price pricei. The orderTypei is:
- 0 if it is a batch of buy orders, or1 if it is a batch of sell orders.0 if it is a batch of buy orders, or1 if it is a batch of sell orders.
Note that orders[i] represents a batch of amounti independent orders with the same price and order type. All orders represented by orders[i] will be placed before all orders represented by orders[i+1] for all valid i.
@@ -32,47 +35,79 @@ tags:
There is a backlog that consists of orders that have not been executed. The backlog is initially empty. When an order is placed, the following happens:
- - If the order is a
buy order, you look at the sell order with the smallest price in the backlog. If that sell order's price is smaller than or equal to the current buy order's price, they will match and be executed, and that sell order will be removed from the backlog. Else, the buy order is added to the backlog.
- - Vice versa, if the order is a
sell order, you look at the buy order with the largest price in the backlog. If that buy order's price is larger than or equal to the current sell order's price, they will match and be executed, and that buy order will be removed from the backlog. Else, the sell order is added to the backlog.
+
+ - If the order is a
buy order, you look at the sell order with the smallest price in the backlog. If that sell order's price is smaller than or equal to the current buy order's price, they will match and be executed, and that sell order will be removed from the backlog. Else, the buy order is added to the backlog.
+
+ - Vice versa, if the order is a
sell order, you look at the buy order with the largest price in the backlog. If that buy order's price is larger than or equal to the current sell order's price, they will match and be executed, and that buy order will be removed from the backlog. Else, the sell order is added to the backlog.
+
Return the total amount of orders in the backlog after placing all the orders from the input. Since this number can be large, return it modulo 109 + 7.
+
Example 1:
+
+
+
Input: orders = [[10,5,0],[15,2,1],[25,1,1],[30,4,0]]
+
Output: 6
+
Explanation: Here is what happens with the orders:
+
- 5 orders of type buy with price 10 are placed. There are no sell orders, so the 5 orders are added to the backlog.
+
- 2 orders of type sell with price 15 are placed. There are no buy orders with prices larger than or equal to 15, so the 2 orders are added to the backlog.
+
- 1 order of type sell with price 25 is placed. There are no buy orders with prices larger than or equal to 25 in the backlog, so this order is added to the backlog.
+
- 4 orders of type buy with price 30 are placed. The first 2 orders are matched with the 2 sell orders of the least price, which is 15 and these 2 sell orders are removed from the backlog. The 3rd order is matched with the sell order of the least price, which is 25 and this sell order is removed from the backlog. Then, there are no more sell orders in the backlog, so the 4th order is added to the backlog.
+
Finally, the backlog has 5 buy orders with price 10, and 1 buy order with price 30. So the total number of orders in the backlog is 6.
+
Example 2:
+
+
+
Input: orders = [[7,1000000000,1],[15,3,0],[5,999999995,0],[5,1,1]]
+
Output: 999999984
+
Explanation: Here is what happens with the orders:
+
- 109 orders of type sell with price 7 are placed. There are no buy orders, so the 109 orders are added to the backlog.
+
- 3 orders of type buy with price 15 are placed. They are matched with the 3 sell orders with the least price which is 7, and those 3 sell orders are removed from the backlog.
+
- 999999995 orders of type buy with price 5 are placed. The least price of a sell order is 7, so the 999999995 orders are added to the backlog.
+
- 1 order of type sell with price 5 is placed. It is matched with the buy order of the highest price, which is 5, and that buy order is removed from the backlog.
+
Finally, the backlog has (1000000000-3) sell orders with price 7, and (999999995-1) buy orders with price 5. So the total number of orders = 1999999991, which is equal to 999999984 % (109 + 7).
+
+
Constraints:
- 1 <= orders.length <= 105orders[i].length == 31 <= pricei, amounti <= 109orderTypei is either 0 or 1.1 <= orders.length <= 105orders[i].length == 31 <= pricei, amounti <= 109orderTypei is either 0 or 1.
diff --git a/solution/1800-1899/1802.Maximum Value at a Given Index in a Bounded Array/README.md b/solution/1800-1899/1802.Maximum Value at a Given Index in a Bounded Array/README.md
index 3902264817560..79459f61da135 100644
--- a/solution/1800-1899/1802.Maximum Value at a Given Index in a Bounded Array/README.md
+++ b/solution/1800-1899/1802.Maximum Value at a Given Index in a Bounded Array/README.md
@@ -6,6 +6,7 @@ rating: 1929
source: 第 233 场周赛 Q3
tags:
- 贪心
+ - 数学
- 二分查找
---
diff --git a/solution/1800-1899/1802.Maximum Value at a Given Index in a Bounded Array/README_EN.md b/solution/1800-1899/1802.Maximum Value at a Given Index in a Bounded Array/README_EN.md
index 4370d39827873..3bd85a7016599 100644
--- a/solution/1800-1899/1802.Maximum Value at a Given Index in a Bounded Array/README_EN.md
+++ b/solution/1800-1899/1802.Maximum Value at a Given Index in a Bounded Array/README_EN.md
@@ -6,6 +6,7 @@ rating: 1929
source: Weekly Contest 233 Q3
tags:
- Greedy
+ - Math
- Binary Search
---
diff --git a/solution/1800-1899/1803.Count Pairs With XOR in a Range/README_EN.md b/solution/1800-1899/1803.Count Pairs With XOR in a Range/README_EN.md
index 71d734e8f7114..b2f0cba2a3268 100644
--- a/solution/1800-1899/1803.Count Pairs With XOR in a Range/README_EN.md
+++ b/solution/1800-1899/1803.Count Pairs With XOR in a Range/README_EN.md
@@ -25,42 +25,69 @@ tags:
A nice pair is a pair (i, j) where 0 <= i < j < nums.length and low <= (nums[i] XOR nums[j]) <= high.
+
Example 1:
+
Input: nums = [1,4,2,7], low = 2, high = 6
+
Output: 6
+
Explanation: All nice pairs (i, j) are as follows:
+
- (0, 1): nums[0] XOR nums[1] = 5
+
- (0, 2): nums[0] XOR nums[2] = 3
+
- (0, 3): nums[0] XOR nums[3] = 6
+
- (1, 2): nums[1] XOR nums[2] = 6
+
- (1, 3): nums[1] XOR nums[3] = 3
+
- (2, 3): nums[2] XOR nums[3] = 5
+
Example 2:
+
Input: nums = [9,8,4,2,1], low = 5, high = 14
+
Output: 8
+
Explanation: All nice pairs (i, j) are as follows:
+
- (0, 2): nums[0] XOR nums[2] = 13
+
- (0, 3): nums[0] XOR nums[3] = 11
+
- (0, 4): nums[0] XOR nums[4] = 8
+
- (1, 2): nums[1] XOR nums[2] = 12
+
- (1, 3): nums[1] XOR nums[3] = 10
+
- (1, 4): nums[1] XOR nums[4] = 9
+
- (2, 3): nums[2] XOR nums[3] = 6
+
- (2, 4): nums[2] XOR nums[4] = 5
+
Constraints:
- 1 <= nums.length <= 2 * 1041 <= nums[i] <= 2 * 1041 <= low <= high <= 2 * 1041 <= nums.length <= 2 * 1041 <= nums[i] <= 2 * 1041 <= low <= high <= 2 * 104
diff --git a/solution/1800-1899/1808.Maximize Number of Nice Divisors/README_EN.md b/solution/1800-1899/1808.Maximize Number of Nice Divisors/README_EN.md
index 043890fcacd1a..d114a92da494e 100644
--- a/solution/1800-1899/1808.Maximize Number of Nice Divisors/README_EN.md
+++ b/solution/1800-1899/1808.Maximize Number of Nice Divisors/README_EN.md
@@ -23,8 +23,11 @@ tags:
You are given a positive integer primeFactors. You are asked to construct a positive integer n that satisfies the following conditions:
+
- The number of prime factors of
n (not necessarily distinct) is at most primeFactors.
+
- The number of nice divisors of
n is maximized. Note that a divisor of n is nice if it is divisible by every prime factor of n. For example, if n = 12, then its prime factors are [2,2,3], then 6 and 12 are nice divisors, while 3 and 4 are not.
+
Return the number of nice divisors of n. Since that number can be too large, return it modulo 109 + 7.
@@ -32,28 +35,41 @@ tags:
Note that a prime number is a natural number greater than 1 that is not a product of two smaller natural numbers. The prime factors of a number n is a list of prime numbers such that their product equals n.
+
Example 1:
+
Input: primeFactors = 5
+
Output: 6
+
Explanation: 200 is a valid value of n.
+
It has 5 prime factors: [2,2,2,5,5], and it has 6 nice divisors: [10,20,40,50,100,200].
+
There is not other value of n that has at most 5 prime factors and more nice divisors.
+
Example 2:
+
Input: primeFactors = 8
+
Output: 18
+
+
Constraints:
- 1 <= primeFactors <= 1091 <= primeFactors <= 109
diff --git a/solution/1800-1899/1827.Minimum Operations to Make the Array Increasing/README_EN.md b/solution/1800-1899/1827.Minimum Operations to Make the Array Increasing/README_EN.md
index af4a7cf20dd88..979e584e8350d 100644
--- a/solution/1800-1899/1827.Minimum Operations to Make the Array Increasing/README_EN.md
+++ b/solution/1800-1899/1827.Minimum Operations to Make the Array Increasing/README_EN.md
@@ -22,7 +22,9 @@ tags:
You are given an integer array nums (0-indexed). In one operation, you can choose an element of the array and increment it by 1.
- - For example, if
nums = [1,2,3], you can choose to increment nums[1] to make nums = [1,3,3].
+
+ - For example, if
nums = [1,2,3], you can choose to increment nums[1] to make nums = [1,3,3].
+
Return the minimum number of operations needed to make nums strictly increasing.
@@ -30,37 +32,55 @@ tags:
An array nums is strictly increasing if nums[i] < nums[i+1] for all 0 <= i < nums.length - 1. An array of length 1 is trivially strictly increasing.
+
Example 1:
+
Input: nums = [1,1,1]
+
Output: 3
+
Explanation: You can do the following operations:
+
1) Increment nums[2], so nums becomes [1,1,2].
+
2) Increment nums[1], so nums becomes [1,2,2].
+
3) Increment nums[2], so nums becomes [1,2,3].
+
Example 2:
+
Input: nums = [1,5,2,4,1]
+
Output: 14
+
Example 3:
+
Input: nums = [8]
+
Output: 0
+
+
Constraints:
- 1 <= nums.length <= 50001 <= nums[i] <= 1041 <= nums.length <= 50001 <= nums[i] <= 104
diff --git a/solution/1800-1899/1836.Remove Duplicates From an Unsorted Linked List/README_EN.md b/solution/1800-1899/1836.Remove Duplicates From an Unsorted Linked List/README_EN.md
index 22fb099044ee4..e1c623dee2b31 100644
--- a/solution/1800-1899/1836.Remove Duplicates From an Unsorted Linked List/README_EN.md
+++ b/solution/1800-1899/1836.Remove Duplicates From an Unsorted Linked List/README_EN.md
@@ -22,36 +22,59 @@ tags:
Return the linked list after the deletions.
+
Example 1:
+
+
+
Input: head = [1,2,3,2]
+
Output: [1,3]
+
Explanation: 2 appears twice in the linked list, so all 2's should be deleted. After deleting all 2's, we are left with [1,3].
+
Example 2:
+
+
+
Input: head = [2,1,1,2]
+
Output: []
+
Explanation: 2 and 1 both appear twice. All the elements should be deleted.
+
Example 3:
+
+
+
Input: head = [3,2,2,1,3,2,4]
+
Output: [1,4]
+
Explanation: 3 appears twice and 2 appears three times. After deleting all 3's and 2's, we are left with [1,4].
+
+
Constraints:
- - The number of nodes in the list is in the range
[1, 105]
- 1 <= Node.val <= 105- The number of nodes in the list is in the range
[1, 105]
+
+ 1 <= Node.val <= 105
diff --git a/solution/1800-1899/1849.Splitting a String Into Descending Consecutive Values/README.md b/solution/1800-1899/1849.Splitting a String Into Descending Consecutive Values/README.md
index 2a5ef80e5fc38..a4e2bda1312cc 100644
--- a/solution/1800-1899/1849.Splitting a String Into Descending Consecutive Values/README.md
+++ b/solution/1800-1899/1849.Splitting a String Into Descending Consecutive Values/README.md
@@ -7,6 +7,7 @@ source: 第 239 场周赛 Q2
tags:
- 字符串
- 回溯
+ - 枚举
---
diff --git a/solution/1800-1899/1849.Splitting a String Into Descending Consecutive Values/README_EN.md b/solution/1800-1899/1849.Splitting a String Into Descending Consecutive Values/README_EN.md
index 30dc658f3ac31..0b1f91ba8ca84 100644
--- a/solution/1800-1899/1849.Splitting a String Into Descending Consecutive Values/README_EN.md
+++ b/solution/1800-1899/1849.Splitting a String Into Descending Consecutive Values/README_EN.md
@@ -7,6 +7,7 @@ source: Weekly Contest 239 Q2
tags:
- String
- Backtracking
+ - Enumeration
---
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/1800-1899/1865.Finding Pairs With a Certain Sum/README.md b/solution/1800-1899/1865.Finding Pairs With a Certain Sum/README.md
index 80dc383ff6383..ac3ed046196a6 100644
--- a/solution/1800-1899/1865.Finding Pairs With a Certain Sum/README.md
+++ b/solution/1800-1899/1865.Finding Pairs With a Certain Sum/README.md
@@ -273,6 +273,52 @@ class FindSumPairs {
*/
```
+#### Rust
+
+```rust
+use std::collections::HashMap;
+
+struct FindSumPairs {
+ nums1: Vec,
+ nums2: Vec,
+ cnt: HashMap,
+}
+
+impl FindSumPairs {
+ fn new(nums1: Vec, nums2: Vec) -> Self {
+ let mut cnt = HashMap::new();
+ for &x in &nums2 {
+ *cnt.entry(x).or_insert(0) += 1;
+ }
+ Self { nums1, nums2, cnt }
+ }
+
+ fn add(&mut self, index: i32, val: i32) {
+ let i = index as usize;
+ let old_val = self.nums2[i];
+ *self.cnt.entry(old_val).or_insert(0) -= 1;
+ if self.cnt[&old_val] == 0 {
+ self.cnt.remove(&old_val);
+ }
+
+ self.nums2[i] += val;
+ let new_val = self.nums2[i];
+ *self.cnt.entry(new_val).or_insert(0) += 1;
+ }
+
+ fn count(&self, tot: i32) -> i32 {
+ let mut ans = 0;
+ for &x in &self.nums1 {
+ let target = tot - x;
+ if let Some(&c) = self.cnt.get(&target) {
+ ans += c;
+ }
+ }
+ ans
+ }
+}
+```
+
#### JavaScript
```js
diff --git a/solution/1800-1899/1865.Finding Pairs With a Certain Sum/README_EN.md b/solution/1800-1899/1865.Finding Pairs With a Certain Sum/README_EN.md
index 37f4847d8a54f..d232604af2812 100644
--- a/solution/1800-1899/1865.Finding Pairs With a Certain Sum/README_EN.md
+++ b/solution/1800-1899/1865.Finding Pairs With a Certain Sum/README_EN.md
@@ -271,6 +271,52 @@ class FindSumPairs {
*/
```
+#### Rust
+
+```rust
+use std::collections::HashMap;
+
+struct FindSumPairs {
+ nums1: Vec,
+ nums2: Vec,
+ cnt: HashMap,
+}
+
+impl FindSumPairs {
+ fn new(nums1: Vec, nums2: Vec) -> Self {
+ let mut cnt = HashMap::new();
+ for &x in &nums2 {
+ *cnt.entry(x).or_insert(0) += 1;
+ }
+ Self { nums1, nums2, cnt }
+ }
+
+ fn add(&mut self, index: i32, val: i32) {
+ let i = index as usize;
+ let old_val = self.nums2[i];
+ *self.cnt.entry(old_val).or_insert(0) -= 1;
+ if self.cnt[&old_val] == 0 {
+ self.cnt.remove(&old_val);
+ }
+
+ self.nums2[i] += val;
+ let new_val = self.nums2[i];
+ *self.cnt.entry(new_val).or_insert(0) += 1;
+ }
+
+ fn count(&self, tot: i32) -> i32 {
+ let mut ans = 0;
+ for &x in &self.nums1 {
+ let target = tot - x;
+ if let Some(&c) = self.cnt.get(&target) {
+ ans += c;
+ }
+ }
+ ans
+ }
+}
+```
+
#### JavaScript
```js
diff --git a/solution/1800-1899/1865.Finding Pairs With a Certain Sum/Solution.rs b/solution/1800-1899/1865.Finding Pairs With a Certain Sum/Solution.rs
new file mode 100644
index 0000000000000..336e1c5147d81
--- /dev/null
+++ b/solution/1800-1899/1865.Finding Pairs With a Certain Sum/Solution.rs
@@ -0,0 +1,41 @@
+use std::collections::HashMap;
+
+struct FindSumPairs {
+ nums1: Vec,
+ nums2: Vec,
+ cnt: HashMap,
+}
+
+impl FindSumPairs {
+ fn new(nums1: Vec, nums2: Vec) -> Self {
+ let mut cnt = HashMap::new();
+ for &x in &nums2 {
+ *cnt.entry(x).or_insert(0) += 1;
+ }
+ Self { nums1, nums2, cnt }
+ }
+
+ fn add(&mut self, index: i32, val: i32) {
+ let i = index as usize;
+ let old_val = self.nums2[i];
+ *self.cnt.entry(old_val).or_insert(0) -= 1;
+ if self.cnt[&old_val] == 0 {
+ self.cnt.remove(&old_val);
+ }
+
+ self.nums2[i] += val;
+ let new_val = self.nums2[i];
+ *self.cnt.entry(new_val).or_insert(0) += 1;
+ }
+
+ fn count(&self, tot: i32) -> i32 {
+ let mut ans = 0;
+ for &x in &self.nums1 {
+ let target = tot - x;
+ if let Some(&c) = self.cnt.get(&target) {
+ ans += c;
+ }
+ }
+ ans
+ }
+}
diff --git a/solution/1800-1899/1872.Stone Game VIII/README_EN.md b/solution/1800-1899/1872.Stone Game VIII/README_EN.md
index fc84b32817c0f..db273764cb33b 100644
--- a/solution/1800-1899/1872.Stone Game VIII/README_EN.md
+++ b/solution/1800-1899/1872.Stone Game VIII/README_EN.md
@@ -27,9 +27,13 @@ tags:
There are n stones arranged in a row. On each player's turn, while the number of stones is more than one, they will do the following:
- - Choose an integer
x > 1, and remove the leftmost x stones from the row.
- - Add the sum of the removed stones' values to the player's score.
- - Place a new stone, whose value is equal to that sum, on the left side of the row.
+
+ - Choose an integer
x > 1, and remove the leftmost x stones from the row.
+
+ - Add the sum of the removed stones' values to the player's score.
+
+ - Place a new stone, whose value is equal to that sum, on the left side of the row.
+
The game stops when only one stone is left in the row.
@@ -39,48 +43,77 @@ tags:
Given an integer array stones of length n where stones[i] represents the value of the ith stone from the left, return the score difference between Alice and Bob if they both play optimally.
+
Example 1:
+
Input: stones = [-1,2,-3,4,-5]
+
Output: 5
+
Explanation:
+
- Alice removes the first 4 stones, adds (-1) + 2 + (-3) + 4 = 2 to her score, and places a stone of
+
value 2 on the left. stones = [2,-5].
+
- Bob removes the first 2 stones, adds 2 + (-5) = -3 to his score, and places a stone of value -3 on
+
the left. stones = [-3].
+
The difference between their scores is 2 - (-3) = 5.
+
Example 2:
+
Input: stones = [7,-6,5,10,5,-2,-6]
+
Output: 13
+
Explanation:
+
- Alice removes all stones, adds 7 + (-6) + 5 + 10 + 5 + (-2) + (-6) = 13 to her score, and places a
+
stone of value 13 on the left. stones = [13].
+
The difference between their scores is 13 - 0 = 13.
+
Example 3:
+
Input: stones = [-10,-12]
+
Output: -22
+
Explanation:
+
- Alice can only make one move, which is to remove both stones. She adds (-10) + (-12) = -22 to her
+
score and places a stone of value -22 on the left. stones = [-22].
+
The difference between their scores is (-22) - 0 = -22.
+
+
Constraints:
- n == stones.length2 <= n <= 105-104 <= stones[i] <= 104n == stones.length2 <= n <= 105-104 <= stones[i] <= 104
diff --git a/solution/1800-1899/1874.Minimize Product Sum of Two Arrays/README_EN.md b/solution/1800-1899/1874.Minimize Product Sum of Two Arrays/README_EN.md
index a072d1144acd3..f4db46805a1ca 100644
--- a/solution/1800-1899/1874.Minimize Product Sum of Two Arrays/README_EN.md
+++ b/solution/1800-1899/1874.Minimize Product Sum of Two Arrays/README_EN.md
@@ -21,35 +21,51 @@ tags:
The product sum of two equal-length arrays a and b is equal to the sum of a[i] * b[i] for all 0 <= i < a.length (0-indexed).
- - For example, if
a = [1,2,3,4] and b = [5,2,3,1], the product sum would be 1*5 + 2*2 + 3*3 + 4*1 = 22.
+
+ - For example, if
a = [1,2,3,4] and b = [5,2,3,1], the product sum would be 1*5 + 2*2 + 3*3 + 4*1 = 22.
+
Given two arrays nums1 and nums2 of length n, return the minimum product sum if you are allowed to rearrange the order of the elements in nums1.
+
Example 1:
+
Input: nums1 = [5,3,4,2], nums2 = [4,2,2,5]
+
Output: 40
+
Explanation: We can rearrange nums1 to become [3,5,4,2]. The product sum of [3,5,4,2] and [4,2,2,5] is 3*4 + 5*2 + 4*2 + 2*5 = 40.
+
Example 2:
+
Input: nums1 = [2,1,4,5,7], nums2 = [3,2,4,8,6]
+
Output: 65
+
Explanation: We can rearrange nums1 to become [5,7,4,1,2]. The product sum of [5,7,4,1,2] and [3,2,4,8,6] is 5*3 + 7*2 + 4*4 + 1*8 + 2*6 = 65.
+
+
Constraints:
- n == nums1.length == nums2.length1 <= n <= 1051 <= nums1[i], nums2[i] <= 100n == nums1.length == nums2.length1 <= n <= 1051 <= nums1[i], nums2[i] <= 100
diff --git a/solution/1800-1899/1877.Minimize Maximum Pair Sum in Array/README_EN.md b/solution/1800-1899/1877.Minimize Maximum Pair Sum in Array/README_EN.md
index 929c483956728..4e50827246f87 100644
--- a/solution/1800-1899/1877.Minimize Maximum Pair Sum in Array/README_EN.md
+++ b/solution/1800-1899/1877.Minimize Maximum Pair Sum in Array/README_EN.md
@@ -24,45 +24,67 @@ tags:
The pair sum of a pair (a,b) is equal to a + b. The maximum pair sum is the largest pair sum in a list of pairs.
- - For example, if we have pairs
(1,5), (2,3), and (4,4), the maximum pair sum would be max(1+5, 2+3, 4+4) = max(6, 5, 8) = 8.
+
+ - For example, if we have pairs
(1,5), (2,3), and (4,4), the maximum pair sum would be max(1+5, 2+3, 4+4) = max(6, 5, 8) = 8.
+
Given an array nums of even length n, pair up the elements of nums into n / 2 pairs such that:
- - Each element of
nums is in exactly one pair, and
- - The maximum pair sum is minimized.
+
+ - Each element of
nums is in exactly one pair, and
+
+ - The maximum pair sum is minimized.
+
Return the minimized maximum pair sum after optimally pairing up the elements.
+
Example 1:
+
Input: nums = [3,5,2,3]
+
Output: 7
+
Explanation: The elements can be paired up into pairs (3,3) and (5,2).
+
The maximum pair sum is max(3+3, 5+2) = max(6, 7) = 7.
+
Example 2:
+
Input: nums = [3,5,4,2,4,6]
+
Output: 8
+
Explanation: The elements can be paired up into pairs (3,5), (4,4), and (6,2).
+
The maximum pair sum is max(3+5, 4+4, 6+2) = max(8, 8, 8) = 8.
+
+
Constraints:
- n == nums.length2 <= n <= 105n is even.1 <= nums[i] <= 105n == nums.length2 <= n <= 105n is even.1 <= nums[i] <= 105
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/1911.Maximum Alternating Subsequence Sum/README_EN.md b/solution/1900-1999/1911.Maximum Alternating Subsequence Sum/README_EN.md
index ecc7532e55269..76cda62341188 100644
--- a/solution/1900-1999/1911.Maximum Alternating Subsequence Sum/README_EN.md
+++ b/solution/1900-1999/1911.Maximum Alternating Subsequence Sum/README_EN.md
@@ -22,47 +22,67 @@ tags:
The alternating sum of a 0-indexed array is defined as the sum of the elements at even indices minus the sum of the elements at odd indices.
- - For example, the alternating sum of
[4,2,5,3] is (4 + 5) - (2 + 3) = 4.
+
+ - For example, the alternating sum of
[4,2,5,3] is (4 + 5) - (2 + 3) = 4.
+
Given an array nums, return the maximum alternating sum of any subsequence of nums (after reindexing the elements of the subsequence).
A subsequence of an array is a new array generated from the original array by deleting some elements (possibly none) without changing the remaining elements' relative order. For example, [2,7,4] is a subsequence of [4,2,3,7,2,1,4] (the underlined elements), while [2,4,2] is not.
+
Example 1:
+
Input: nums = [4,2,5,3]
+
Output: 7
+
Explanation: It is optimal to choose the subsequence [4,2,5] with alternating sum (4 + 5) - 2 = 7.
+
Example 2:
+
Input: nums = [5,6,7,8]
+
Output: 8
+
Explanation: It is optimal to choose the subsequence [8] with alternating sum 8.
+
Example 3:
+
Input: nums = [6,2,1,2,4,5]
+
Output: 10
+
Explanation: It is optimal to choose the subsequence [6,1,5] with alternating sum (6 + 5) - 1 = 10.
+
+
Constraints:
- 1 <= nums.length <= 1051 <= nums[i] <= 1051 <= nums.length <= 1051 <= nums[i] <= 105
diff --git a/solution/1900-1999/1913.Maximum Product Difference Between Two Pairs/README_EN.md b/solution/1900-1999/1913.Maximum Product Difference Between Two Pairs/README_EN.md
index de2987a86b5c6..806f7cb640d4f 100644
--- a/solution/1900-1999/1913.Maximum Product Difference Between Two Pairs/README_EN.md
+++ b/solution/1900-1999/1913.Maximum Product Difference Between Two Pairs/README_EN.md
@@ -22,7 +22,9 @@ tags:
The product difference between two pairs (a, b) and (c, d) is defined as (a * b) - (c * d).
- - For example, the product difference between
(5, 6) and (2, 7) is (5 * 6) - (2 * 7) = 16.
+
+ - For example, the product difference between
(5, 6) and (2, 7) is (5 * 6) - (2 * 7) = 16.
+
Given an integer array nums, choose four distinct indices w, x, y, and z such that the product difference between pairs (nums[w], nums[x]) and (nums[y], nums[z]) is maximized.
@@ -30,30 +32,45 @@ tags:
Return the maximum such product difference.
+
Example 1:
+
Input: nums = [5,6,2,7,4]
+
Output: 34
+
Explanation: We can choose indices 1 and 3 for the first pair (6, 7) and indices 2 and 4 for the second pair (2, 4).
+
The product difference is (6 * 7) - (2 * 4) = 34.
+
Example 2:
+
Input: nums = [4,2,5,9,7,4,8]
+
Output: 64
+
Explanation: We can choose indices 3 and 6 for the first pair (9, 8) and indices 1 and 5 for the second pair (2, 4).
+
The product difference is (9 * 8) - (2 * 4) = 64.
+
+
Constraints:
- 4 <= nums.length <= 1041 <= nums[i] <= 1044 <= nums.length <= 1041 <= nums[i] <= 104
diff --git a/solution/1900-1999/1914.Cyclically Rotating a Grid/README_EN.md b/solution/1900-1999/1914.Cyclically Rotating a Grid/README_EN.md
index fae78135d2d47..2b5a5d14a34c7 100644
--- a/solution/1900-1999/1914.Cyclically Rotating a Grid/README_EN.md
+++ b/solution/1900-1999/1914.Cyclically Rotating a Grid/README_EN.md
@@ -27,37 +27,59 @@ tags:
A cyclic rotation of the matrix is done by cyclically rotating each layer in the matrix. To cyclically rotate a layer once, each element in the layer will take the place of the adjacent element in the counter-clockwise direction. An example rotation is shown below:
+
+
Return the matrix after applying k cyclic rotations to it.
+
Example 1:
+
+
+
Input: grid = [[40,10],[30,20]], k = 1
+
Output: [[10,20],[40,30]]
+
Explanation: The figures above represent the grid at every state.
+
Example 2:
+
+
Input: grid = [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]], k = 2
+
Output: [[3,4,8,12],[2,11,10,16],[1,7,6,15],[5,9,13,14]]
+
Explanation: The figures above represent the grid at every state.
+
+
Constraints:
- m == grid.lengthn == grid[i].length2 <= m, n <= 50- Both
m and n are even integers.
- 1 <= grid[i][j] <= 50001 <= k <= 109m == grid.lengthn == grid[i].length2 <= m, n <= 50- Both
m and n are even integers.
+
+ 1 <= grid[i][j] <= 50001 <= k <= 109
diff --git a/solution/1900-1999/1915.Number of Wonderful Substrings/README_EN.md b/solution/1900-1999/1915.Number of Wonderful Substrings/README_EN.md
index 1db1ec7914388..e6048268f5cc4 100644
--- a/solution/1900-1999/1915.Number of Wonderful Substrings/README_EN.md
+++ b/solution/1900-1999/1915.Number of Wonderful Substrings/README_EN.md
@@ -24,7 +24,9 @@ tags:
A wonderful string is a string where at most one letter appears an odd number of times.
- - For example,
"ccjjc" and "abab" are wonderful, but "ab" is not.
+
+ - For example,
"ccjjc" and "abab" are wonderful, but "ab" is not.
+
Given a string word that consists of the first ten lowercase English letters ('a' through 'j'), return the number of wonderful non-empty substrings in word. If the same substring appears multiple times in word, then count each occurrence separately.
@@ -32,51 +34,83 @@ tags:
A substring is a contiguous sequence of characters in a string.
+
Example 1:
+
Input: word = "aba"
+
Output: 4
+
Explanation: The four wonderful substrings are underlined below:
+
- "aba" -> "a"
+
- "aba" -> "b"
+
- "aba" -> "a"
+
- "aba" -> "aba"
+
Example 2:
+
Input: word = "aabb"
+
Output: 9
+
Explanation: The nine wonderful substrings are underlined below:
+
- "aabb" -> "a"
+
- "aabb" -> "aa"
+
- "aabb" -> "aab"
+
- "aabb" -> "aabb"
+
- "aabb" -> "a"
+
- "aabb" -> "abb"
+
- "aabb" -> "b"
+
- "aabb" -> "bb"
+
- "aabb" -> "b"
+
Example 3:
+
Input: word = "he"
+
Output: 2
+
Explanation: The two wonderful substrings are underlined below:
+
- "he" -> "h"
+
- "he" -> "e"
+
+
Constraints:
- 1 <= word.length <= 105word consists of lowercase English letters from 'a' to 'j'.1 <= word.length <= 105word consists of lowercase English letters from 'a' to 'j'.
diff --git a/solution/1900-1999/1916.Count Ways to Build Rooms in an Ant Colony/README_EN.md b/solution/1900-1999/1916.Count Ways to Build Rooms in an Ant Colony/README_EN.md
index 08e8d9fb13bfc..f306ec994eb05 100644
--- a/solution/1900-1999/1916.Count Ways to Build Rooms in an Ant Colony/README_EN.md
+++ b/solution/1900-1999/1916.Count Ways to Build Rooms in an Ant Colony/README_EN.md
@@ -30,39 +30,65 @@ tags:
Return the number of different orders you can build all the rooms in. Since the answer may be large, return it modulo 109 + 7.
+
Example 1:
+
+
+
Input: prevRoom = [-1,0,1]
+
Output: 1
+
Explanation: There is only one way to build the additional rooms: 0 → 1 → 2
+
Example 2:
+
+
Input: prevRoom = [-1,0,0,1,2]
+
Output: 6
+
Explanation:
+
The 6 ways are:
+
0 → 1 → 3 → 2 → 4
+
0 → 2 → 4 → 1 → 3
+
0 → 1 → 2 → 3 → 4
+
0 → 1 → 2 → 4 → 3
+
0 → 2 → 1 → 3 → 4
+
0 → 2 → 1 → 4 → 3
+
+
Constraints:
- n == prevRoom.length2 <= n <= 105prevRoom[0] == -10 <= prevRoom[i] < n for all 1 <= i < n- Every room is reachable from room
0 once all the rooms are built.
+
+ n == prevRoom.length2 <= n <= 105prevRoom[0] == -10 <= prevRoom[i] < n for all 1 <= i < n- Every room is reachable from room
0 once all the rooms are built.
+
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/2014.Longest Subsequence Repeated k Times/README.md b/solution/2000-2099/2014.Longest Subsequence Repeated k Times/README.md
index 971cc3b505454..d81ae7e9f1c02 100644
--- a/solution/2000-2099/2014.Longest Subsequence Repeated k Times/README.md
+++ b/solution/2000-2099/2014.Longest Subsequence Repeated k Times/README.md
@@ -70,7 +70,7 @@ tags:
n == s.length2 <= k <= 20002 <= n < k * 82 <= n < min(2001, k * 8)s 由小写英文字母组成
@@ -80,32 +80,250 @@ tags:
-### 方法一
+### 方法一：BFS
+
+我们可以先统计字符串中每个字符出现的次数，然后将出现次数大于等于 $k$ 的字符按从小到大的顺序存入一个列表 $\textit{cs}$ 中。接下来，我们可以使用 BFS 来枚举所有可能的子序列。
+
+我们定义一个队列 $\textit{q}$，初始时将空字符串放入队列中。然后，我们从队列中取出一个字符串 $\textit{cur}$，并尝试将每个字符 $c \in \textit{cs}$ 添加到 $\textit{cur}$ 的末尾，形成一个新的字符串 $\textit{nxt}$。如果 $\textit{nxt}$ 是一个重复 $k$ 次的子序列，我们就将其加入到答案中，并将 $\textit{nxt}$ 放入队列中继续处理。
+
+我们需要一个辅助函数 $\textit{check(t, k)}$ 来判断字符串 $\textit{t}$ 是否是字符串 $s$ 的一个重复 $k$ 次的子序列。具体地，我们可以使用两个指针来遍历字符串 $s$ 和 $\textit{t}$，如果在遍历过程中能够找到 $\textit{t}$ 的所有字符，并且能够重复 $k$ 次，那么就返回 $\textit{true}$，否则返回 $\textit{false}$。
#### Python3
```python
-
+class Solution:
+ def longestSubsequenceRepeatedK(self, s: str, k: int) -> str:
+ def check(t: str, k: int) -> bool:
+ i = 0
+ for c in s:
+ if c == t[i]:
+ i += 1
+ if i == len(t):
+ k -= 1
+ if k == 0:
+ return True
+ i = 0
+ return False
+
+ cnt = Counter(s)
+ cs = [c for c in ascii_lowercase if cnt[c] >= k]
+ q = deque([""])
+ ans = ""
+ while q:
+ cur = q.popleft()
+ for c in cs:
+ nxt = cur + c
+ if check(nxt, k):
+ ans = nxt
+ q.append(nxt)
+ return ans
```
#### Java
```java
-
+class Solution {
+ private char[] s;
+
+ public String longestSubsequenceRepeatedK(String s, int k) {
+ this.s = s.toCharArray();
+ int[] cnt = new int[26];
+ for (char c : this.s) {
+ cnt[c - 'a']++;
+ }
+
+ List cs = new ArrayList<>();
+ for (char c = 'a'; c <= 'z'; ++c) {
+ if (cnt[c - 'a'] >= k) {
+ cs.add(c);
+ }
+ }
+ Deque q = new ArrayDeque<>();
+ q.offer("");
+ String ans = "";
+ while (!q.isEmpty()) {
+ String cur = q.poll();
+ for (char c : cs) {
+ String nxt = cur + c;
+ if (check(nxt, k)) {
+ ans = nxt;
+ q.offer(nxt);
+ }
+ }
+ }
+ return ans;
+ }
+
+ private boolean check(String t, int k) {
+ int i = 0;
+ for (char c : s) {
+ if (c == t.charAt(i)) {
+ i++;
+ if (i == t.length()) {
+ if (--k == 0) {
+ return true;
+ }
+ i = 0;
+ }
+ }
+ }
+ return false;
+ }
+}
```
#### C++
```cpp
-
+class Solution {
+public:
+ string longestSubsequenceRepeatedK(string s, int k) {
+ auto check = [&](const string& t, int k) -> bool {
+ int i = 0;
+ for (char c : s) {
+ if (c == t[i]) {
+ i++;
+ if (i == t.size()) {
+ if (--k == 0) {
+ return true;
+ }
+ i = 0;
+ }
+ }
+ }
+ return false;
+ };
+ int cnt[26] = {};
+ for (char c : s) {
+ cnt[c - 'a']++;
+ }
+
+ vector cs;
+ for (char c = 'a'; c <= 'z'; ++c) {
+ if (cnt[c - 'a'] >= k) {
+ cs.push_back(c);
+ }
+ }
+
+ queue q;
+ q.push("");
+ string ans;
+ while (!q.empty()) {
+ string cur = q.front();
+ q.pop();
+ for (char c : cs) {
+ string nxt = cur + c;
+ if (check(nxt, k)) {
+ ans = nxt;
+ q.push(nxt);
+ }
+ }
+ }
+ return ans;
+ }
+};
```
#### Go
```go
+func longestSubsequenceRepeatedK(s string, k int) string {
+ check := func(t string, k int) bool {
+ i := 0
+ for _, c := range s {
+ if byte(c) == t[i] {
+ i++
+ if i == len(t) {
+ k--
+ if k == 0 {
+ return true
+ }
+ i = 0
+ }
+ }
+ }
+ return false
+ }
+
+ cnt := [26]int{}
+ for i := 0; i < len(s); i++ {
+ cnt[s[i]-'a']++
+ }
+
+ cs := []byte{}
+ for c := byte('a'); c <= 'z'; c++ {
+ if cnt[c-'a'] >= k {
+ cs = append(cs, c)
+ }
+ }
+
+ q := []string{""}
+ ans := ""
+ for len(q) > 0 {
+ cur := q[0]
+ q = q[1:]
+ for _, c := range cs {
+ nxt := cur + string(c)
+ if check(nxt, k) {
+ ans = nxt
+ q = append(q, nxt)
+ }
+ }
+ }
+ return ans
+}
+```
+#### TypeScript
+
+```ts
+function longestSubsequenceRepeatedK(s: string, k: number): string {
+ const check = (t: string, k: number): boolean => {
+ let i = 0;
+ for (const c of s) {
+ if (c === t[i]) {
+ i++;
+ if (i === t.length) {
+ k--;
+ if (k === 0) {
+ return true;
+ }
+ i = 0;
+ }
+ }
+ }
+ return false;
+ };
+
+ const cnt = new Array(26).fill(0);
+ for (const c of s) {
+ cnt[c.charCodeAt(0) - 97]++;
+ }
+
+ const cs: string[] = [];
+ for (let i = 0; i < 26; ++i) {
+ if (cnt[i] >= k) {
+ cs.push(String.fromCharCode(97 + i));
+ }
+ }
+
+ const q: string[] = [''];
+ let ans = '';
+ while (q.length > 0) {
+ const cur = q.shift()!;
+ for (const c of cs) {
+ const nxt = cur + c;
+ if (check(nxt, k)) {
+ ans = nxt;
+ q.push(nxt);
+ }
+ }
+ }
+
+ return ans;
+}
```
diff --git a/solution/2000-2099/2014.Longest Subsequence Repeated k Times/README_EN.md b/solution/2000-2099/2014.Longest Subsequence Repeated k Times/README_EN.md
index 31b8034b543c5..d7fd6b3fa7708 100644
--- a/solution/2000-2099/2014.Longest Subsequence Repeated k Times/README_EN.md
+++ b/solution/2000-2099/2014.Longest Subsequence Repeated k Times/README_EN.md
@@ -65,8 +65,8 @@ tags:
n == s.length2 <= n, k <= 20002 <= n < k * 82 <= k <= 20002 <= n < min(2001, k * 8)s consists of lowercase English letters.
@@ -76,32 +76,250 @@ tags:
-### Solution 1
+### Solution 1: BFS
+
+We can first count the occurrences of each character in the string, and then store the characters that appear at least $k$ times in a list $\textit{cs}$ in ascending order. Next, we can use BFS to enumerate all possible subsequences.
+
+We define a queue $\textit{q}$, initially putting the empty string into the queue. Then, we take out a string $\textit{cur}$ from the queue and try to append each character $c \in \textit{cs}$ to the end of $\textit{cur}$ to form a new string $\textit{nxt}$. If $\textit{nxt}$ is a subsequence that can be repeated $k$ times, we add it to the answer and put $\textit{nxt}$ back into the queue for further processing.
+
+We need an auxiliary function $\textit{check(t, k)}$ to determine whether the string $\textit{t}$ is a repeated $k$ times subsequence of string $s$. Specifically, we can use two pointers to traverse $s$ and $\textit{t}$. If we can find all characters of $\textit{t}$ in $s$ and repeat this process $k$ times, then return $\textit{true}$; otherwise, return $\textit{false}$.
#### Python3
```python
-
+class Solution:
+ def longestSubsequenceRepeatedK(self, s: str, k: int) -> str:
+ def check(t: str, k: int) -> bool:
+ i = 0
+ for c in s:
+ if c == t[i]:
+ i += 1
+ if i == len(t):
+ k -= 1
+ if k == 0:
+ return True
+ i = 0
+ return False
+
+ cnt = Counter(s)
+ cs = [c for c in ascii_lowercase if cnt[c] >= k]
+ q = deque([""])
+ ans = ""
+ while q:
+ cur = q.popleft()
+ for c in cs:
+ nxt = cur + c
+ if check(nxt, k):
+ ans = nxt
+ q.append(nxt)
+ return ans
```
#### Java
```java
-
+class Solution {
+ private char[] s;
+
+ public String longestSubsequenceRepeatedK(String s, int k) {
+ this.s = s.toCharArray();
+ int[] cnt = new int[26];
+ for (char c : this.s) {
+ cnt[c - 'a']++;
+ }
+
+ List cs = new ArrayList<>();
+ for (char c = 'a'; c <= 'z'; ++c) {
+ if (cnt[c - 'a'] >= k) {
+ cs.add(c);
+ }
+ }
+ Deque q = new ArrayDeque<>();
+ q.offer("");
+ String ans = "";
+ while (!q.isEmpty()) {
+ String cur = q.poll();
+ for (char c : cs) {
+ String nxt = cur + c;
+ if (check(nxt, k)) {
+ ans = nxt;
+ q.offer(nxt);
+ }
+ }
+ }
+ return ans;
+ }
+
+ private boolean check(String t, int k) {
+ int i = 0;
+ for (char c : s) {
+ if (c == t.charAt(i)) {
+ i++;
+ if (i == t.length()) {
+ if (--k == 0) {
+ return true;
+ }
+ i = 0;
+ }
+ }
+ }
+ return false;
+ }
+}
```
#### C++
```cpp
-
+class Solution {
+public:
+ string longestSubsequenceRepeatedK(string s, int k) {
+ auto check = [&](const string& t, int k) -> bool {
+ int i = 0;
+ for (char c : s) {
+ if (c == t[i]) {
+ i++;
+ if (i == t.size()) {
+ if (--k == 0) {
+ return true;
+ }
+ i = 0;
+ }
+ }
+ }
+ return false;
+ };
+ int cnt[26] = {};
+ for (char c : s) {
+ cnt[c - 'a']++;
+ }
+
+ vector cs;
+ for (char c = 'a'; c <= 'z'; ++c) {
+ if (cnt[c - 'a'] >= k) {
+ cs.push_back(c);
+ }
+ }
+
+ queue q;
+ q.push("");
+ string ans;
+ while (!q.empty()) {
+ string cur = q.front();
+ q.pop();
+ for (char c : cs) {
+ string nxt = cur + c;
+ if (check(nxt, k)) {
+ ans = nxt;
+ q.push(nxt);
+ }
+ }
+ }
+ return ans;
+ }
+};
```
#### Go
```go
+func longestSubsequenceRepeatedK(s string, k int) string {
+ check := func(t string, k int) bool {
+ i := 0
+ for _, c := range s {
+ if byte(c) == t[i] {
+ i++
+ if i == len(t) {
+ k--
+ if k == 0 {
+ return true
+ }
+ i = 0
+ }
+ }
+ }
+ return false
+ }
+
+ cnt := [26]int{}
+ for i := 0; i < len(s); i++ {
+ cnt[s[i]-'a']++
+ }
+
+ cs := []byte{}
+ for c := byte('a'); c <= 'z'; c++ {
+ if cnt[c-'a'] >= k {
+ cs = append(cs, c)
+ }
+ }
+
+ q := []string{""}
+ ans := ""
+ for len(q) > 0 {
+ cur := q[0]
+ q = q[1:]
+ for _, c := range cs {
+ nxt := cur + string(c)
+ if check(nxt, k) {
+ ans = nxt
+ q = append(q, nxt)
+ }
+ }
+ }
+ return ans
+}
+```
+#### TypeScript
+
+```ts
+function longestSubsequenceRepeatedK(s: string, k: number): string {
+ const check = (t: string, k: number): boolean => {
+ let i = 0;
+ for (const c of s) {
+ if (c === t[i]) {
+ i++;
+ if (i === t.length) {
+ k--;
+ if (k === 0) {
+ return true;
+ }
+ i = 0;
+ }
+ }
+ }
+ return false;
+ };
+
+ const cnt = new Array(26).fill(0);
+ for (const c of s) {
+ cnt[c.charCodeAt(0) - 97]++;
+ }
+
+ const cs: string[] = [];
+ for (let i = 0; i < 26; ++i) {
+ if (cnt[i] >= k) {
+ cs.push(String.fromCharCode(97 + i));
+ }
+ }
+
+ const q: string[] = [''];
+ let ans = '';
+ while (q.length > 0) {
+ const cur = q.shift()!;
+ for (const c of cs) {
+ const nxt = cur + c;
+ if (check(nxt, k)) {
+ ans = nxt;
+ q.push(nxt);
+ }
+ }
+ }
+
+ return ans;
+}
```
diff --git a/solution/2000-2099/2014.Longest Subsequence Repeated k Times/Solution.cpp b/solution/2000-2099/2014.Longest Subsequence Repeated k Times/Solution.cpp
new file mode 100644
index 0000000000000..8a7ad8569e9ca
--- /dev/null
+++ b/solution/2000-2099/2014.Longest Subsequence Repeated k Times/Solution.cpp
@@ -0,0 +1,47 @@
+class Solution {
+public:
+ string longestSubsequenceRepeatedK(string s, int k) {
+ auto check = [&](const string& t, int k) -> bool {
+ int i = 0;
+ for (char c : s) {
+ if (c == t[i]) {
+ i++;
+ if (i == t.size()) {
+ if (--k == 0) {
+ return true;
+ }
+ i = 0;
+ }
+ }
+ }
+ return false;
+ };
+ int cnt[26] = {};
+ for (char c : s) {
+ cnt[c - 'a']++;
+ }
+
+ vector cs;
+ for (char c = 'a'; c <= 'z'; ++c) {
+ if (cnt[c - 'a'] >= k) {
+ cs.push_back(c);
+ }
+ }
+
+ queue q;
+ q.push("");
+ string ans;
+ while (!q.empty()) {
+ string cur = q.front();
+ q.pop();
+ for (char c : cs) {
+ string nxt = cur + c;
+ if (check(nxt, k)) {
+ ans = nxt;
+ q.push(nxt);
+ }
+ }
+ }
+ return ans;
+ }
+};
diff --git a/solution/2000-2099/2014.Longest Subsequence Repeated k Times/Solution.go b/solution/2000-2099/2014.Longest Subsequence Repeated k Times/Solution.go
new file mode 100644
index 0000000000000..9aebe716c2c08
--- /dev/null
+++ b/solution/2000-2099/2014.Longest Subsequence Repeated k Times/Solution.go
@@ -0,0 +1,45 @@
+func longestSubsequenceRepeatedK(s string, k int) string {
+ check := func(t string, k int) bool {
+ i := 0
+ for _, c := range s {
+ if byte(c) == t[i] {
+ i++
+ if i == len(t) {
+ k--
+ if k == 0 {
+ return true
+ }
+ i = 0
+ }
+ }
+ }
+ return false
+ }
+
+ cnt := [26]int{}
+ for i := 0; i < len(s); i++ {
+ cnt[s[i]-'a']++
+ }
+
+ cs := []byte{}
+ for c := byte('a'); c <= 'z'; c++ {
+ if cnt[c-'a'] >= k {
+ cs = append(cs, c)
+ }
+ }
+
+ q := []string{""}
+ ans := ""
+ for len(q) > 0 {
+ cur := q[0]
+ q = q[1:]
+ for _, c := range cs {
+ nxt := cur + string(c)
+ if check(nxt, k) {
+ ans = nxt
+ q = append(q, nxt)
+ }
+ }
+ }
+ return ans
+}
diff --git a/solution/2000-2099/2014.Longest Subsequence Repeated k Times/Solution.java b/solution/2000-2099/2014.Longest Subsequence Repeated k Times/Solution.java
new file mode 100644
index 0000000000000..11573eda7c6ee
--- /dev/null
+++ b/solution/2000-2099/2014.Longest Subsequence Repeated k Times/Solution.java
@@ -0,0 +1,48 @@
+class Solution {
+ private char[] s;
+
+ public String longestSubsequenceRepeatedK(String s, int k) {
+ this.s = s.toCharArray();
+ int[] cnt = new int[26];
+ for (char c : this.s) {
+ cnt[c - 'a']++;
+ }
+
+ List cs = new ArrayList<>();
+ for (char c = 'a'; c <= 'z'; ++c) {
+ if (cnt[c - 'a'] >= k) {
+ cs.add(c);
+ }
+ }
+ Deque q = new ArrayDeque<>();
+ q.offer("");
+ String ans = "";
+ while (!q.isEmpty()) {
+ String cur = q.poll();
+ for (char c : cs) {
+ String nxt = cur + c;
+ if (check(nxt, k)) {
+ ans = nxt;
+ q.offer(nxt);
+ }
+ }
+ }
+ return ans;
+ }
+
+ private boolean check(String t, int k) {
+ int i = 0;
+ for (char c : s) {
+ if (c == t.charAt(i)) {
+ i++;
+ if (i == t.length()) {
+ if (--k == 0) {
+ return true;
+ }
+ i = 0;
+ }
+ }
+ }
+ return false;
+ }
+}
\ No newline at end of file
diff --git a/solution/2000-2099/2014.Longest Subsequence Repeated k Times/Solution.py b/solution/2000-2099/2014.Longest Subsequence Repeated k Times/Solution.py
new file mode 100644
index 0000000000000..fdb26b136fcb3
--- /dev/null
+++ b/solution/2000-2099/2014.Longest Subsequence Repeated k Times/Solution.py
@@ -0,0 +1,26 @@
+class Solution:
+ def longestSubsequenceRepeatedK(self, s: str, k: int) -> str:
+ def check(t: str, k: int) -> bool:
+ i = 0
+ for c in s:
+ if c == t[i]:
+ i += 1
+ if i == len(t):
+ k -= 1
+ if k == 0:
+ return True
+ i = 0
+ return False
+
+ cnt = Counter(s)
+ cs = [c for c in ascii_lowercase if cnt[c] >= k]
+ q = deque([""])
+ ans = ""
+ while q:
+ cur = q.popleft()
+ for c in cs:
+ nxt = cur + c
+ if check(nxt, k):
+ ans = nxt
+ q.append(nxt)
+ return ans
diff --git a/solution/2000-2099/2014.Longest Subsequence Repeated k Times/Solution.ts b/solution/2000-2099/2014.Longest Subsequence Repeated k Times/Solution.ts
new file mode 100644
index 0000000000000..1c93ee58da115
--- /dev/null
+++ b/solution/2000-2099/2014.Longest Subsequence Repeated k Times/Solution.ts
@@ -0,0 +1,45 @@
+function longestSubsequenceRepeatedK(s: string, k: number): string {
+ const check = (t: string, k: number): boolean => {
+ let i = 0;
+ for (const c of s) {
+ if (c === t[i]) {
+ i++;
+ if (i === t.length) {
+ k--;
+ if (k === 0) {
+ return true;
+ }
+ i = 0;
+ }
+ }
+ }
+ return false;
+ };
+
+ const cnt = new Array(26).fill(0);
+ for (const c of s) {
+ cnt[c.charCodeAt(0) - 97]++;
+ }
+
+ const cs: string[] = [];
+ for (let i = 0; i < 26; ++i) {
+ if (cnt[i] >= k) {
+ cs.push(String.fromCharCode(97 + i));
+ }
+ }
+
+ const q: string[] = [''];
+ let ans = '';
+ while (q.length > 0) {
+ const cur = q.shift()!;
+ for (const c of cs) {
+ const nxt = cur + c;
+ if (check(nxt, k)) {
+ ans = nxt;
+ q.push(nxt);
+ }
+ }
+ }
+
+ return ans;
+}
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/2040.Kth Smallest Product of Two Sorted Arrays/README.md b/solution/2000-2099/2040.Kth Smallest Product of Two Sorted Arrays/README.md
index ac5d851b018b6..cddb788d2dafe 100644
--- a/solution/2000-2099/2040.Kth Smallest Product of Two Sorted Arrays/README.md
+++ b/solution/2000-2099/2040.Kth Smallest Product of Two Sorted Arrays/README.md
@@ -356,6 +356,65 @@ function kthSmallestProduct(nums1: number[], nums2: number[], k: number): number
}
```
+#### Rust
+
+```rust
+impl Solution {
+ pub fn kth_smallest_product(nums1: Vec, nums2: Vec, k: i64) -> i64 {
+ let m = nums1.len();
+ let n = nums2.len();
+ let a = nums1[0].abs().max(nums1[m - 1].abs()) as i64;
+ let b = nums2[0].abs().max(nums2[n - 1].abs()) as i64;
+ let mut l = -a * b;
+ let mut r = a * b;
+
+ let count = |p: i64| -> i64 {
+ let mut cnt = 0i64;
+ for &x in &nums1 {
+ if x > 0 {
+ let mut left = 0;
+ let mut right = n;
+ while left < right {
+ let mid = (left + right) / 2;
+ if (x as i64) * (nums2[mid] as i64) > p {
+ right = mid;
+ } else {
+ left = mid + 1;
+ }
+ }
+ cnt += left as i64;
+ } else if x < 0 {
+ let mut left = 0;
+ let mut right = n;
+ while left < right {
+ let mid = (left + right) / 2;
+ if (x as i64) * (nums2[mid] as i64) <= p {
+ right = mid;
+ } else {
+ left = mid + 1;
+ }
+ }
+ cnt += (n - left) as i64;
+ } else if p >= 0 {
+ cnt += n as i64;
+ }
+ }
+ cnt
+ };
+
+ while l < r {
+ let mid = l + (r - l) / 2;
+ if count(mid) >= k {
+ r = mid;
+ } else {
+ l = mid + 1;
+ }
+ }
+ l
+ }
+}
+```
+
diff --git a/solution/2000-2099/2040.Kth Smallest Product of Two Sorted Arrays/README_EN.md b/solution/2000-2099/2040.Kth Smallest Product of Two Sorted Arrays/README_EN.md
index 97650014c80a7..37e3102aa44e6 100644
--- a/solution/2000-2099/2040.Kth Smallest Product of Two Sorted Arrays/README_EN.md
+++ b/solution/2000-2099/2040.Kth Smallest Product of Two Sorted Arrays/README_EN.md
@@ -357,6 +357,65 @@ function kthSmallestProduct(nums1: number[], nums2: number[], k: number): number
}
```
+#### Rust
+
+```rust
+impl Solution {
+ pub fn kth_smallest_product(nums1: Vec, nums2: Vec, k: i64) -> i64 {
+ let m = nums1.len();
+ let n = nums2.len();
+ let a = nums1[0].abs().max(nums1[m - 1].abs()) as i64;
+ let b = nums2[0].abs().max(nums2[n - 1].abs()) as i64;
+ let mut l = -a * b;
+ let mut r = a * b;
+
+ let count = |p: i64| -> i64 {
+ let mut cnt = 0i64;
+ for &x in &nums1 {
+ if x > 0 {
+ let mut left = 0;
+ let mut right = n;
+ while left < right {
+ let mid = (left + right) / 2;
+ if (x as i64) * (nums2[mid] as i64) > p {
+ right = mid;
+ } else {
+ left = mid + 1;
+ }
+ }
+ cnt += left as i64;
+ } else if x < 0 {
+ let mut left = 0;
+ let mut right = n;
+ while left < right {
+ let mid = (left + right) / 2;
+ if (x as i64) * (nums2[mid] as i64) <= p {
+ right = mid;
+ } else {
+ left = mid + 1;
+ }
+ }
+ cnt += (n - left) as i64;
+ } else if p >= 0 {
+ cnt += n as i64;
+ }
+ }
+ cnt
+ };
+
+ while l < r {
+ let mid = l + (r - l) / 2;
+ if count(mid) >= k {
+ r = mid;
+ } else {
+ l = mid + 1;
+ }
+ }
+ l
+ }
+}
+```
+
diff --git a/solution/2000-2099/2040.Kth Smallest Product of Two Sorted Arrays/Solution.rs b/solution/2000-2099/2040.Kth Smallest Product of Two Sorted Arrays/Solution.rs
new file mode 100644
index 0000000000000..0d312303d1ef8
--- /dev/null
+++ b/solution/2000-2099/2040.Kth Smallest Product of Two Sorted Arrays/Solution.rs
@@ -0,0 +1,54 @@
+impl Solution {
+ pub fn kth_smallest_product(nums1: Vec, nums2: Vec, k: i64) -> i64 {
+ let m = nums1.len();
+ let n = nums2.len();
+ let a = nums1[0].abs().max(nums1[m - 1].abs()) as i64;
+ let b = nums2[0].abs().max(nums2[n - 1].abs()) as i64;
+ let mut l = -a * b;
+ let mut r = a * b;
+
+ let count = |p: i64| -> i64 {
+ let mut cnt = 0i64;
+ for &x in &nums1 {
+ if x > 0 {
+ let mut left = 0;
+ let mut right = n;
+ while left < right {
+ let mid = (left + right) / 2;
+ if (x as i64) * (nums2[mid] as i64) > p {
+ right = mid;
+ } else {
+ left = mid + 1;
+ }
+ }
+ cnt += left as i64;
+ } else if x < 0 {
+ let mut left = 0;
+ let mut right = n;
+ while left < right {
+ let mid = (left + right) / 2;
+ if (x as i64) * (nums2[mid] as i64) <= p {
+ right = mid;
+ } else {
+ left = mid + 1;
+ }
+ }
+ cnt += (n - left) as i64;
+ } else if p >= 0 {
+ cnt += n as i64;
+ }
+ }
+ cnt
+ };
+
+ while l < r {
+ let mid = l + (r - l) / 2;
+ if count(mid) >= k {
+ r = mid;
+ } else {
+ l = mid + 1;
+ }
+ }
+ l
+ }
+}
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/2000-2099/2081.Sum of k-Mirror Numbers/README.md b/solution/2000-2099/2081.Sum of k-Mirror Numbers/README.md
index 53bad43650637..224a410e3d6a1 100644
--- a/solution/2000-2099/2081.Sum of k-Mirror Numbers/README.md
+++ b/solution/2000-2099/2081.Sum of k-Mirror Numbers/README.md
@@ -85,26 +85,112 @@ tags:
-### 方法一
+### 方法一：折半枚举 + 数学
+
+对于一个 k 镜像数字，我们可以将其分为两部分：前半部分和后半部分。对于偶数长度的数字，前半部分和后半部分完全相同；对于奇数长度的数字，前半部分和后半部分相同，但中间的数字可以是任意数字。
+
+我们可以通过枚举前半部分的数字，然后根据前半部分构造出完整的 k 镜像数字。具体步骤如下：
+
+1. **枚举长度**：从 1 开始枚举数字的长度，直到找到满足条件的 k 镜像数字。
+2. **计算前半部分的范围**：对于长度为 $l$ 的数字，前半部分的范围是 $[10^{(l-1)/2}, 10^{(l+1)/2})$。
+3. **构造 k 镜像数字**：对于每个前半部分的数字 $i$，如果长度为偶数，则直接将 $i$ 作为前半部分；如果长度为奇数，则将 $i$ 除以 10 得到前半部分。然后将前半部分的数字反转并添加到后半部分，构造出完整的 k 镜像数字。
+4. **检查 k 镜像数字**：将构造出的数字转换为 k 进制，检查其是否是回文数。
+5. **累加结果**：如果是 k 镜像数字，则将其累加到结果中，并减少计数器 $n$。当计数器 $n$ 减至 0 时，返回结果。
+
+时间复杂度主要取决于枚举的长度和前半部分的范围。由于 $n$ 的最大值为 30，因此在实际操作中，枚举的次数是有限的。空间复杂度 $O(1)$，因为我们只使用了常数级别的额外空间。
+#### Python3
+
+```python
+class Solution:
+ def kMirror(self, k: int, n: int) -> int:
+ def check(x: int, k: int) -> bool:
+ s = []
+ while x:
+ s.append(x % k)
+ x //= k
+ return s == s[::-1]
+
+ ans = 0
+ for l in count(1):
+ x = 10 ** ((l - 1) // 2)
+ y = 10 ** ((l + 1) // 2)
+ for i in range(x, y):
+ v = i
+ j = i if l % 2 == 0 else i // 10
+ while j > 0:
+ v = v * 10 + j % 10
+ j //= 10
+ if check(v, k):
+ ans += v
+ n -= 1
+ if n == 0:
+ return ans
+```
+
#### Java
```java
class Solution {
public long kMirror(int k, int n) {
long ans = 0;
- for (int l = 1;; ++l) {
+ for (int l = 1;; l++) {
int x = (int) Math.pow(10, (l - 1) / 2);
int y = (int) Math.pow(10, (l + 1) / 2);
for (int i = x; i < y; i++) {
long v = i;
- for (int j = l % 2 == 0 ? i : i / 10; j > 0; j /= 10) {
+ int j = (l % 2 == 0) ? i : i / 10;
+ while (j > 0) {
+ v = v * 10 + j % 10;
+ j /= 10;
+ }
+ if (check(v, k)) {
+ ans += v;
+ n--;
+ if (n == 0) {
+ return ans;
+ }
+ }
+ }
+ }
+ }
+
+ private boolean check(long x, int k) {
+ List s = new ArrayList<>();
+ while (x > 0) {
+ s.add((int) (x % k));
+ x /= k;
+ }
+ for (int i = 0, j = s.size() - 1; i < j; ++i, --j) {
+ if (!s.get(i).equals(s.get(j))) {
+ return false;
+ }
+ }
+ return true;
+ }
+}
+```
+
+#### C++
+
+```cpp
+class Solution {
+public:
+ long long kMirror(int k, int n) {
+ long long ans = 0;
+ for (int l = 1;; ++l) {
+ int x = pow(10, (l - 1) / 2);
+ int y = pow(10, (l + 1) / 2);
+ for (int i = x; i < y; ++i) {
+ long long v = i;
+ int j = (l % 2 == 0) ? i : i / 10;
+ while (j > 0) {
v = v * 10 + j % 10;
+ j /= 10;
}
- String ss = Long.toString(v, k);
- if (check(ss.toCharArray())) {
+ if (check(v, k)) {
ans += v;
if (--n == 0) {
return ans;
@@ -114,14 +200,113 @@ class Solution {
}
}
- private boolean check(char[] c) {
- for (int i = 0, j = c.length - 1; i < j; i++, j--) {
- if (c[i] != c[j]) {
+private:
+ bool check(long long x, int k) {
+ vector s;
+ while (x > 0) {
+ s.push_back(x % k);
+ x /= k;
+ }
+ for (int i = 0, j = s.size() - 1; i < j; ++i, --j) {
+ if (s[i] != s[j]) {
return false;
}
}
return true;
}
+};
+```
+
+#### Go
+
+```go
+func kMirror(k int, n int) int64 {
+ check := func(x int64, k int) bool {
+ s := []int{}
+ for x > 0 {
+ s = append(s, int(x%int64(k)))
+ x /= int64(k)
+ }
+ for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
+ if s[i] != s[j] {
+ return false
+ }
+ }
+ return true
+ }
+
+ var ans int64 = 0
+ for l := 1; ; l++ {
+ x := pow10((l - 1) / 2)
+ y := pow10((l + 1) / 2)
+ for i := x; i < y; i++ {
+ v := int64(i)
+ j := i
+ if l%2 != 0 {
+ j = i / 10
+ }
+ for j > 0 {
+ v = v*10 + int64(j%10)
+ j /= 10
+ }
+ if check(v, k) {
+ ans += v
+ n--
+ if n == 0 {
+ return ans
+ }
+ }
+ }
+ }
+}
+
+func pow10(exp int) int {
+ res := 1
+ for i := 0; i < exp; i++ {
+ res *= 10
+ }
+ return res
+}
+```
+
+#### TypeScript
+
+```ts
+function kMirror(k: number, n: number): number {
+ function check(x: number, k: number): boolean {
+ const s: number[] = [];
+ while (x > 0) {
+ s.push(x % k);
+ x = Math.floor(x / k);
+ }
+ for (let i = 0, j = s.length - 1; i < j; i++, j--) {
+ if (s[i] !== s[j]) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ let ans = 0;
+ for (let l = 1; ; l++) {
+ const x = Math.pow(10, Math.floor((l - 1) / 2));
+ const y = Math.pow(10, Math.floor((l + 1) / 2));
+ for (let i = x; i < y; i++) {
+ let v = i;
+ let j = l % 2 === 0 ? i : Math.floor(i / 10);
+ while (j > 0) {
+ v = v * 10 + (j % 10);
+ j = Math.floor(j / 10);
+ }
+ if (check(v, k)) {
+ ans += v;
+ n--;
+ if (n === 0) {
+ return ans;
+ }
+ }
+ }
+ }
}
```
diff --git a/solution/2000-2099/2081.Sum of k-Mirror Numbers/README_EN.md b/solution/2000-2099/2081.Sum of k-Mirror Numbers/README_EN.md
index ec3ab6bf5b1bd..2238182ec1e96 100644
--- a/solution/2000-2099/2081.Sum of k-Mirror Numbers/README_EN.md
+++ b/solution/2000-2099/2081.Sum of k-Mirror Numbers/README_EN.md
@@ -86,26 +86,112 @@ Their sum = 1 + 2 + 4 + 8 + 121 + 151 + 212 = 499.
-### Solution 1
+### Solution 1: Half Enumeration + Mathematics
+
+For a k-mirror number, we can divide it into two parts: the first half and the second half. For numbers with even length, the first and second halves are exactly the same; for numbers with odd length, the first and second halves are the same, but the middle digit can be any digit.
+
+We can enumerate the numbers in the first half, and then construct the complete k-mirror number based on the first half. The specific steps are as follows:
+
+1. **Enumerate Lengths**: Start enumerating the length of the numbers from 1, until we find enough k-mirror numbers that meet the requirements.
+2. **Calculate the Range of the First Half**: For a number of length $l$, the range of the first half is $[10^{(l-1)/2}, 10^{(l+1)/2})$.
+3. **Construct k-Mirror Numbers**: For each number $i$ in the first half, if the length is even, use $i$ directly as the first half; if the length is odd, divide $i$ by 10 to get the first half. Then reverse the digits of the first half and append them to form the complete k-mirror number.
+4. **Check k-Mirror Numbers**: Convert the constructed number to base $k$ and check whether it is a palindrome.
+5. **Accumulate the Result**: If it is a k-mirror number, add it to the result and decrease the counter $n$. When $n$ reaches 0, return the result.
+
+The time complexity mainly depends on the length being enumerated and the range of the first half. Since the maximum value of $n$ is 30, the number of enumerations is limited in practice. The space complexity is $O(1)$, since only a constant amount of extra space is
+#### Python3
+
+```python
+class Solution:
+ def kMirror(self, k: int, n: int) -> int:
+ def check(x: int, k: int) -> bool:
+ s = []
+ while x:
+ s.append(x % k)
+ x //= k
+ return s == s[::-1]
+
+ ans = 0
+ for l in count(1):
+ x = 10 ** ((l - 1) // 2)
+ y = 10 ** ((l + 1) // 2)
+ for i in range(x, y):
+ v = i
+ j = i if l % 2 == 0 else i // 10
+ while j > 0:
+ v = v * 10 + j % 10
+ j //= 10
+ if check(v, k):
+ ans += v
+ n -= 1
+ if n == 0:
+ return ans
+```
+
#### Java
```java
class Solution {
public long kMirror(int k, int n) {
long ans = 0;
- for (int l = 1;; ++l) {
+ for (int l = 1;; l++) {
int x = (int) Math.pow(10, (l - 1) / 2);
int y = (int) Math.pow(10, (l + 1) / 2);
for (int i = x; i < y; i++) {
long v = i;
- for (int j = l % 2 == 0 ? i : i / 10; j > 0; j /= 10) {
+ int j = (l % 2 == 0) ? i : i / 10;
+ while (j > 0) {
+ v = v * 10 + j % 10;
+ j /= 10;
+ }
+ if (check(v, k)) {
+ ans += v;
+ n--;
+ if (n == 0) {
+ return ans;
+ }
+ }
+ }
+ }
+ }
+
+ private boolean check(long x, int k) {
+ List s = new ArrayList<>();
+ while (x > 0) {
+ s.add((int) (x % k));
+ x /= k;
+ }
+ for (int i = 0, j = s.size() - 1; i < j; ++i, --j) {
+ if (!s.get(i).equals(s.get(j))) {
+ return false;
+ }
+ }
+ return true;
+ }
+}
+```
+
+#### C++
+
+```cpp
+class Solution {
+public:
+ long long kMirror(int k, int n) {
+ long long ans = 0;
+ for (int l = 1;; ++l) {
+ int x = pow(10, (l - 1) / 2);
+ int y = pow(10, (l + 1) / 2);
+ for (int i = x; i < y; ++i) {
+ long long v = i;
+ int j = (l % 2 == 0) ? i : i / 10;
+ while (j > 0) {
v = v * 10 + j % 10;
+ j /= 10;
}
- String ss = Long.toString(v, k);
- if (check(ss.toCharArray())) {
+ if (check(v, k)) {
ans += v;
if (--n == 0) {
return ans;
@@ -115,14 +201,113 @@ class Solution {
}
}
- private boolean check(char[] c) {
- for (int i = 0, j = c.length - 1; i < j; i++, j--) {
- if (c[i] != c[j]) {
+private:
+ bool check(long long x, int k) {
+ vector s;
+ while (x > 0) {
+ s.push_back(x % k);
+ x /= k;
+ }
+ for (int i = 0, j = s.size() - 1; i < j; ++i, --j) {
+ if (s[i] != s[j]) {
return false;
}
}
return true;
}
+};
+```
+
+#### Go
+
+```go
+func kMirror(k int, n int) int64 {
+ check := func(x int64, k int) bool {
+ s := []int{}
+ for x > 0 {
+ s = append(s, int(x%int64(k)))
+ x /= int64(k)
+ }
+ for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
+ if s[i] != s[j] {
+ return false
+ }
+ }
+ return true
+ }
+
+ var ans int64 = 0
+ for l := 1; ; l++ {
+ x := pow10((l - 1) / 2)
+ y := pow10((l + 1) / 2)
+ for i := x; i < y; i++ {
+ v := int64(i)
+ j := i
+ if l%2 != 0 {
+ j = i / 10
+ }
+ for j > 0 {
+ v = v*10 + int64(j%10)
+ j /= 10
+ }
+ if check(v, k) {
+ ans += v
+ n--
+ if n == 0 {
+ return ans
+ }
+ }
+ }
+ }
+}
+
+func pow10(exp int) int {
+ res := 1
+ for i := 0; i < exp; i++ {
+ res *= 10
+ }
+ return res
+}
+```
+
+#### TypeScript
+
+```ts
+function kMirror(k: number, n: number): number {
+ function check(x: number, k: number): boolean {
+ const s: number[] = [];
+ while (x > 0) {
+ s.push(x % k);
+ x = Math.floor(x / k);
+ }
+ for (let i = 0, j = s.length - 1; i < j; i++, j--) {
+ if (s[i] !== s[j]) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ let ans = 0;
+ for (let l = 1; ; l++) {
+ const x = Math.pow(10, Math.floor((l - 1) / 2));
+ const y = Math.pow(10, Math.floor((l + 1) / 2));
+ for (let i = x; i < y; i++) {
+ let v = i;
+ let j = l % 2 === 0 ? i : Math.floor(i / 10);
+ while (j > 0) {
+ v = v * 10 + (j % 10);
+ j = Math.floor(j / 10);
+ }
+ if (check(v, k)) {
+ ans += v;
+ n--;
+ if (n === 0) {
+ return ans;
+ }
+ }
+ }
+ }
}
```
diff --git a/solution/2000-2099/2081.Sum of k-Mirror Numbers/Solution.cpp b/solution/2000-2099/2081.Sum of k-Mirror Numbers/Solution.cpp
new file mode 100644
index 0000000000000..f0378bdb0147e
--- /dev/null
+++ b/solution/2000-2099/2081.Sum of k-Mirror Numbers/Solution.cpp
@@ -0,0 +1,39 @@
+class Solution {
+public:
+ long long kMirror(int k, int n) {
+ long long ans = 0;
+ for (int l = 1;; ++l) {
+ int x = pow(10, (l - 1) / 2);
+ int y = pow(10, (l + 1) / 2);
+ for (int i = x; i < y; ++i) {
+ long long v = i;
+ int j = (l % 2 == 0) ? i : i / 10;
+ while (j > 0) {
+ v = v * 10 + j % 10;
+ j /= 10;
+ }
+ if (check(v, k)) {
+ ans += v;
+ if (--n == 0) {
+ return ans;
+ }
+ }
+ }
+ }
+ }
+
+private:
+ bool check(long long x, int k) {
+ vector s;
+ while (x > 0) {
+ s.push_back(x % k);
+ x /= k;
+ }
+ for (int i = 0, j = s.size() - 1; i < j; ++i, --j) {
+ if (s[i] != s[j]) {
+ return false;
+ }
+ }
+ return true;
+ }
+};
diff --git a/solution/2000-2099/2081.Sum of k-Mirror Numbers/Solution.go b/solution/2000-2099/2081.Sum of k-Mirror Numbers/Solution.go
new file mode 100644
index 0000000000000..b99c8b2fea28d
--- /dev/null
+++ b/solution/2000-2099/2081.Sum of k-Mirror Numbers/Solution.go
@@ -0,0 +1,47 @@
+func kMirror(k int, n int) int64 {
+ check := func(x int64, k int) bool {
+ s := []int{}
+ for x > 0 {
+ s = append(s, int(x%int64(k)))
+ x /= int64(k)
+ }
+ for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
+ if s[i] != s[j] {
+ return false
+ }
+ }
+ return true
+ }
+
+ var ans int64 = 0
+ for l := 1; ; l++ {
+ x := pow10((l - 1) / 2)
+ y := pow10((l + 1) / 2)
+ for i := x; i < y; i++ {
+ v := int64(i)
+ j := i
+ if l%2 != 0 {
+ j = i / 10
+ }
+ for j > 0 {
+ v = v*10 + int64(j%10)
+ j /= 10
+ }
+ if check(v, k) {
+ ans += v
+ n--
+ if n == 0 {
+ return ans
+ }
+ }
+ }
+ }
+}
+
+func pow10(exp int) int {
+ res := 1
+ for i := 0; i < exp; i++ {
+ res *= 10
+ }
+ return res
+}
diff --git a/solution/2000-2099/2081.Sum of k-Mirror Numbers/Solution.java b/solution/2000-2099/2081.Sum of k-Mirror Numbers/Solution.java
index c08776873b60b..f9dae28dfd03c 100644
--- a/solution/2000-2099/2081.Sum of k-Mirror Numbers/Solution.java
+++ b/solution/2000-2099/2081.Sum of k-Mirror Numbers/Solution.java
@@ -1,18 +1,20 @@
class Solution {
public long kMirror(int k, int n) {
long ans = 0;
- for (int l = 1;; ++l) {
+ for (int l = 1;; l++) {
int x = (int) Math.pow(10, (l - 1) / 2);
int y = (int) Math.pow(10, (l + 1) / 2);
for (int i = x; i < y; i++) {
long v = i;
- for (int j = l % 2 == 0 ? i : i / 10; j > 0; j /= 10) {
+ int j = (l % 2 == 0) ? i : i / 10;
+ while (j > 0) {
v = v * 10 + j % 10;
+ j /= 10;
}
- String ss = Long.toString(v, k);
- if (check(ss.toCharArray())) {
+ if (check(v, k)) {
ans += v;
- if (--n == 0) {
+ n--;
+ if (n == 0) {
return ans;
}
}
@@ -20,12 +22,17 @@ public long kMirror(int k, int n) {
}
}
- private boolean check(char[] c) {
- for (int i = 0, j = c.length - 1; i < j; i++, j--) {
- if (c[i] != c[j]) {
+ private boolean check(long x, int k) {
+ List s = new ArrayList<>();
+ while (x > 0) {
+ s.add((int) (x % k));
+ x /= k;
+ }
+ for (int i = 0, j = s.size() - 1; i < j; ++i, --j) {
+ if (!s.get(i).equals(s.get(j))) {
return false;
}
}
return true;
}
-}
\ No newline at end of file
+}
diff --git a/solution/2000-2099/2081.Sum of k-Mirror Numbers/Solution.py b/solution/2000-2099/2081.Sum of k-Mirror Numbers/Solution.py
new file mode 100644
index 0000000000000..df18cf29d7316
--- /dev/null
+++ b/solution/2000-2099/2081.Sum of k-Mirror Numbers/Solution.py
@@ -0,0 +1,24 @@
+class Solution:
+ def kMirror(self, k: int, n: int) -> int:
+ def check(x: int, k: int) -> bool:
+ s = []
+ while x:
+ s.append(x % k)
+ x //= k
+ return s == s[::-1]
+
+ ans = 0
+ for l in count(1):
+ x = 10 ** ((l - 1) // 2)
+ y = 10 ** ((l + 1) // 2)
+ for i in range(x, y):
+ v = i
+ j = i if l % 2 == 0 else i // 10
+ while j > 0:
+ v = v * 10 + j % 10
+ j //= 10
+ if check(v, k):
+ ans += v
+ n -= 1
+ if n == 0:
+ return ans
diff --git a/solution/2000-2099/2081.Sum of k-Mirror Numbers/Solution.ts b/solution/2000-2099/2081.Sum of k-Mirror Numbers/Solution.ts
new file mode 100644
index 0000000000000..4d5e04035acec
--- /dev/null
+++ b/solution/2000-2099/2081.Sum of k-Mirror Numbers/Solution.ts
@@ -0,0 +1,36 @@
+function kMirror(k: number, n: number): number {
+ function check(x: number, k: number): boolean {
+ const s: number[] = [];
+ while (x > 0) {
+ s.push(x % k);
+ x = Math.floor(x / k);
+ }
+ for (let i = 0, j = s.length - 1; i < j; i++, j--) {
+ if (s[i] !== s[j]) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ let ans = 0;
+ for (let l = 1; ; l++) {
+ const x = Math.pow(10, Math.floor((l - 1) / 2));
+ const y = Math.pow(10, Math.floor((l + 1) / 2));
+ for (let i = x; i < y; i++) {
+ let v = i;
+ let j = l % 2 === 0 ? i : Math.floor(i / 10);
+ while (j > 0) {
+ v = v * 10 + (j % 10);
+ j = Math.floor(j / 10);
+ }
+ if (check(v, k)) {
+ ans += v;
+ n--;
+ if (n === 0) {
+ return ans;
+ }
+ }
+ }
+ }
+}
diff --git a/solution/2000-2099/2099.Find Subsequence of Length K With the Largest Sum/README.md b/solution/2000-2099/2099.Find Subsequence of Length K With the Largest Sum/README.md
index a0c24322cf7ec..60a570609910a 100644
--- a/solution/2000-2099/2099.Find Subsequence of Length K With the Largest Sum/README.md
+++ b/solution/2000-2099/2099.Find Subsequence of Length K With the Largest Sum/README.md
@@ -95,9 +95,7 @@ class Solution {
public int[] maxSubsequence(int[] nums, int k) {
int n = nums.length;
Integer[] idx = new Integer[n];
- for (int i = 0; i < n; ++i) {
- idx[i] = i;
- }
+ Arrays.setAll(idx, i -> i);
Arrays.sort(idx, (i, j) -> nums[i] - nums[j]);
Arrays.sort(idx, n - k, n);
int[] ans = new int[k];
@@ -109,20 +107,41 @@ class Solution {
}
```
+#### C++
+
+```cpp
+#include 
+第一条路径是 左 -> 上 -> 左, 记为 "lul". +第二条路径是 上 -> 左, 记为 'ul'. +两条路径都具有最短距离6, 但'l' < 'u'，故第一条路径字典序更小。因此输出"lul"。 +
+
+
+输入： points = [[1,1],[1,3],[3,1],[3,3],[2,2]] +输出： 4-+
+输入： points = [[1,1],[1,3],[3,1],[3,3],[4,1],[4,3]] +输出： 2
+
+输入： points = [[0,3],[1,2],[3,1],[1,3],[2,1]] +输出： 0 +解释： 无法由这些点组成任何矩形。
