;
-};
+function removeSubfolders(folder: string[]): string[] {
+ const trie = new Trie();
+ for (let i = 0; i < folder.length; ++i) {
+ trie.insert(i, folder[i]);
+ }
+ return trie.search().map(i => folder[i]);
+}
diff --git a/solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/Solution3.go b/solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/Solution3.go
deleted file mode 100644
index 9a5f248168d9d..0000000000000
--- a/solution/1200-1299/1233.Remove Sub-Folders from the Filesystem/Solution3.go
+++ /dev/null
@@ -1,46 +0,0 @@
-type Trie struct {
- children map[string]*Trie
- fid int
-}
-
-func newTrie() *Trie {
- return &Trie{map[string]*Trie{}, -1}
-}
-
-func (this *Trie) insert(fid int, f string) {
- node := this
- ps := strings.Split(f, "/")
- for _, p := range ps[1:] {
- if _, ok := node.children[p]; !ok {
- node.children[p] = newTrie()
- }
- node = node.children[p]
- }
- node.fid = fid
-}
-
-func (this *Trie) search() (ans []int) {
- var dfs func(*Trie)
- dfs = func(root *Trie) {
- if root.fid != -1 {
- ans = append(ans, root.fid)
- return
- }
- for _, child := range root.children {
- dfs(child)
- }
- }
- dfs(this)
- return
-}
-
-func removeSubfolders(folder []string) (ans []string) {
- trie := newTrie()
- for i, f := range folder {
- trie.insert(i, f)
- }
- for _, i := range trie.search() {
- ans = append(ans, folder[i])
- }
- return
-}
\ No newline at end of file
diff --git a/solution/1200-1299/1258.Synonymous Sentences/README.md b/solution/1200-1299/1258.Synonymous Sentences/README.md
index 2b00239e3e600..c5efea5ae8214 100644
--- a/solution/1200-1299/1258.Synonymous Sentences/README.md
+++ b/solution/1200-1299/1258.Synonymous Sentences/README.md
@@ -5,6 +5,7 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/1200-1299/1258.Sy
rating: 1847
source: 第 13 场双周赛 Q3
tags:
+ - 排序
- 并查集
- 数组
- 哈希表
diff --git a/solution/1200-1299/1258.Synonymous Sentences/README_EN.md b/solution/1200-1299/1258.Synonymous Sentences/README_EN.md
index 5e6126ae5a0c2..849c4d294e764 100644
--- a/solution/1200-1299/1258.Synonymous Sentences/README_EN.md
+++ b/solution/1200-1299/1258.Synonymous Sentences/README_EN.md
@@ -5,6 +5,7 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/1200-1299/1258.Sy
rating: 1847
source: Biweekly Contest 13 Q3
tags:
+ - Sort
- Union Find
- Array
- Hash Table
diff --git a/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/README.md b/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/README.md
index 64d18981736ca..b31a8a0daf1b6 100644
--- a/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/README.md
+++ b/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/README.md
@@ -23,38 +23,24 @@ tags:
请你返回该链表所表示数字的 十进制值 。
+最高位 在链表的头部。
+
示例 1：
-
+
-输入：head = [1,0,1]
+
+输入：head = [1,0,1]
输出：5
解释：二进制数 (101) 转化为十进制数 (5)
示例 2：
-输入：head = [0]
-输出：0
-
-
-示例 3：
-
-输入：head = [1]
-输出：1
-
-
-示例 4：
-
-输入：head = [1,0,0,1,0,0,1,1,1,0,0,0,0,0,0]
-输出：18880
-
-
-示例 5：
-
-输入：head = [0,0]
+
+输入：head = [0]
输出：0
@@ -76,11 +62,11 @@ tags:
### 方法一：遍历链表
-我们用变量 `ans` 记录当前的十进制值，初始值为 $0$。
+我们用变量 $\textit{ans}$ 记录当前的十进制值，初始值为 $0$。
-遍历链表，对于每个结点，将 `ans` 左移一位，然后再或上当前结点的值。遍历结束后，`ans` 即为十进制值。
+遍历链表，对于每个结点，将 $\textit{ans}$ 左移一位，然后再或上当前结点的值。遍历结束后，$\textit{ans}$ 即为十进制值。
-时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为链表的长度。
+时间复杂度 $O(n)$，其中 $n$ 为链表的长度。空间复杂度 $O(1)$。
@@ -212,12 +198,11 @@ function getDecimalValue(head: ListNode | null): number {
// }
// }
impl Solution {
- pub fn get_decimal_value(head: Option>) -> i32 {
+ pub fn get_decimal_value(mut head: Option>) -> i32 {
let mut ans = 0;
- let mut cur = &head;
- while let Some(node) = cur {
+ while let Some(node) = head {
ans = (ans << 1) | node.val;
- cur = &node.next;
+ head = node.next;
}
ans
}
@@ -247,6 +232,31 @@ var getDecimalValue = function (head) {
};
```
+#### C#
+
+```cs
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ * public int val;
+ * public ListNode next;
+ * public ListNode(int val=0, ListNode next=null) {
+ * this.val = val;
+ * this.next = next;
+ * }
+ * }
+ */
+public class Solution {
+ public int GetDecimalValue(ListNode head) {
+ int ans = 0;
+ for (; head != null; head = head.next) {
+ ans = ans << 1 | head.val;
+ }
+ return ans;
+ }
+}
+```
+
#### PHP
```php
@@ -267,13 +277,12 @@ class Solution {
* @return Integer
*/
function getDecimalValue($head) {
- $rs = [];
- while ($head != null) {
- array_push($rs, $head->val);
+ $ans = 0;
+ while ($head !== null) {
+ $ans = ($ans << 1) | $head->val;
$head = $head->next;
}
- $rsStr = implode($rs);
- return bindec($rsStr);
+ return $ans;
}
}
```
diff --git a/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/README_EN.md b/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/README_EN.md
index 3e49f84db6367..5d6aaab02c5ac 100644
--- a/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/README_EN.md
+++ b/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/README_EN.md
@@ -56,7 +56,13 @@ tags:
-### Solution 1
+### Solution 1: Traverse the Linked List
+
+We use a variable $\textit{ans}$ to record the current decimal value, with an initial value of $0$.
+
+Traverse the linked list. For each node, left-shift $\textit{ans}$ by one bit, then perform a bitwise OR with the current node's value. After traversal, $\textit{ans}$ is the decimal value.
+
+The time complexity is $O(n)$, where $n$ is the length of the linked list. The space complexity is $O(1)$.
@@ -188,12 +194,11 @@ function getDecimalValue(head: ListNode | null): number {
// }
// }
impl Solution {
- pub fn get_decimal_value(head: Option>) -> i32 {
+ pub fn get_decimal_value(mut head: Option>) -> i32 {
let mut ans = 0;
- let mut cur = &head;
- while let Some(node) = cur {
+ while let Some(node) = head {
ans = (ans << 1) | node.val;
- cur = &node.next;
+ head = node.next;
}
ans
}
@@ -223,6 +228,31 @@ var getDecimalValue = function (head) {
};
```
+#### C#
+
+```cs
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ * public int val;
+ * public ListNode next;
+ * public ListNode(int val=0, ListNode next=null) {
+ * this.val = val;
+ * this.next = next;
+ * }
+ * }
+ */
+public class Solution {
+ public int GetDecimalValue(ListNode head) {
+ int ans = 0;
+ for (; head != null; head = head.next) {
+ ans = ans << 1 | head.val;
+ }
+ return ans;
+ }
+}
+```
+
#### PHP
```php
@@ -243,13 +273,12 @@ class Solution {
* @return Integer
*/
function getDecimalValue($head) {
- $rs = [];
- while ($head != null) {
- array_push($rs, $head->val);
+ $ans = 0;
+ while ($head !== null) {
+ $ans = ($ans << 1) | $head->val;
$head = $head->next;
}
- $rsStr = implode($rs);
- return bindec($rsStr);
+ return $ans;
}
}
```
diff --git a/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/Solution.cs b/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/Solution.cs
new file mode 100644
index 0000000000000..bbfcf9dbff062
--- /dev/null
+++ b/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/Solution.cs
@@ -0,0 +1,20 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ * public int val;
+ * public ListNode next;
+ * public ListNode(int val=0, ListNode next=null) {
+ * this.val = val;
+ * this.next = next;
+ * }
+ * }
+ */
+public class Solution {
+ public int GetDecimalValue(ListNode head) {
+ int ans = 0;
+ for (; head != null; head = head.next) {
+ ans = ans << 1 | head.val;
+ }
+ return ans;
+ }
+}
\ No newline at end of file
diff --git a/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/Solution.php b/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/Solution.php
index 7ddaf720fe6ae..514bc47573ca4 100644
--- a/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/Solution.php
+++ b/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/Solution.php
@@ -15,12 +15,11 @@ class Solution {
* @return Integer
*/
function getDecimalValue($head) {
- $rs = [];
- while ($head != null) {
- array_push($rs, $head->val);
+ $ans = 0;
+ while ($head !== null) {
+ $ans = ($ans << 1) | $head->val;
$head = $head->next;
}
- $rsStr = implode($rs);
- return bindec($rsStr);
+ return $ans;
}
}
\ No newline at end of file
diff --git a/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/Solution.rs b/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/Solution.rs
index 7c122a66fc0df..b3f205ea5f95c 100644
--- a/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/Solution.rs
+++ b/solution/1200-1299/1290.Convert Binary Number in a Linked List to Integer/Solution.rs
@@ -15,12 +15,11 @@
// }
// }
impl Solution {
- pub fn get_decimal_value(head: Option>) -> i32 {
+ pub fn get_decimal_value(mut head: Option>) -> i32 {
let mut ans = 0;
- let mut cur = &head;
- while let Some(node) = cur {
+ while let Some(node) = head {
ans = (ans << 1) | node.val;
- cur = &node.next;
+ head = node.next;
}
ans
}
diff --git a/solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/README.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/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/1500-1599/1516.Move Sub-Tree of N-Ary Tree/README_EN.md b/solution/1500-1599/1516.Move Sub-Tree of N-Ary Tree/README_EN.md
index e0bb9b5768ef2..d1141fca6d308 100644
--- a/solution/1500-1599/1516.Move Sub-Tree of N-Ary Tree/README_EN.md
+++ b/solution/1500-1599/1516.Move Sub-Tree of N-Ary Tree/README_EN.md
@@ -68,6 +68,14 @@ Notice that node 4 is the last child of node 1.
Explanation: This example follows case 3 because node p is not in the sub-tree of node q and vice-versa. We can move node 3 with its sub-tree and make it as node 8's child.
+Example 4:
+
+
+Input: root = [1,null,2,3,null,4], p = 1, q = 4
+Output: [4,null,1,null,2,3]
+Explanation: This example follows case 1 because node q is in the sub-tree of node p. Disconnect 4 with its parent and move node 1 with its sub-tree and make it as node 4's child.
+
+
Constraints:
diff --git a/solution/1500-1599/1516.Move Sub-Tree of N-Ary Tree/images/untitled-diagramdrawio.png b/solution/1500-1599/1516.Move Sub-Tree of N-Ary Tree/images/untitled-diagramdrawio.png
new file mode 100644
index 0000000000000..3daaaf9e87ae7
Binary files /dev/null and b/solution/1500-1599/1516.Move Sub-Tree of N-Ary Tree/images/untitled-diagramdrawio.png differ
diff --git a/solution/1500-1599/1517.Find Users With Valid E-Mails/README.md b/solution/1500-1599/1517.Find Users With Valid E-Mails/README.md
index e69eb35820536..8ca76e3ff3e2e 100644
--- a/solution/1500-1599/1517.Find Users With Valid E-Mails/README.md
+++ b/solution/1500-1599/1517.Find Users With Valid E-Mails/README.md
@@ -37,7 +37,7 @@ user_id 是该表的主键（具有唯一值的列）。
一个有效的电子邮件具有前缀名称和域，其中：
- - 前缀 名称是一个字符串，可以包含字母（大写或小写），数字，下划线
'_' ，点 '.' 和/或破折号 '-' 。前缀名称 必须 以字母开头。
+ - 前缀 名称是一个字符串，可以包含字母（大写或小写），数字，下划线
'_' ，点 '.' 和（或）破折号 '-' 。前缀名称 必须 以字母开头。
- 域 为
'@leetcode.com' 。
diff --git a/solution/1600-1699/1695.Maximum Erasure Value/README.md b/solution/1600-1699/1695.Maximum Erasure Value/README.md
index 890ed06b4617a..e3acd494c64a7 100644
--- a/solution/1600-1699/1695.Maximum Erasure Value/README.md
+++ b/solution/1600-1699/1695.Maximum Erasure Value/README.md
@@ -61,11 +61,11 @@ tags:
### 方法一：数组或哈希表 + 前缀和
-我们用数组或哈希表 $d$ 记录每个数字最后一次出现的位置，用 $s$ 记录前缀和，用 $j$ 记录当前不重复子数组的左端点。
+我们用数组或哈希表 $\text{d}$ 记录每个数字最后一次出现的位置，用前缀和数组 $\text{s}$ 记录从起点到当前位置的和。我们用变量 $j$ 记录当前不重复子数组的左端点。
-遍历数组，对于每个数字 $v$，如果 $d[v]$ 存在，那么我们更新 $j$ 为 $max(j, d[v])$，这样就保证了当前不重复子数组不包含 $v$，然后更新答案为 $max(ans, s[i] - s[j])$，最后更新 $d[v]$ 为 $i$。
+遍历数组，对于每个数字 $v$，如果 $\text{d}[v]$ 存在，那么我们更新 $j$ 为 $\max(j, \text{d}[v])$，这样就保证了当前不重复子数组不包含 $v$。然后我们更新答案为 $\max(\text{ans}, \text{s}[i] - \text{s}[j])$，最后更新 $\text{d}[v]$ 为 $i$。
-时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $nums$ 的长度。
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $\text{nums}$ 的长度。
@@ -74,7 +74,7 @@ tags:
```python
class Solution:
def maximumUniqueSubarray(self, nums: List[int]) -> int:
- d = defaultdict(int)
+ d = [0] * (max(nums) + 1)
s = list(accumulate(nums, initial=0))
ans = j = 0
for i, v in enumerate(nums, 1):
@@ -173,21 +173,48 @@ function maximumUniqueSubarray(nums: number[]): number {
}
```
+#### Rust
+
+```rust
+impl Solution {
+ pub fn maximum_unique_subarray(nums: Vec) -> i32 {
+ let m = *nums.iter().max().unwrap() as usize;
+ let mut d = vec![0; m + 1];
+ let n = nums.len();
+
+ let mut s = vec![0; n + 1];
+ for i in 0..n {
+ s[i + 1] = s[i] + nums[i];
+ }
+
+ let mut ans = 0;
+ let mut j = 0;
+ for (i, &v) in nums.iter().enumerate().map(|(i, v)| (i + 1, v)) {
+ j = j.max(d[v as usize]);
+ ans = ans.max(s[i] - s[j]);
+ d[v as usize] = i;
+ }
+
+ ans
+ }
+}
+```
+
-### 方法二：双指针
+### 方法二：双指针（滑动窗口）
-题目实际上是让我们找出一个最长的子数组，该子数组中所有元素都不相同。我们可以用两个指针 $i$ 和 $j$ 分别指向子数组的左右边界，初始时 $i = 0$, $j = 0$。另外，我们用一个哈希表 $vis$ 记录子数组中的元素。
+题目实际上是让我们找出一个最长的子数组，该子数组中所有元素都不相同。我们可以用两个指针 $i$ 和 $j$ 分别指向子数组的左右边界，初始时 $i = 0$, $j = 0$。另外，我们用一个哈希表 $\text{vis}$ 记录子数组中的元素。
-遍历数组，对于每个数字 $x$，如果 $x$ 在 $vis$ 中，那么我们不断地将 $nums[i]$ 从 $vis$ 中移除，直到 $x$ 不在 $vis$ 中为止。这样我们就找到了一个不包含重复元素的子数组。我们将 $x$ 加入 $vis$，并更新子数组的和 $s$，然后更新答案 $ans = \max(ans, s)$。
+遍历数组，对于每个数字 $x$，如果 $x$ 在 $\text{vis}$ 中，那么我们不断地将 $\text{nums}[i]$ 从 $\text{vis}$ 中移除，直到 $x$ 不在 $\text{vis}$ 中为止。这样我们就找到了一个不包含重复元素的子数组。我们将 $x$ 加入 $\text{vis}$，并更新子数组的和 $s$，然后更新答案 $\text{ans} = \max(\text{ans}, s)$。
遍历结束后，我们就可以得到最大的子数组和。
-时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $nums$ 的长度。
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $\text{nums}$ 的长度。
@@ -292,6 +319,33 @@ function maximumUniqueSubarray(nums: number[]): number {
}
```
+#### Rust
+
+```rust
+use std::collections::HashSet;
+
+impl Solution {
+ pub fn maximum_unique_subarray(nums: Vec) -> i32 {
+ let mut vis = HashSet::new();
+ let (mut ans, mut s, mut i) = (0, 0, 0);
+
+ for &x in &nums {
+ while vis.contains(&x) {
+ let y = nums[i];
+ s -= y;
+ vis.remove(&y);
+ i += 1;
+ }
+ vis.insert(x);
+ s += x;
+ ans = ans.max(s);
+ }
+
+ ans
+ }
+}
+```
+
diff --git a/solution/1600-1699/1695.Maximum Erasure Value/README_EN.md b/solution/1600-1699/1695.Maximum Erasure Value/README_EN.md
index 4a0e89c95882b..cc20b0f8b6cfe 100644
--- a/solution/1600-1699/1695.Maximum Erasure Value/README_EN.md
+++ b/solution/1600-1699/1695.Maximum Erasure Value/README_EN.md
@@ -59,11 +59,11 @@ tags:
### Solution 1: Array or Hash Table + Prefix Sum
-We use an array or hash table $d$ to record the last occurrence of each number, use $s$ to record the prefix sum, and use $j$ to record the left endpoint of the current non-repeating subarray.
+We use an array or hash table $\text{d}$ to record the last occurrence position of each number, and use a prefix sum array $\text{s}$ to record the sum from the starting point to the current position. We use a variable $j$ to record the left endpoint of the current non-repeating subarray.
-We traverse the array, for each number $v$, if $d[v]$ exists, then we update $j$ to $max(j, d[v])$, which ensures that the current non-repeating subarray does not contain $v$. Then we update the answer to $max(ans, s[i] - s[j])$, and finally update $d[v]$ to $i$.
+We iterate through the array. For each number $v$, if $\text{d}[v]$ exists, we update $j$ to $\max(j, \text{d}[v])$, which ensures that the current non-repeating subarray does not contain $v$. Then we update the answer to $\max(\text{ans}, \text{s}[i] - \text{s}[j])$, and finally update $\text{d}[v]$ to $i$.
-The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the array $nums$.
+The time complexity is $O(n)$, and the space complexity is $O(n)$, where $n$ is the length of the array $\text{nums}$.
@@ -72,7 +72,7 @@ The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is
```python
class Solution:
def maximumUniqueSubarray(self, nums: List[int]) -> int:
- d = defaultdict(int)
+ d = [0] * (max(nums) + 1)
s = list(accumulate(nums, initial=0))
ans = j = 0
for i, v in enumerate(nums, 1):
@@ -171,21 +171,48 @@ function maximumUniqueSubarray(nums: number[]): number {
}
```
+#### Rust
+
+```rust
+impl Solution {
+ pub fn maximum_unique_subarray(nums: Vec) -> i32 {
+ let m = *nums.iter().max().unwrap() as usize;
+ let mut d = vec![0; m + 1];
+ let n = nums.len();
+
+ let mut s = vec![0; n + 1];
+ for i in 0..n {
+ s[i + 1] = s[i] + nums[i];
+ }
+
+ let mut ans = 0;
+ let mut j = 0;
+ for (i, &v) in nums.iter().enumerate().map(|(i, v)| (i + 1, v)) {
+ j = j.max(d[v as usize]);
+ ans = ans.max(s[i] - s[j]);
+ d[v as usize] = i;
+ }
+
+ ans
+ }
+}
+```
+
-### Solution 2: Two Pointers
+### Solution 2: Two Pointers (Sliding Window)
-The problem is actually asking us to find the longest subarray in which all elements are distinct. We can use two pointers $i$ and $j$ to point to the left and right boundaries of the subarray, initially $i = 0$, $j = 0$. In addition, we use a hash table $vis$ to record the elements in the subarray.
+The problem is essentially asking us to find the longest subarray where all elements are distinct. We can use two pointers $i$ and $j$ to point to the left and right boundaries of the subarray, initially $i = 0$ and $j = 0$. Additionally, we use a hash table $\text{vis}$ to record the elements in the subarray.
-We traverse the array, for each number $x$, if $x$ is in $vis$, then we continuously remove $nums[i]$ from $vis$, until $x$ is not in $vis$. In this way, we find a subarray without duplicate elements. We add $x$ to $vis$, update the sum of the subarray $s$, and then update the answer $ans = \max(ans, s)$.
+We iterate through the array. For each number $x$, if $x$ is in $\text{vis}$, we continuously remove $\text{nums}[i]$ from $\text{vis}$ until $x$ is no longer in $\text{vis}$. This way, we find a subarray that contains no duplicate elements. We add $x$ to $\text{vis}$, update the subarray sum $s$, and then update the answer $\text{ans} = \max(\text{ans}, s)$.
-After the traversal, we can get the maximum sum of the subarray.
+After the iteration, we can get the maximum subarray sum.
-The time complexity is $O(n)$, and the space complexity is $O(n)$. Where $n$ is the length of the array $nums$.
+The time complexity is $O(n)$, and the space complexity is $O(n)$, where $n$ is the length of the array $\text{nums}$.
@@ -290,6 +317,33 @@ function maximumUniqueSubarray(nums: number[]): number {
}
```
+#### Rust
+
+```rust
+use std::collections::HashSet;
+
+impl Solution {
+ pub fn maximum_unique_subarray(nums: Vec) -> i32 {
+ let mut vis = HashSet::new();
+ let (mut ans, mut s, mut i) = (0, 0, 0);
+
+ for &x in &nums {
+ while vis.contains(&x) {
+ let y = nums[i];
+ s -= y;
+ vis.remove(&y);
+ i += 1;
+ }
+ vis.insert(x);
+ s += x;
+ ans = ans.max(s);
+ }
+
+ ans
+ }
+}
+```
+
diff --git a/solution/1600-1699/1695.Maximum Erasure Value/Solution.py b/solution/1600-1699/1695.Maximum Erasure Value/Solution.py
index 07b780f3444e4..068e35bfd907b 100644
--- a/solution/1600-1699/1695.Maximum Erasure Value/Solution.py
+++ b/solution/1600-1699/1695.Maximum Erasure Value/Solution.py
@@ -1,6 +1,6 @@
class Solution:
def maximumUniqueSubarray(self, nums: List[int]) -> int:
- d = defaultdict(int)
+ d = [0] * (max(nums) + 1)
s = list(accumulate(nums, initial=0))
ans = j = 0
for i, v in enumerate(nums, 1):
diff --git a/solution/1600-1699/1695.Maximum Erasure Value/Solution.rs b/solution/1600-1699/1695.Maximum Erasure Value/Solution.rs
new file mode 100644
index 0000000000000..f9212293a0775
--- /dev/null
+++ b/solution/1600-1699/1695.Maximum Erasure Value/Solution.rs
@@ -0,0 +1,22 @@
+impl Solution {
+ pub fn maximum_unique_subarray(nums: Vec) -> i32 {
+ let m = *nums.iter().max().unwrap() as usize;
+ let mut d = vec![0; m + 1];
+ let n = nums.len();
+
+ let mut s = vec![0; n + 1];
+ for i in 0..n {
+ s[i + 1] = s[i] + nums[i];
+ }
+
+ let mut ans = 0;
+ let mut j = 0;
+ for (i, &v) in nums.iter().enumerate().map(|(i, v)| (i + 1, v)) {
+ j = j.max(d[v as usize]);
+ ans = ans.max(s[i] - s[j]);
+ d[v as usize] = i;
+ }
+
+ ans
+ }
+}
diff --git a/solution/1600-1699/1695.Maximum Erasure Value/Solution2.rs b/solution/1600-1699/1695.Maximum Erasure Value/Solution2.rs
new file mode 100644
index 0000000000000..fb90a2d2bb733
--- /dev/null
+++ b/solution/1600-1699/1695.Maximum Erasure Value/Solution2.rs
@@ -0,0 +1,22 @@
+use std::collections::HashSet;
+
+impl Solution {
+ pub fn maximum_unique_subarray(nums: Vec) -> i32 {
+ let mut vis = HashSet::new();
+ let (mut ans, mut s, mut i) = (0, 0, 0);
+
+ for &x in &nums {
+ while vis.contains(&x) {
+ let y = nums[i];
+ s -= y;
+ vis.remove(&y);
+ i += 1;
+ }
+ vis.insert(x);
+ s += x;
+ ans = ans.max(s);
+ }
+
+ ans
+ }
+}
diff --git a/solution/1700-1799/1717.Maximum Score From Removing Substrings/README.md b/solution/1700-1799/1717.Maximum Score From Removing Substrings/README.md
index e399609fa2ebd..188d7f4e4bd69 100644
--- a/solution/1700-1799/1717.Maximum Score From Removing Substrings/README.md
+++ b/solution/1700-1799/1717.Maximum Score From Removing Substrings/README.md
@@ -88,9 +88,9 @@ tags:
- 如果 $c$ 是 "a"，由于要先删除 "ab"，因此此时我们不消除该字符，只增加 $\textit{cnt1}$；
- 如果 $c$ 是 "b"，如果此时 $\textit{cnt1} > 0$，我们可以消除一个 "ab"，并增加 $x$ 分，否则我们只能增加 $\textit{cnt2}$；
-- 如果 $c$ 是其他字符，那么对于该子字符串，我们剩下了一个 $\textit{cnt2}$ 个 "b" 和 $\textit{cnt1}$ 个 "a"，我们可以消除 $\min(\textit{cnt1}, \textit{cnt2})$ 个 "ab"，并增加 $y$ 分。
+- 如果 $c$ 是其他字符，那么对于该子字符串，我们剩下了 $\textit{cnt2}$ 个 "b" 和 $\textit{cnt1}$ 个 "a"，我们可以消除 $\min(\textit{cnt1}, \textit{cnt2})$ 个 "ba"，并增加若干个 $y$ 分。
-遍历结束后，我们还需要额外处理一下剩余的 "ab"，增加若干个 $y$ 分。
+遍历结束后，我们还需要额外处理一下剩余的 "ba"，增加若干个 $y$ 分。
时间复杂度 $O(n)$，其中 $n$ 为字符串 $s$ 的长度。空间复杂度 $O(1)$。
@@ -259,6 +259,44 @@ function maximumGain(s: string, x: number, y: number): number {
}
```
+#### Rust
+
+```rust
+impl Solution {
+ pub fn maximum_gain(s: String, mut x: i32, mut y: i32) -> i32 {
+ let (mut a, mut b) = ('a', 'b');
+ if x < y {
+ std::mem::swap(&mut x, &mut y);
+ std::mem::swap(&mut a, &mut b);
+ }
+
+ let mut ans = 0;
+ let mut cnt1 = 0;
+ let mut cnt2 = 0;
+
+ for c in s.chars() {
+ if c == a {
+ cnt1 += 1;
+ } else if c == b {
+ if cnt1 > 0 {
+ ans += x;
+ cnt1 -= 1;
+ } else {
+ cnt2 += 1;
+ }
+ } else {
+ ans += cnt1.min(cnt2) * y;
+ cnt1 = 0;
+ cnt2 = 0;
+ }
+ }
+
+ ans += cnt1.min(cnt2) * y;
+ ans
+ }
+}
+```
+
#### JavaScript
```js
@@ -291,81 +329,38 @@ function maximumGain(s, x, y) {
}
```
-
-
-
-
-
-
-### Solution 2: Greedy + Stack
-
-
-
-#### TypeScript
-
-```ts
-function maximumGain(s: string, x: number, y: number): number {
- const stk: string[] = [];
- const pairs: Record = { a: 'b', b: 'a' };
- const pair = x > y ? ['a', 'b'] : ['b', 'a'];
- let str = [...s];
- let ans = 0;
- let havePairs = true;
-
- while (havePairs) {
- for (const p of pair) {
- havePairs = true;
-
- for (const ch of str) {
- if (stk.at(-1) === p && ch === pairs[p]) {
- stk.pop();
- } else stk.push(ch);
- }
+#### C#
- if (str.length === stk.length) havePairs = false;
-
- const multiplier = p === 'a' ? x : y;
- ans += (multiplier * (str.length - stk.length)) / 2;
- str = [...stk];
- stk.length = 0;
+```cs
+public class Solution {
+ public int MaximumGain(string s, int x, int y) {
+ char a = 'a', b = 'b';
+ if (x < y) {
+ (x, y) = (y, x);
+ (a, b) = (b, a);
}
- }
-
- return ans;
-}
-```
-#### JavaeScript
-
-```js
-function maximumGain(s, x, y) {
- const stk = [];
- const pairs = { a: 'b', b: 'a' };
- const pair = x > y ? ['a', 'b'] : ['b', 'a'];
- let str = [...s];
- let ans = 0;
- let havePairs = true;
-
- while (havePairs) {
- for (const p of pair) {
- havePairs = true;
-
- for (const ch of str) {
- if (stk.at(-1) === p && ch === pairs[p]) {
- stk.pop();
- } else stk.push(ch);
+ int ans = 0, cnt1 = 0, cnt2 = 0;
+ foreach (char c in s) {
+ if (c == a) {
+ cnt1++;
+ } else if (c == b) {
+ if (cnt1 > 0) {
+ ans += x;
+ cnt1--;
+ } else {
+ cnt2++;
+ }
+ } else {
+ ans += Math.Min(cnt1, cnt2) * y;
+ cnt1 = 0;
+ cnt2 = 0;
}
-
- if (str.length === stk.length) havePairs = false;
-
- const multiplier = p === 'a' ? x : y;
- ans += (multiplier * (str.length - stk.length)) / 2;
- str = [...stk];
- stk.length = 0;
}
- }
- return ans;
+ ans += Math.Min(cnt1, cnt2) * y;
+ return ans;
+ }
}
```
diff --git a/solution/1700-1799/1717.Maximum Score From Removing Substrings/README_EN.md b/solution/1700-1799/1717.Maximum Score From Removing Substrings/README_EN.md
index cd7204fd75dcf..bad524814c1b2 100644
--- a/solution/1700-1799/1717.Maximum Score From Removing Substrings/README_EN.md
+++ b/solution/1700-1799/1717.Maximum Score From Removing Substrings/README_EN.md
@@ -76,23 +76,23 @@ Total score = 5 + 4 + 5 + 5 = 19.
### Solution 1: Greedy
-Let's assume that the score of the substring "ab" is always not lower than the score of the substring "ba". If not, we can swap "a" and "b", and simultaneously swap $x$ and $y$.
+We can assume that the score of substring "ab" is always no less than the score of substring "ba". If not, we can swap "a" and "b", and simultaneously swap $x$ and $y$.
-Next, we only need to consider the case where the string contains only "a" and "b". If the string contains other characters, we can treat them as a dividing point, splitting the string into several substrings that contain only "a" and "b", and then calculate the score for each substring separately.
+Next, we only need to consider the case where the string contains only "a" and "b". If the string contains other characters, we can treat them as split points, dividing the string into several substrings that contain only "a" and "b", and then calculate the score for each substring separately.
-We observe that, for a substring containing only "a" and "b", no matter what operations are taken, in the end, there will only be one type of character left, or an empty string. Since each operation will delete one "a" and one "b" simultaneously, the total number of operations is fixed. We can greedily delete "ab" first, then "ba", to ensure the maximum score.
+We observe that for a substring containing only "a" and "b", no matter what operations we take, we will eventually be left with only one type of character, or an empty string. Since each operation removes one "a" and one "b" simultaneously, the total number of operations is fixed. We can greedily remove "ab" first, then remove "ba", which ensures the maximum score.
-Therefore, we can use two variables $\textit{cnt1}$ and $\textit{cnt2}$ to record the number of "a" and "b", respectively. Then, we traverse the string, update $\textit{cnt1}$ and $\textit{cnt2}$ based on the current character, and calculate the score.
+Therefore, we can use two variables $\textit{cnt1}$ and $\textit{cnt2}$ to record the counts of "a" and "b" respectively, then traverse the string and update $\textit{cnt1}$ and $\textit{cnt2}$ according to different cases of the current character, while calculating the score.
-For the current character $c$:
+For the current character $c$ being traversed:
-- If $c$ is "a", since we need to delete "ab" first, we do not eliminate this character at this time, only increase $\textit{cnt1}$;
-- If $c$ is "b", if $\textit{cnt1} > 0$ at this time, we can eliminate an "ab" and add $x$ points; otherwise, we can only increase $\textit{cnt2}$;
-- If $c$ is another character, then for this substring, we are left with $\textit{cnt2}$ "b" and $\textit{cnt1}$ "a", we can eliminate $\min(\textit{cnt1}, \textit{cnt2})$ "ab" and add $y$ points.
+- If $c$ is "a", since we want to remove "ab" first, we don't eliminate this character at this time, only increment $\textit{cnt1}$;
+- If $c$ is "b", if $\textit{cnt1} > 0$ at this time, we can eliminate one "ab" and add $x$ points; otherwise, we can only increment $\textit{cnt2}$;
+- If $c$ is another character, then for this substring, we have $\textit{cnt2}$ "b"s and $\textit{cnt1}$ "a"s left. We can eliminate $\min(\textit{cnt1}, \textit{cnt2})$ "ba"s and add several $y$ points.
-After the traversal is finished, we also need to additionally handle the remaining "ab", adding several $y$ points.
+After traversal, we need to handle the remaining "ba"s and add several $y$ points.
-The time complexity is $O(n)$, where $n$ is the length of the string $s$. The space complexity is $O(1)$.
+The time complexity is $O(n)$, where $n$ is the length of string $s$. The space complexity is $O(1)$.
@@ -259,6 +259,44 @@ function maximumGain(s: string, x: number, y: number): number {
}
```
+#### Rust
+
+```rust
+impl Solution {
+ pub fn maximum_gain(s: String, mut x: i32, mut y: i32) -> i32 {
+ let (mut a, mut b) = ('a', 'b');
+ if x < y {
+ std::mem::swap(&mut x, &mut y);
+ std::mem::swap(&mut a, &mut b);
+ }
+
+ let mut ans = 0;
+ let mut cnt1 = 0;
+ let mut cnt2 = 0;
+
+ for c in s.chars() {
+ if c == a {
+ cnt1 += 1;
+ } else if c == b {
+ if cnt1 > 0 {
+ ans += x;
+ cnt1 -= 1;
+ } else {
+ cnt2 += 1;
+ }
+ } else {
+ ans += cnt1.min(cnt2) * y;
+ cnt1 = 0;
+ cnt2 = 0;
+ }
+ }
+
+ ans += cnt1.min(cnt2) * y;
+ ans
+ }
+}
+```
+
#### JavaScript
```js
@@ -291,81 +329,38 @@ function maximumGain(s, x, y) {
}
```
-
-
-
-
-
-
-### Solution 2: Greedy + Stack
-
-
-
-#### TypeScript
-
-```ts
-function maximumGain(s: string, x: number, y: number): number {
- const stk: string[] = [];
- const pairs: Record = { a: 'b', b: 'a' };
- const pair = x > y ? ['a', 'b'] : ['b', 'a'];
- let str = [...s];
- let ans = 0;
- let havePairs = true;
-
- while (havePairs) {
- for (const p of pair) {
- havePairs = true;
-
- for (const ch of str) {
- if (stk.at(-1) === p && ch === pairs[p]) {
- stk.pop();
- } else stk.push(ch);
- }
+#### C#
- if (str.length === stk.length) havePairs = false;
-
- const multiplier = p === 'a' ? x : y;
- ans += (multiplier * (str.length - stk.length)) / 2;
- str = [...stk];
- stk.length = 0;
+```cs
+public class Solution {
+ public int MaximumGain(string s, int x, int y) {
+ char a = 'a', b = 'b';
+ if (x < y) {
+ (x, y) = (y, x);
+ (a, b) = (b, a);
}
- }
-
- return ans;
-}
-```
-#### JavaeScript
-
-```js
-function maximumGain(s, x, y) {
- const stk = [];
- const pairs = { a: 'b', b: 'a' };
- const pair = x > y ? ['a', 'b'] : ['b', 'a'];
- let str = [...s];
- let ans = 0;
- let havePairs = true;
-
- while (havePairs) {
- for (const p of pair) {
- havePairs = true;
-
- for (const ch of str) {
- if (stk.at(-1) === p && ch === pairs[p]) {
- stk.pop();
- } else stk.push(ch);
+ int ans = 0, cnt1 = 0, cnt2 = 0;
+ foreach (char c in s) {
+ if (c == a) {
+ cnt1++;
+ } else if (c == b) {
+ if (cnt1 > 0) {
+ ans += x;
+ cnt1--;
+ } else {
+ cnt2++;
+ }
+ } else {
+ ans += Math.Min(cnt1, cnt2) * y;
+ cnt1 = 0;
+ cnt2 = 0;
}
-
- if (str.length === stk.length) havePairs = false;
-
- const multiplier = p === 'a' ? x : y;
- ans += (multiplier * (str.length - stk.length)) / 2;
- str = [...stk];
- stk.length = 0;
}
- }
- return ans;
+ ans += Math.Min(cnt1, cnt2) * y;
+ return ans;
+ }
}
```
diff --git a/solution/1700-1799/1717.Maximum Score From Removing Substrings/Solution.cs b/solution/1700-1799/1717.Maximum Score From Removing Substrings/Solution.cs
new file mode 100644
index 0000000000000..14b0ed2e9eed1
--- /dev/null
+++ b/solution/1700-1799/1717.Maximum Score From Removing Substrings/Solution.cs
@@ -0,0 +1,30 @@
+public class Solution {
+ public int MaximumGain(string s, int x, int y) {
+ char a = 'a', b = 'b';
+ if (x < y) {
+ (x, y) = (y, x);
+ (a, b) = (b, a);
+ }
+
+ int ans = 0, cnt1 = 0, cnt2 = 0;
+ foreach (char c in s) {
+ if (c == a) {
+ cnt1++;
+ } else if (c == b) {
+ if (cnt1 > 0) {
+ ans += x;
+ cnt1--;
+ } else {
+ cnt2++;
+ }
+ } else {
+ ans += Math.Min(cnt1, cnt2) * y;
+ cnt1 = 0;
+ cnt2 = 0;
+ }
+ }
+
+ ans += Math.Min(cnt1, cnt2) * y;
+ return ans;
+ }
+}
diff --git a/solution/1700-1799/1717.Maximum Score From Removing Substrings/Solution.rs b/solution/1700-1799/1717.Maximum Score From Removing Substrings/Solution.rs
new file mode 100644
index 0000000000000..b36a061bd38bc
--- /dev/null
+++ b/solution/1700-1799/1717.Maximum Score From Removing Substrings/Solution.rs
@@ -0,0 +1,33 @@
+impl Solution {
+ pub fn maximum_gain(s: String, mut x: i32, mut y: i32) -> i32 {
+ let (mut a, mut b) = ('a', 'b');
+ if x < y {
+ std::mem::swap(&mut x, &mut y);
+ std::mem::swap(&mut a, &mut b);
+ }
+
+ let mut ans = 0;
+ let mut cnt1 = 0;
+ let mut cnt2 = 0;
+
+ for c in s.chars() {
+ if c == a {
+ cnt1 += 1;
+ } else if c == b {
+ if cnt1 > 0 {
+ ans += x;
+ cnt1 -= 1;
+ } else {
+ cnt2 += 1;
+ }
+ } else {
+ ans += cnt1.min(cnt2) * y;
+ cnt1 = 0;
+ cnt2 = 0;
+ }
+ }
+
+ ans += cnt1.min(cnt2) * y;
+ ans
+ }
+}
diff --git a/solution/1700-1799/1717.Maximum Score From Removing Substrings/Solution2.js b/solution/1700-1799/1717.Maximum Score From Removing Substrings/Solution2.js
deleted file mode 100644
index 52b060f133f78..0000000000000
--- a/solution/1700-1799/1717.Maximum Score From Removing Substrings/Solution2.js
+++ /dev/null
@@ -1,29 +0,0 @@
-function maximumGain(s, x, y) {
- const stk = [];
- const pairs = { a: 'b', b: 'a' };
- const pair = x > y ? ['a', 'b'] : ['b', 'a'];
- let str = [...s];
- let ans = 0;
- let havePairs = true;
-
- while (havePairs) {
- for (const p of pair) {
- havePairs = true;
-
- for (const ch of str) {
- if (stk.at(-1) === p && ch === pairs[p]) {
- stk.pop();
- } else stk.push(ch);
- }
-
- if (str.length === stk.length) havePairs = false;
-
- const multiplier = p === 'a' ? x : y;
- ans += (multiplier * (str.length - stk.length)) / 2;
- str = [...stk];
- stk.length = 0;
- }
- }
-
- return ans;
-}
diff --git a/solution/1700-1799/1717.Maximum Score From Removing Substrings/Solution2.ts b/solution/1700-1799/1717.Maximum Score From Removing Substrings/Solution2.ts
deleted file mode 100644
index f4ed700d88a27..0000000000000
--- a/solution/1700-1799/1717.Maximum Score From Removing Substrings/Solution2.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-function maximumGain(s: string, x: number, y: number): number {
- const stk: string[] = [];
- const pairs: Record = { a: 'b', b: 'a' };
- const pair = x > y ? ['a', 'b'] : ['b', 'a'];
- let str = [...s];
- let ans = 0;
- let havePairs = true;
-
- while (havePairs) {
- for (const p of pair) {
- havePairs = true;
-
- for (const ch of str) {
- if (stk.at(-1) === p && ch === pairs[p]) {
- stk.pop();
- } else stk.push(ch);
- }
-
- if (str.length === stk.length) havePairs = false;
-
- const multiplier = p === 'a' ? x : y;
- ans += (multiplier * (str.length - stk.length)) / 2;
- str = [...stk];
- stk.length = 0;
- }
- }
-
- return ans;
-}
diff --git a/solution/1700-1799/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 0ae985fff2bd2..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
@@ -257,6 +257,47 @@ function maxValue(events: number[][], k: number): number {
}
```
+#### 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)
+ }
+}
+```
+
@@ -409,6 +450,43 @@ function maxValue(events: number[][], k: number): number {
}
```
+#### 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 571eacd071403..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
@@ -255,6 +255,47 @@ function maxValue(events: number[][], k: number): number {
}
```
+#### 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)
+ }
+}
+```
+
@@ -407,6 +448,43 @@ function maxValue(events: number[][], k: number): number {
}
```
+#### 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.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/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/1761.Minimum Degree of a Connected Trio in a Graph/README.md b/solution/1700-1799/1761.Minimum Degree of a Connected Trio in a Graph/README.md
index 90006eafe2d23..46700b4c52b25 100644
--- a/solution/1700-1799/1761.Minimum Degree of a Connected Trio in a Graph/README.md
+++ b/solution/1700-1799/1761.Minimum Degree of a Connected Trio in a Graph/README.md
@@ -6,6 +6,7 @@ rating: 2005
source: 第 228 场周赛 Q4
tags:
- 图
+ - 枚举
---
diff --git a/solution/1700-1799/1761.Minimum Degree of a Connected Trio in a Graph/README_EN.md b/solution/1700-1799/1761.Minimum Degree of a Connected Trio in a Graph/README_EN.md
index 5fef7b1a02c31..6b78026063035 100644
--- a/solution/1700-1799/1761.Minimum Degree of a Connected Trio in a Graph/README_EN.md
+++ b/solution/1700-1799/1761.Minimum Degree of a Connected Trio in a Graph/README_EN.md
@@ -6,6 +6,7 @@ rating: 2005
source: Weekly Contest 228 Q4
tags:
- Graph
+ - Enumeration
---
diff --git a/solution/1700-1799/1782.Count Pairs Of Nodes/README.md b/solution/1700-1799/1782.Count Pairs Of Nodes/README.md
index 147e25290a894..10d3849c230d2 100644
--- a/solution/1700-1799/1782.Count Pairs Of Nodes/README.md
+++ b/solution/1700-1799/1782.Count Pairs Of Nodes/README.md
@@ -7,8 +7,10 @@ source: 第 47 场双周赛 Q4
tags:
- 图
- 数组
+ - 哈希表
- 双指针
- 二分查找
+ - 计数
- 排序
---
diff --git a/solution/1700-1799/1782.Count Pairs Of Nodes/README_EN.md b/solution/1700-1799/1782.Count Pairs Of Nodes/README_EN.md
index 10717cdd494c1..27fce30218815 100644
--- a/solution/1700-1799/1782.Count Pairs Of Nodes/README_EN.md
+++ b/solution/1700-1799/1782.Count Pairs Of Nodes/README_EN.md
@@ -7,8 +7,10 @@ source: Biweekly Contest 47 Q4
tags:
- Graph
- Array
+ - Hash Table
- Two Pointers
- Binary Search
+ - Counting
- Sorting
---
diff --git a/solution/1800-1899/1858.Longest Word With All Prefixes/README.md b/solution/1800-1899/1858.Longest Word With All Prefixes/README.md
index 98319b2b037cc..ac042587d5839 100644
--- a/solution/1800-1899/1858.Longest Word With All Prefixes/README.md
+++ b/solution/1800-1899/1858.Longest Word With All Prefixes/README.md
@@ -5,6 +5,8 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/1800-1899/1858.Lo
tags:
- 深度优先搜索
- 字典树
+ - 数组
+ - 字符串
---
diff --git a/solution/1800-1899/1858.Longest Word With All Prefixes/README_EN.md b/solution/1800-1899/1858.Longest Word With All Prefixes/README_EN.md
index c9983247f32f8..0ebd12e11de1a 100644
--- a/solution/1800-1899/1858.Longest Word With All Prefixes/README_EN.md
+++ b/solution/1800-1899/1858.Longest Word With All Prefixes/README_EN.md
@@ -5,6 +5,8 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/1800-1899/1858.Lo
tags:
- Depth-First Search
- Trie
+ - Array
+ - String
---
diff --git a/solution/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/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/README.md b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/README.md
index 6e138b23b3d9f..afaa23d0616a1 100644
--- a/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/README.md
+++ b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/README.md
@@ -82,41 +82,341 @@ tags:
-### 方法一
+### 方法一：记忆化搜索 + 二进制枚举
+
+我们定义一个函数 $\text{dfs}(l, r, n)$，表示在当前回合中，编号为 $l$ 和 $r$ 的运动员在 $n$ 名运动员中比拼的最早和最晚回合数。
+
+函数 $\text{dfs}(l, r, n)$ 的执行逻辑如下：
+
+1. 如果 $l + r = n - 1$，说明两名运动员在当前回合中比拼，返回 $[1, 1]$。
+2. 如果 $f[l][r][n] \neq 0$，说明之前已经计算过这个状态，直接返回结果。
+3. 初始化最早回合数为正无穷大，最晚回合数为负无穷大。
+4. 计算当前回合中前半部分的运动员数目 $m = n / 2$。
+5. 枚举前半部分的所有可能的胜者组合（使用二进制枚举），对于每一种组合：
+ - 根据当前组合确定哪些运动员获胜。
+ - 确定当前回合中编号为 $l$ 和 $r$ 的运动员在当前回合中的位置。
+ - 统计当前回合中编号为 $l$ 和 $r$ 的运动员在剩余运动员中的位置，记为 $a$ 和 $b$，以及剩余运动员的总数 $c$。
+ - 递归调用 $\text{dfs}(a, b, c)$，获取当前状态的最早和最晚回合数。
+ - 更新最早回合数和最晚回合数。
+6. 将计算结果存储在 $f[l][r][n]$ 中，并返回最早和最晚回合数。
+
+答案为 $\text{dfs}(\text{firstPlayer} - 1, \text{secondPlayer} - 1, n)$。
#### Python3
```python
+@cache
+def dfs(l: int, r: int, n: int):
+ if l + r == n - 1:
+ return [1, 1]
+ res = [inf, -inf]
+ m = n >> 1
+ for i in range(1 << m):
+ win = [False] * n
+ for j in range(m):
+ if i >> j & 1:
+ win[j] = True
+ else:
+ win[n - 1 - j] = True
+ if n & 1:
+ win[m] = True
+ win[n - 1 - l] = win[n - 1 - r] = False
+ win[l] = win[r] = True
+ a = b = c = 0
+ for j in range(n):
+ if j == l:
+ a = c
+ if j == r:
+ b = c
+ if win[j]:
+ c += 1
+ x, y = dfs(a, b, c)
+ res[0] = min(res[0], x + 1)
+ res[1] = max(res[1], y + 1)
+ return res
+
+
class Solution:
def earliestAndLatest(
self, n: int, firstPlayer: int, secondPlayer: int
) -> List[int]:
- # dp[i][j][k] := (earliest, latest) pair w/ firstPlayer is i-th player from
- # Front, secondPlayer is j-th player from end, and there're k people
- @functools.lru_cache(None)
- def dp(l: int, r: int, k: int) -> List[int]:
- if l == r:
- return [1, 1]
- if l > r:
- return dp(r, l, k)
-
- a = math.inf
- b = -math.inf
-
- # Enumerate all possible positions
- for i in range(1, l + 1):
- for j in range(l - i + 1, r - i + 1):
- if not l + r - k // 2 <= i + j <= (k + 1) // 2:
- continue
- x, y = dp(i, j, (k + 1) // 2)
- a = min(a, x + 1)
- b = max(b, y + 1)
-
- return [a, b]
-
- return dp(firstPlayer, n - secondPlayer + 1, n)
+ return dfs(firstPlayer - 1, secondPlayer - 1, n)
+```
+
+#### Java
+
+```java
+class Solution {
+ static int[][][] f = new int[30][30][31];
+
+ public int[] earliestAndLatest(int n, int firstPlayer, int secondPlayer) {
+ return dfs(firstPlayer - 1, secondPlayer - 1, n);
+ }
+
+ private int[] dfs(int l, int r, int n) {
+ if (f[l][r][n] != 0) {
+ return decode(f[l][r][n]);
+ }
+ if (l + r == n - 1) {
+ f[l][r][n] = encode(1, 1);
+ return new int[] {1, 1};
+ }
+ int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;
+ int m = n >> 1;
+ for (int i = 0; i < (1 << m); i++) {
+ boolean[] win = new boolean[n];
+ for (int j = 0; j < m; j++) {
+ if (((i >> j) & 1) == 1) {
+ win[j] = true;
+ } else {
+ win[n - 1 - j] = true;
+ }
+ }
+ if ((n & 1) == 1) {
+ win[m] = true;
+ }
+ win[n - 1 - l] = win[n - 1 - r] = false;
+ win[l] = win[r] = true;
+ int a = 0, b = 0, c = 0;
+ for (int j = 0; j < n; j++) {
+ if (j == l) {
+ a = c;
+ }
+ if (j == r) {
+ b = c;
+ }
+ if (win[j]) {
+ c++;
+ }
+ }
+ int[] t = dfs(a, b, c);
+ min = Math.min(min, t[0] + 1);
+ max = Math.max(max, t[1] + 1);
+ }
+ f[l][r][n] = encode(min, max);
+ return new int[] {min, max};
+ }
+
+ private int encode(int x, int y) {
+ return (x << 8) | y;
+ }
+
+ private int[] decode(int val) {
+ return new int[] {val >> 8, val & 255};
+ }
+}
+```
+
+#### C++
+
+```cpp
+int f[30][30][31];
+class Solution {
+public:
+ vector earliestAndLatest(int n, int firstPlayer, int secondPlayer) {
+ return dfs(firstPlayer - 1, secondPlayer - 1, n);
+ }
+
+private:
+ vector dfs(int l, int r, int n) {
+ if (f[l][r][n] != 0) {
+ return decode(f[l][r][n]);
+ }
+ if (l + r == n - 1) {
+ f[l][r][n] = encode(1, 1);
+ return {1, 1};
+ }
+
+ int min = INT_MAX, max = INT_MIN;
+ int m = n >> 1;
+
+ for (int i = 0; i < (1 << m); i++) {
+ vector win(n, false);
+ for (int j = 0; j < m; j++) {
+ if ((i >> j) & 1) {
+ win[j] = true;
+ } else {
+ win[n - 1 - j] = true;
+ }
+ }
+ if (n & 1) {
+ win[m] = true;
+ }
+
+ win[n - 1 - l] = false;
+ win[n - 1 - r] = false;
+ win[l] = true;
+ win[r] = true;
+
+ int a = 0, b = 0, c = 0;
+ for (int j = 0; j < n; j++) {
+ if (j == l) a = c;
+ if (j == r) b = c;
+ if (win[j]) c++;
+ }
+
+ vector t = dfs(a, b, c);
+ min = std::min(min, t[0] + 1);
+ max = std::max(max, t[1] + 1);
+ }
+
+ f[l][r][n] = encode(min, max);
+ return {min, max};
+ }
+
+ int encode(int x, int y) {
+ return (x << 8) | y;
+ }
+
+ vector decode(int val) {
+ return {val >> 8, val & 255};
+ }
+};
+```
+
+#### Go
+
+```go
+var f [30][30][31]int
+
+func earliestAndLatest(n int, firstPlayer int, secondPlayer int) []int {
+ return dfs(firstPlayer-1, secondPlayer-1, n)
+}
+
+func dfs(l, r, n int) []int {
+ if f[l][r][n] != 0 {
+ return decode(f[l][r][n])
+ }
+ if l+r == n-1 {
+ f[l][r][n] = encode(1, 1)
+ return []int{1, 1}
+ }
+
+ min, max := 1<<30, -1<<31
+ m := n >> 1
+
+ for i := 0; i < (1 << m); i++ {
+ win := make([]bool, n)
+ for j := 0; j < m; j++ {
+ if (i>>j)&1 == 1 {
+ win[j] = true
+ } else {
+ win[n-1-j] = true
+ }
+ }
+ if n&1 == 1 {
+ win[m] = true
+ }
+ win[n-1-l] = false
+ win[n-1-r] = false
+ win[l] = true
+ win[r] = true
+
+ a, b, c := 0, 0, 0
+ for j := 0; j < n; j++ {
+ if j == l {
+ a = c
+ }
+ if j == r {
+ b = c
+ }
+ if win[j] {
+ c++
+ }
+ }
+
+ t := dfs(a, b, c)
+ if t[0]+1 < min {
+ min = t[0] + 1
+ }
+ if t[1]+1 > max {
+ max = t[1] + 1
+ }
+ }
+
+ f[l][r][n] = encode(min, max)
+ return []int{min, max}
+}
+
+func encode(x, y int) int {
+ return (x << 8) | y
+}
+
+func decode(val int) []int {
+ return []int{val >> 8, val & 255}
+}
+```
+
+#### TypeScript
+
+```ts
+function earliestAndLatest(n: number, firstPlayer: number, secondPlayer: number): number[] {
+ return dfs(firstPlayer - 1, secondPlayer - 1, n);
+}
+
+const f: number[][][] = Array.from({ length: 30 }, () =>
+ Array.from({ length: 30 }, () => Array(31).fill(0)),
+);
+
+function dfs(l: number, r: number, n: number): number[] {
+ if (f[l][r][n] !== 0) {
+ return decode(f[l][r][n]);
+ }
+ if (l + r === n - 1) {
+ f[l][r][n] = encode(1, 1);
+ return [1, 1];
+ }
+
+ let min = Number.MAX_SAFE_INTEGER;
+ let max = Number.MIN_SAFE_INTEGER;
+ const m = n >> 1;
+
+ for (let i = 0; i < 1 << m; i++) {
+ const win: boolean[] = Array(n).fill(false);
+ for (let j = 0; j < m; j++) {
+ if ((i >> j) & 1) {
+ win[j] = true;
+ } else {
+ win[n - 1 - j] = true;
+ }
+ }
+
+ if (n & 1) {
+ win[m] = true;
+ }
+
+ win[n - 1 - l] = false;
+ win[n - 1 - r] = false;
+ win[l] = true;
+ win[r] = true;
+
+ let a = 0,
+ b = 0,
+ c = 0;
+ for (let j = 0; j < n; j++) {
+ if (j === l) a = c;
+ if (j === r) b = c;
+ if (win[j]) c++;
+ }
+
+ const t = dfs(a, b, c);
+ min = Math.min(min, t[0] + 1);
+ max = Math.max(max, t[1] + 1);
+ }
+
+ f[l][r][n] = encode(min, max);
+ return [min, max];
+}
+
+function encode(x: number, y: number): number {
+ return (x << 8) | y;
+}
+
+function decode(val: number): number[] {
+ return [val >> 8, val & 255];
+}
```
diff --git a/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/README_EN.md b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/README_EN.md
index e53be4a5412c8..a1b7924f02ebe 100644
--- a/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/README_EN.md
+++ b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/README_EN.md
@@ -82,41 +82,341 @@ There is no way to make them compete in any other round.
-### Solution 1
+### Solution 1: Memoization + Binary Enumeration
+
+We define a function $\text{dfs}(l, r, n)$, which represents the earliest and latest rounds where players numbered $l$ and $r$ compete among $n$ players in the current round.
+
+The execution logic of function $\text{dfs}(l, r, n)$ is as follows:
+
+1. If $l + r = n - 1$, it means the two players compete in the current round, return $[1, 1]$.
+2. If $f[l][r][n] \neq 0$, it means this state has been calculated before, directly return the result.
+3. Initialize the earliest round number as positive infinity and the latest round number as negative infinity.
+4. Calculate the number of players in the first half of the current round $m = n / 2$.
+5. Enumerate all possible winner combinations of the first half (using binary enumeration), for each combination:
+ - Determine which players win based on the current combination.
+ - Determine the positions of players numbered $l$ and $r$ in the current round.
+ - Count the positions of players numbered $l$ and $r$ among the remaining players, denoted as $a$ and $b$, and the total number of remaining players $c$.
+ - Recursively call $\text{dfs}(a, b, c)$ to get the earliest and latest round numbers for the current state.
+ - Update the earliest and latest round numbers.
+6. Store the calculation result in $f[l][r][n]$ and return the earliest and latest round numbers.
+
+The answer is $\text{dfs}(\text{firstPlayer} - 1, \text{secondPlayer} - 1, n)$.
#### Python3
```python
+@cache
+def dfs(l: int, r: int, n: int):
+ if l + r == n - 1:
+ return [1, 1]
+ res = [inf, -inf]
+ m = n >> 1
+ for i in range(1 << m):
+ win = [False] * n
+ for j in range(m):
+ if i >> j & 1:
+ win[j] = True
+ else:
+ win[n - 1 - j] = True
+ if n & 1:
+ win[m] = True
+ win[n - 1 - l] = win[n - 1 - r] = False
+ win[l] = win[r] = True
+ a = b = c = 0
+ for j in range(n):
+ if j == l:
+ a = c
+ if j == r:
+ b = c
+ if win[j]:
+ c += 1
+ x, y = dfs(a, b, c)
+ res[0] = min(res[0], x + 1)
+ res[1] = max(res[1], y + 1)
+ return res
+
+
class Solution:
def earliestAndLatest(
self, n: int, firstPlayer: int, secondPlayer: int
) -> List[int]:
- # dp[i][j][k] := (earliest, latest) pair w/ firstPlayer is i-th player from
- # Front, secondPlayer is j-th player from end, and there're k people
- @functools.lru_cache(None)
- def dp(l: int, r: int, k: int) -> List[int]:
- if l == r:
- return [1, 1]
- if l > r:
- return dp(r, l, k)
-
- a = math.inf
- b = -math.inf
-
- # Enumerate all possible positions
- for i in range(1, l + 1):
- for j in range(l - i + 1, r - i + 1):
- if not l + r - k // 2 <= i + j <= (k + 1) // 2:
- continue
- x, y = dp(i, j, (k + 1) // 2)
- a = min(a, x + 1)
- b = max(b, y + 1)
-
- return [a, b]
-
- return dp(firstPlayer, n - secondPlayer + 1, n)
+ return dfs(firstPlayer - 1, secondPlayer - 1, n)
+```
+
+#### Java
+
+```java
+class Solution {
+ static int[][][] f = new int[30][30][31];
+
+ public int[] earliestAndLatest(int n, int firstPlayer, int secondPlayer) {
+ return dfs(firstPlayer - 1, secondPlayer - 1, n);
+ }
+
+ private int[] dfs(int l, int r, int n) {
+ if (f[l][r][n] != 0) {
+ return decode(f[l][r][n]);
+ }
+ if (l + r == n - 1) {
+ f[l][r][n] = encode(1, 1);
+ return new int[] {1, 1};
+ }
+ int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;
+ int m = n >> 1;
+ for (int i = 0; i < (1 << m); i++) {
+ boolean[] win = new boolean[n];
+ for (int j = 0; j < m; j++) {
+ if (((i >> j) & 1) == 1) {
+ win[j] = true;
+ } else {
+ win[n - 1 - j] = true;
+ }
+ }
+ if ((n & 1) == 1) {
+ win[m] = true;
+ }
+ win[n - 1 - l] = win[n - 1 - r] = false;
+ win[l] = win[r] = true;
+ int a = 0, b = 0, c = 0;
+ for (int j = 0; j < n; j++) {
+ if (j == l) {
+ a = c;
+ }
+ if (j == r) {
+ b = c;
+ }
+ if (win[j]) {
+ c++;
+ }
+ }
+ int[] t = dfs(a, b, c);
+ min = Math.min(min, t[0] + 1);
+ max = Math.max(max, t[1] + 1);
+ }
+ f[l][r][n] = encode(min, max);
+ return new int[] {min, max};
+ }
+
+ private int encode(int x, int y) {
+ return (x << 8) | y;
+ }
+
+ private int[] decode(int val) {
+ return new int[] {val >> 8, val & 255};
+ }
+}
+```
+
+#### C++
+
+```cpp
+int f[30][30][31];
+class Solution {
+public:
+ vector earliestAndLatest(int n, int firstPlayer, int secondPlayer) {
+ return dfs(firstPlayer - 1, secondPlayer - 1, n);
+ }
+
+private:
+ vector dfs(int l, int r, int n) {
+ if (f[l][r][n] != 0) {
+ return decode(f[l][r][n]);
+ }
+ if (l + r == n - 1) {
+ f[l][r][n] = encode(1, 1);
+ return {1, 1};
+ }
+
+ int min = INT_MAX, max = INT_MIN;
+ int m = n >> 1;
+
+ for (int i = 0; i < (1 << m); i++) {
+ vector win(n, false);
+ for (int j = 0; j < m; j++) {
+ if ((i >> j) & 1) {
+ win[j] = true;
+ } else {
+ win[n - 1 - j] = true;
+ }
+ }
+ if (n & 1) {
+ win[m] = true;
+ }
+
+ win[n - 1 - l] = false;
+ win[n - 1 - r] = false;
+ win[l] = true;
+ win[r] = true;
+
+ int a = 0, b = 0, c = 0;
+ for (int j = 0; j < n; j++) {
+ if (j == l) a = c;
+ if (j == r) b = c;
+ if (win[j]) c++;
+ }
+
+ vector t = dfs(a, b, c);
+ min = std::min(min, t[0] + 1);
+ max = std::max(max, t[1] + 1);
+ }
+
+ f[l][r][n] = encode(min, max);
+ return {min, max};
+ }
+
+ int encode(int x, int y) {
+ return (x << 8) | y;
+ }
+
+ vector decode(int val) {
+ return {val >> 8, val & 255};
+ }
+};
+```
+
+#### Go
+
+```go
+var f [30][30][31]int
+
+func earliestAndLatest(n int, firstPlayer int, secondPlayer int) []int {
+ return dfs(firstPlayer-1, secondPlayer-1, n)
+}
+
+func dfs(l, r, n int) []int {
+ if f[l][r][n] != 0 {
+ return decode(f[l][r][n])
+ }
+ if l+r == n-1 {
+ f[l][r][n] = encode(1, 1)
+ return []int{1, 1}
+ }
+
+ min, max := 1<<30, -1<<31
+ m := n >> 1
+
+ for i := 0; i < (1 << m); i++ {
+ win := make([]bool, n)
+ for j := 0; j < m; j++ {
+ if (i>>j)&1 == 1 {
+ win[j] = true
+ } else {
+ win[n-1-j] = true
+ }
+ }
+ if n&1 == 1 {
+ win[m] = true
+ }
+ win[n-1-l] = false
+ win[n-1-r] = false
+ win[l] = true
+ win[r] = true
+
+ a, b, c := 0, 0, 0
+ for j := 0; j < n; j++ {
+ if j == l {
+ a = c
+ }
+ if j == r {
+ b = c
+ }
+ if win[j] {
+ c++
+ }
+ }
+
+ t := dfs(a, b, c)
+ if t[0]+1 < min {
+ min = t[0] + 1
+ }
+ if t[1]+1 > max {
+ max = t[1] + 1
+ }
+ }
+
+ f[l][r][n] = encode(min, max)
+ return []int{min, max}
+}
+
+func encode(x, y int) int {
+ return (x << 8) | y
+}
+
+func decode(val int) []int {
+ return []int{val >> 8, val & 255}
+}
+```
+
+#### TypeScript
+
+```ts
+function earliestAndLatest(n: number, firstPlayer: number, secondPlayer: number): number[] {
+ return dfs(firstPlayer - 1, secondPlayer - 1, n);
+}
+
+const f: number[][][] = Array.from({ length: 30 }, () =>
+ Array.from({ length: 30 }, () => Array(31).fill(0)),
+);
+
+function dfs(l: number, r: number, n: number): number[] {
+ if (f[l][r][n] !== 0) {
+ return decode(f[l][r][n]);
+ }
+ if (l + r === n - 1) {
+ f[l][r][n] = encode(1, 1);
+ return [1, 1];
+ }
+
+ let min = Number.MAX_SAFE_INTEGER;
+ let max = Number.MIN_SAFE_INTEGER;
+ const m = n >> 1;
+
+ for (let i = 0; i < 1 << m; i++) {
+ const win: boolean[] = Array(n).fill(false);
+ for (let j = 0; j < m; j++) {
+ if ((i >> j) & 1) {
+ win[j] = true;
+ } else {
+ win[n - 1 - j] = true;
+ }
+ }
+
+ if (n & 1) {
+ win[m] = true;
+ }
+
+ win[n - 1 - l] = false;
+ win[n - 1 - r] = false;
+ win[l] = true;
+ win[r] = true;
+
+ let a = 0,
+ b = 0,
+ c = 0;
+ for (let j = 0; j < n; j++) {
+ if (j === l) a = c;
+ if (j === r) b = c;
+ if (win[j]) c++;
+ }
+
+ const t = dfs(a, b, c);
+ min = Math.min(min, t[0] + 1);
+ max = Math.max(max, t[1] + 1);
+ }
+
+ f[l][r][n] = encode(min, max);
+ return [min, max];
+}
+
+function encode(x: number, y: number): number {
+ return (x << 8) | y;
+}
+
+function decode(val: number): number[] {
+ return [val >> 8, val & 255];
+}
```
diff --git a/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.cpp b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.cpp
new file mode 100644
index 0000000000000..d274dc8ce825a
--- /dev/null
+++ b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.cpp
@@ -0,0 +1,62 @@
+int f[30][30][31];
+class Solution {
+public:
+ vector earliestAndLatest(int n, int firstPlayer, int secondPlayer) {
+ return dfs(firstPlayer - 1, secondPlayer - 1, n);
+ }
+
+private:
+ vector dfs(int l, int r, int n) {
+ if (f[l][r][n] != 0) {
+ return decode(f[l][r][n]);
+ }
+ if (l + r == n - 1) {
+ f[l][r][n] = encode(1, 1);
+ return {1, 1};
+ }
+
+ int min = INT_MAX, max = INT_MIN;
+ int m = n >> 1;
+
+ for (int i = 0; i < (1 << m); i++) {
+ vector win(n, false);
+ for (int j = 0; j < m; j++) {
+ if ((i >> j) & 1) {
+ win[j] = true;
+ } else {
+ win[n - 1 - j] = true;
+ }
+ }
+ if (n & 1) {
+ win[m] = true;
+ }
+
+ win[n - 1 - l] = false;
+ win[n - 1 - r] = false;
+ win[l] = true;
+ win[r] = true;
+
+ int a = 0, b = 0, c = 0;
+ for (int j = 0; j < n; j++) {
+ if (j == l) a = c;
+ if (j == r) b = c;
+ if (win[j]) c++;
+ }
+
+ vector t = dfs(a, b, c);
+ min = std::min(min, t[0] + 1);
+ max = std::max(max, t[1] + 1);
+ }
+
+ f[l][r][n] = encode(min, max);
+ return {min, max};
+ }
+
+ int encode(int x, int y) {
+ return (x << 8) | y;
+ }
+
+ vector decode(int val) {
+ return {val >> 8, val & 255};
+ }
+};
\ No newline at end of file
diff --git a/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.go b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.go
new file mode 100644
index 0000000000000..c7c4473015c3c
--- /dev/null
+++ b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.go
@@ -0,0 +1,68 @@
+var f [30][30][31]int
+
+func earliestAndLatest(n int, firstPlayer int, secondPlayer int) []int {
+ return dfs(firstPlayer-1, secondPlayer-1, n)
+}
+
+func dfs(l, r, n int) []int {
+ if f[l][r][n] != 0 {
+ return decode(f[l][r][n])
+ }
+ if l+r == n-1 {
+ f[l][r][n] = encode(1, 1)
+ return []int{1, 1}
+ }
+
+ min, max := 1<<30, -1<<31
+ m := n >> 1
+
+ for i := 0; i < (1 << m); i++ {
+ win := make([]bool, n)
+ for j := 0; j < m; j++ {
+ if (i>>j)&1 == 1 {
+ win[j] = true
+ } else {
+ win[n-1-j] = true
+ }
+ }
+ if n&1 == 1 {
+ win[m] = true
+ }
+ win[n-1-l] = false
+ win[n-1-r] = false
+ win[l] = true
+ win[r] = true
+
+ a, b, c := 0, 0, 0
+ for j := 0; j < n; j++ {
+ if j == l {
+ a = c
+ }
+ if j == r {
+ b = c
+ }
+ if win[j] {
+ c++
+ }
+ }
+
+ t := dfs(a, b, c)
+ if t[0]+1 < min {
+ min = t[0] + 1
+ }
+ if t[1]+1 > max {
+ max = t[1] + 1
+ }
+ }
+
+ f[l][r][n] = encode(min, max)
+ return []int{min, max}
+}
+
+func encode(x, y int) int {
+ return (x << 8) | y
+}
+
+func decode(val int) []int {
+ return []int{val >> 8, val & 255}
+}
diff --git a/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.java b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.java
new file mode 100644
index 0000000000000..e9786bf268209
--- /dev/null
+++ b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.java
@@ -0,0 +1,59 @@
+class Solution {
+ static int[][][] f = new int[30][30][31];
+
+ public int[] earliestAndLatest(int n, int firstPlayer, int secondPlayer) {
+ return dfs(firstPlayer - 1, secondPlayer - 1, n);
+ }
+
+ private int[] dfs(int l, int r, int n) {
+ if (f[l][r][n] != 0) {
+ return decode(f[l][r][n]);
+ }
+ if (l + r == n - 1) {
+ f[l][r][n] = encode(1, 1);
+ return new int[] {1, 1};
+ }
+ int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;
+ int m = n >> 1;
+ for (int i = 0; i < (1 << m); i++) {
+ boolean[] win = new boolean[n];
+ for (int j = 0; j < m; j++) {
+ if (((i >> j) & 1) == 1) {
+ win[j] = true;
+ } else {
+ win[n - 1 - j] = true;
+ }
+ }
+ if ((n & 1) == 1) {
+ win[m] = true;
+ }
+ win[n - 1 - l] = win[n - 1 - r] = false;
+ win[l] = win[r] = true;
+ int a = 0, b = 0, c = 0;
+ for (int j = 0; j < n; j++) {
+ if (j == l) {
+ a = c;
+ }
+ if (j == r) {
+ b = c;
+ }
+ if (win[j]) {
+ c++;
+ }
+ }
+ int[] t = dfs(a, b, c);
+ min = Math.min(min, t[0] + 1);
+ max = Math.max(max, t[1] + 1);
+ }
+ f[l][r][n] = encode(min, max);
+ return new int[] {min, max};
+ }
+
+ private int encode(int x, int y) {
+ return (x << 8) | y;
+ }
+
+ private int[] decode(int val) {
+ return new int[] {val >> 8, val & 255};
+ }
+}
diff --git a/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.py b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.py
index f16f724b7a0ab..ecdb1da17d8cc 100644
--- a/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.py
+++ b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.py
@@ -1,28 +1,36 @@
+@cache
+def dfs(l: int, r: int, n: int):
+ if l + r == n - 1:
+ return [1, 1]
+ res = [inf, -inf]
+ m = n >> 1
+ for i in range(1 << m):
+ win = [False] * n
+ for j in range(m):
+ if i >> j & 1:
+ win[j] = True
+ else:
+ win[n - 1 - j] = True
+ if n & 1:
+ win[m] = True
+ win[n - 1 - l] = win[n - 1 - r] = False
+ win[l] = win[r] = True
+ a = b = c = 0
+ for j in range(n):
+ if j == l:
+ a = c
+ if j == r:
+ b = c
+ if win[j]:
+ c += 1
+ x, y = dfs(a, b, c)
+ res[0] = min(res[0], x + 1)
+ res[1] = max(res[1], y + 1)
+ return res
+
+
class Solution:
def earliestAndLatest(
self, n: int, firstPlayer: int, secondPlayer: int
) -> List[int]:
- # dp[i][j][k] := (earliest, latest) pair w/ firstPlayer is i-th player from
- # Front, secondPlayer is j-th player from end, and there're k people
- @functools.lru_cache(None)
- def dp(l: int, r: int, k: int) -> List[int]:
- if l == r:
- return [1, 1]
- if l > r:
- return dp(r, l, k)
-
- a = math.inf
- b = -math.inf
-
- # Enumerate all possible positions
- for i in range(1, l + 1):
- for j in range(l - i + 1, r - i + 1):
- if not l + r - k // 2 <= i + j <= (k + 1) // 2:
- continue
- x, y = dp(i, j, (k + 1) // 2)
- a = min(a, x + 1)
- b = max(b, y + 1)
-
- return [a, b]
-
- return dp(firstPlayer, n - secondPlayer + 1, n)
+ return dfs(firstPlayer - 1, secondPlayer - 1, n)
diff --git a/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.ts b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.ts
new file mode 100644
index 0000000000000..4c0797ca5804c
--- /dev/null
+++ b/solution/1900-1999/1900.The Earliest and Latest Rounds Where Players Compete/Solution.ts
@@ -0,0 +1,65 @@
+function earliestAndLatest(n: number, firstPlayer: number, secondPlayer: number): number[] {
+ return dfs(firstPlayer - 1, secondPlayer - 1, n);
+}
+
+const f: number[][][] = Array.from({ length: 30 }, () =>
+ Array.from({ length: 30 }, () => Array(31).fill(0)),
+);
+
+function dfs(l: number, r: number, n: number): number[] {
+ if (f[l][r][n] !== 0) {
+ return decode(f[l][r][n]);
+ }
+ if (l + r === n - 1) {
+ f[l][r][n] = encode(1, 1);
+ return [1, 1];
+ }
+
+ let min = Number.MAX_SAFE_INTEGER;
+ let max = Number.MIN_SAFE_INTEGER;
+ const m = n >> 1;
+
+ for (let i = 0; i < 1 << m; i++) {
+ const win: boolean[] = Array(n).fill(false);
+ for (let j = 0; j < m; j++) {
+ if ((i >> j) & 1) {
+ win[j] = true;
+ } else {
+ win[n - 1 - j] = true;
+ }
+ }
+
+ if (n & 1) {
+ win[m] = true;
+ }
+
+ win[n - 1 - l] = false;
+ win[n - 1 - r] = false;
+ win[l] = true;
+ win[r] = true;
+
+ let a = 0,
+ b = 0,
+ c = 0;
+ for (let j = 0; j < n; j++) {
+ if (j === l) a = c;
+ if (j === r) b = c;
+ if (win[j]) c++;
+ }
+
+ const t = dfs(a, b, c);
+ min = Math.min(min, t[0] + 1);
+ max = Math.max(max, t[1] + 1);
+ }
+
+ f[l][r][n] = encode(min, max);
+ return [min, max];
+}
+
+function encode(x: number, y: number): number {
+ return (x << 8) | y;
+}
+
+function decode(val: number): number[] {
+ return [val >> 8, val & 255];
+}
diff --git a/solution/1900-1999/1948.Delete Duplicate Folders in System/README.md b/solution/1900-1999/1948.Delete Duplicate Folders in System/README.md
index d3255436fb79c..073d0a88e91b7 100644
--- a/solution/1900-1999/1948.Delete Duplicate Folders in System/README.md
+++ b/solution/1900-1999/1948.Delete Duplicate Folders in System/README.md
@@ -122,32 +122,348 @@ tags:
-### 方法一
+### 方法一：字典树 + DFS
+
+我们可以使用字典树来存储文件夹的结构，字典树的每个节点数据如下：
+
+- `children`：一个字典，键为子文件夹的名称，值为对应的子节点。
+- `deleted`：一个布尔值，表示该节点是否被标记为待删除。
+
+我们将所有路径插入到字典树中，然后使用 DFS 遍历字典树，构建每个子树的字符串表示。对于每个子树，如果它的字符串表示已经存在于一个全局字典中，则将该节点和全局字典中的对应节点都标记为待删除。最后，再次使用 DFS 遍历字典树，将未被标记的节点的路径添加到结果列表中。
#### Python3
```python
-
+class Trie:
+ def __init__(self):
+ self.children: Dict[str, "Trie"] = defaultdict(Trie)
+ self.deleted: bool = False
+
+
+class Solution:
+ def deleteDuplicateFolder(self, paths: List[List[str]]) -> List[List[str]]:
+ root = Trie()
+ for path in paths:
+ cur = root
+ for name in path:
+ if cur.children[name] is None:
+ cur.children[name] = Trie()
+ cur = cur.children[name]
+
+ g: Dict[str, Trie] = {}
+
+ def dfs(node: Trie) -> str:
+ if not node.children:
+ return ""
+ subs: List[str] = []
+ for name, child in node.children.items():
+ subs.append(f"{name}({dfs(child)})")
+ s = "".join(sorted(subs))
+ if s in g:
+ node.deleted = g[s].deleted = True
+ else:
+ g[s] = node
+ return s
+
+ def dfs2(node: Trie) -> None:
+ if node.deleted:
+ return
+ if path:
+ ans.append(path[:])
+ for name, child in node.children.items():
+ path.append(name)
+ dfs2(child)
+ path.pop()
+
+ dfs(root)
+ ans: List[List[str]] = []
+ path: List[str] = []
+ dfs2(root)
+ return ans
```
#### Java
```java
-
+class Trie {
+ Map children;
+ boolean deleted;
+
+ public Trie() {
+ children = new HashMap<>();
+ deleted = false;
+ }
+}
+
+class Solution {
+ public List> deleteDuplicateFolder(List> paths) {
+ Trie root = new Trie();
+ for (List path : paths) {
+ Trie cur = root;
+ for (String name : path) {
+ if (!cur.children.containsKey(name)) {
+ cur.children.put(name, new Trie());
+ }
+ cur = cur.children.get(name);
+ }
+ }
+
+ Map g = new HashMap<>();
+
+ var dfs = new Function() {
+ @Override
+ public String apply(Trie node) {
+ if (node.children.isEmpty()) {
+ return "";
+ }
+ List subs = new ArrayList<>();
+ for (var entry : node.children.entrySet()) {
+ subs.add(entry.getKey() + "(" + apply(entry.getValue()) + ")");
+ }
+ Collections.sort(subs);
+ String s = String.join("", subs);
+ if (g.containsKey(s)) {
+ node.deleted = true;
+ g.get(s).deleted = true;
+ } else {
+ g.put(s, node);
+ }
+ return s;
+ }
+ };
+
+ dfs.apply(root);
+
+ List> ans = new ArrayList<>();
+ List path = new ArrayList<>();
+
+ var dfs2 = new Function() {
+ @Override
+ public Void apply(Trie node) {
+ if (node.deleted) {
+ return null;
+ }
+ if (!path.isEmpty()) {
+ ans.add(new ArrayList<>(path));
+ }
+ for (Map.Entry entry : node.children.entrySet()) {
+ path.add(entry.getKey());
+ apply(entry.getValue());
+ path.remove(path.size() - 1);
+ }
+ return null;
+ }
+ };
+
+ dfs2.apply(root);
+
+ return ans;
+ }
+}
```
#### C++
```cpp
-
+class Trie {
+public:
+ unordered_map children;
+ bool deleted = false;
+};
+
+class Solution {
+public:
+ vector> deleteDuplicateFolder(vector>& paths) {
+ Trie* root = new Trie();
+
+ for (auto& path : paths) {
+ Trie* cur = root;
+ for (auto& name : path) {
+ if (cur->children.find(name) == cur->children.end()) {
+ cur->children[name] = new Trie();
+ }
+ cur = cur->children[name];
+ }
+ }
+
+ unordered_map g;
+
+ auto dfs = [&](this auto&& dfs, Trie* node) -> string {
+ if (node->children.empty()) return "";
+
+ vector subs;
+ for (auto& child : node->children) {
+ subs.push_back(child.first + "(" + dfs(child.second) + ")");
+ }
+ sort(subs.begin(), subs.end());
+ string s = "";
+ for (auto& sub : subs) s += sub;
+
+ if (g.contains(s)) {
+ node->deleted = true;
+ g[s]->deleted = true;
+ } else {
+ g[s] = node;
+ }
+ return s;
+ };
+
+ dfs(root);
+
+ vector> ans;
+ vector path;
+
+ auto dfs2 = [&](this auto&& dfs2, Trie* node) -> void {
+ if (node->deleted) return;
+ if (!path.empty()) {
+ ans.push_back(path);
+ }
+ for (auto& child : node->children) {
+ path.push_back(child.first);
+ dfs2(child.second);
+ path.pop_back();
+ }
+ };
+
+ dfs2(root);
+
+ return ans;
+ }
+};
```
#### Go
```go
+type Trie struct {
+ children map[string]*Trie
+ deleted bool
+}
+
+func NewTrie() *Trie {
+ return &Trie{
+ children: make(map[string]*Trie),
+ }
+}
+
+func deleteDuplicateFolder(paths [][]string) (ans [][]string) {
+ root := NewTrie()
+ for _, path := range paths {
+ cur := root
+ for _, name := range path {
+ if _, exists := cur.children[name]; !exists {
+ cur.children[name] = NewTrie()
+ }
+ cur = cur.children[name]
+ }
+ }
+
+ g := make(map[string]*Trie)
+
+ var dfs func(*Trie) string
+ dfs = func(node *Trie) string {
+ if len(node.children) == 0 {
+ return ""
+ }
+ var subs []string
+ for name, child := range node.children {
+ subs = append(subs, name+"("+dfs(child)+")")
+ }
+ sort.Strings(subs)
+ s := strings.Join(subs, "")
+ if existingNode, exists := g[s]; exists {
+ node.deleted = true
+ existingNode.deleted = true
+ } else {
+ g[s] = node
+ }
+ return s
+ }
+
+ var dfs2 func(*Trie, []string)
+ dfs2 = func(node *Trie, path []string) {
+ if node.deleted {
+ return
+ }
+ if len(path) > 0 {
+ ans = append(ans, append([]string{}, path...))
+ }
+ for name, child := range node.children {
+ dfs2(child, append(path, name))
+ }
+ }
+
+ dfs(root)
+ dfs2(root, []string{})
+ return ans
+}
+```
+#### TypeScript
+
+```ts
+function deleteDuplicateFolder(paths: string[][]): string[][] {
+ class Trie {
+ children: { [key: string]: Trie } = {};
+ deleted: boolean = false;
+ }
+
+ const root = new Trie();
+
+ for (const path of paths) {
+ let cur = root;
+ for (const name of path) {
+ if (!cur.children[name]) {
+ cur.children[name] = new Trie();
+ }
+ cur = cur.children[name];
+ }
+ }
+
+ const g: { [key: string]: Trie } = {};
+
+ const dfs = (node: Trie): string => {
+ if (Object.keys(node.children).length === 0) return '';
+
+ const subs: string[] = [];
+ for (const [name, child] of Object.entries(node.children)) {
+ subs.push(`${name}(${dfs(child)})`);
+ }
+ subs.sort();
+ const s = subs.join('');
+
+ if (g[s]) {
+ node.deleted = true;
+ g[s].deleted = true;
+ } else {
+ g[s] = node;
+ }
+ return s;
+ };
+
+ dfs(root);
+
+ const ans: string[][] = [];
+ const path: string[] = [];
+
+ const dfs2 = (node: Trie): void => {
+ if (node.deleted) return;
+ if (path.length > 0) {
+ ans.push([...path]);
+ }
+ for (const [name, child] of Object.entries(node.children)) {
+ path.push(name);
+ dfs2(child);
+ path.pop();
+ }
+ };
+
+ dfs2(root);
+
+ return ans;
+}
```
diff --git a/solution/1900-1999/1948.Delete Duplicate Folders in System/README_EN.md b/solution/1900-1999/1948.Delete Duplicate Folders in System/README_EN.md
index 01fa7d10a03c7..70015e2e4de1d 100644
--- a/solution/1900-1999/1948.Delete Duplicate Folders in System/README_EN.md
+++ b/solution/1900-1999/1948.Delete Duplicate Folders in System/README_EN.md
@@ -101,32 +101,348 @@ Note that the returned array can be in a different order as the order does not m
-### Solution 1
+### Solution 1: Trie + DFS
+
+We can use a trie to store the folder structure, where each node in the trie contains the following data:
+
+- `children`: A dictionary where the key is the name of the subfolder and the value is the corresponding child node.
+- `deleted`: A boolean value indicating whether the node is marked for deletion.
+
+We insert all paths into the trie, then use DFS to traverse the trie and build a string representation for each subtree. For each subtree, if its string representation already exists in a global dictionary, we mark both the current node and the corresponding node in the global dictionary for deletion. Finally, we use DFS again to traverse the trie and add the paths of unmarked nodes to the result list.
#### Python3
```python
-
+class Trie:
+ def __init__(self):
+ self.children: Dict[str, "Trie"] = defaultdict(Trie)
+ self.deleted: bool = False
+
+
+class Solution:
+ def deleteDuplicateFolder(self, paths: List[List[str]]) -> List[List[str]]:
+ root = Trie()
+ for path in paths:
+ cur = root
+ for name in path:
+ if cur.children[name] is None:
+ cur.children[name] = Trie()
+ cur = cur.children[name]
+
+ g: Dict[str, Trie] = {}
+
+ def dfs(node: Trie) -> str:
+ if not node.children:
+ return ""
+ subs: List[str] = []
+ for name, child in node.children.items():
+ subs.append(f"{name}({dfs(child)})")
+ s = "".join(sorted(subs))
+ if s in g:
+ node.deleted = g[s].deleted = True
+ else:
+ g[s] = node
+ return s
+
+ def dfs2(node: Trie) -> None:
+ if node.deleted:
+ return
+ if path:
+ ans.append(path[:])
+ for name, child in node.children.items():
+ path.append(name)
+ dfs2(child)
+ path.pop()
+
+ dfs(root)
+ ans: List[List[str]] = []
+ path: List[str] = []
+ dfs2(root)
+ return ans
```
#### Java
```java
-
+class Trie {
+ Map children;
+ boolean deleted;
+
+ public Trie() {
+ children = new HashMap<>();
+ deleted = false;
+ }
+}
+
+class Solution {
+ public List> deleteDuplicateFolder(List> paths) {
+ Trie root = new Trie();
+ for (List path : paths) {
+ Trie cur = root;
+ for (String name : path) {
+ if (!cur.children.containsKey(name)) {
+ cur.children.put(name, new Trie());
+ }
+ cur = cur.children.get(name);
+ }
+ }
+
+ Map g = new HashMap<>();
+
+ var dfs = new Function() {
+ @Override
+ public String apply(Trie node) {
+ if (node.children.isEmpty()) {
+ return "";
+ }
+ List subs = new ArrayList<>();
+ for (var entry : node.children.entrySet()) {
+ subs.add(entry.getKey() + "(" + apply(entry.getValue()) + ")");
+ }
+ Collections.sort(subs);
+ String s = String.join("", subs);
+ if (g.containsKey(s)) {
+ node.deleted = true;
+ g.get(s).deleted = true;
+ } else {
+ g.put(s, node);
+ }
+ return s;
+ }
+ };
+
+ dfs.apply(root);
+
+ List> ans = new ArrayList<>();
+ List path = new ArrayList<>();
+
+ var dfs2 = new Function() {
+ @Override
+ public Void apply(Trie node) {
+ if (node.deleted) {
+ return null;
+ }
+ if (!path.isEmpty()) {
+ ans.add(new ArrayList<>(path));
+ }
+ for (Map.Entry entry : node.children.entrySet()) {
+ path.add(entry.getKey());
+ apply(entry.getValue());
+ path.remove(path.size() - 1);
+ }
+ return null;
+ }
+ };
+
+ dfs2.apply(root);
+
+ return ans;
+ }
+}
```
#### C++
```cpp
-
+class Trie {
+public:
+ unordered_map children;
+ bool deleted = false;
+};
+
+class Solution {
+public:
+ vector> deleteDuplicateFolder(vector>& paths) {
+ Trie* root = new Trie();
+
+ for (auto& path : paths) {
+ Trie* cur = root;
+ for (auto& name : path) {
+ if (cur->children.find(name) == cur->children.end()) {
+ cur->children[name] = new Trie();
+ }
+ cur = cur->children[name];
+ }
+ }
+
+ unordered_map g;
+
+ auto dfs = [&](this auto&& dfs, Trie* node) -> string {
+ if (node->children.empty()) return "";
+
+ vector subs;
+ for (auto& child : node->children) {
+ subs.push_back(child.first + "(" + dfs(child.second) + ")");
+ }
+ sort(subs.begin(), subs.end());
+ string s = "";
+ for (auto& sub : subs) s += sub;
+
+ if (g.contains(s)) {
+ node->deleted = true;
+ g[s]->deleted = true;
+ } else {
+ g[s] = node;
+ }
+ return s;
+ };
+
+ dfs(root);
+
+ vector> ans;
+ vector path;
+
+ auto dfs2 = [&](this auto&& dfs2, Trie* node) -> void {
+ if (node->deleted) return;
+ if (!path.empty()) {
+ ans.push_back(path);
+ }
+ for (auto& child : node->children) {
+ path.push_back(child.first);
+ dfs2(child.second);
+ path.pop_back();
+ }
+ };
+
+ dfs2(root);
+
+ return ans;
+ }
+};
```
#### Go
```go
+type Trie struct {
+ children map[string]*Trie
+ deleted bool
+}
+
+func NewTrie() *Trie {
+ return &Trie{
+ children: make(map[string]*Trie),
+ }
+}
+
+func deleteDuplicateFolder(paths [][]string) (ans [][]string) {
+ root := NewTrie()
+ for _, path := range paths {
+ cur := root
+ for _, name := range path {
+ if _, exists := cur.children[name]; !exists {
+ cur.children[name] = NewTrie()
+ }
+ cur = cur.children[name]
+ }
+ }
+
+ g := make(map[string]*Trie)
+
+ var dfs func(*Trie) string
+ dfs = func(node *Trie) string {
+ if len(node.children) == 0 {
+ return ""
+ }
+ var subs []string
+ for name, child := range node.children {
+ subs = append(subs, name+"("+dfs(child)+")")
+ }
+ sort.Strings(subs)
+ s := strings.Join(subs, "")
+ if existingNode, exists := g[s]; exists {
+ node.deleted = true
+ existingNode.deleted = true
+ } else {
+ g[s] = node
+ }
+ return s
+ }
+
+ var dfs2 func(*Trie, []string)
+ dfs2 = func(node *Trie, path []string) {
+ if node.deleted {
+ return
+ }
+ if len(path) > 0 {
+ ans = append(ans, append([]string{}, path...))
+ }
+ for name, child := range node.children {
+ dfs2(child, append(path, name))
+ }
+ }
+
+ dfs(root)
+ dfs2(root, []string{})
+ return ans
+}
+```
+#### TypeScript
+
+```ts
+function deleteDuplicateFolder(paths: string[][]): string[][] {
+ class Trie {
+ children: { [key: string]: Trie } = {};
+ deleted: boolean = false;
+ }
+
+ const root = new Trie();
+
+ for (const path of paths) {
+ let cur = root;
+ for (const name of path) {
+ if (!cur.children[name]) {
+ cur.children[name] = new Trie();
+ }
+ cur = cur.children[name];
+ }
+ }
+
+ const g: { [key: string]: Trie } = {};
+
+ const dfs = (node: Trie): string => {
+ if (Object.keys(node.children).length === 0) return '';
+
+ const subs: string[] = [];
+ for (const [name, child] of Object.entries(node.children)) {
+ subs.push(`${name}(${dfs(child)})`);
+ }
+ subs.sort();
+ const s = subs.join('');
+
+ if (g[s]) {
+ node.deleted = true;
+ g[s].deleted = true;
+ } else {
+ g[s] = node;
+ }
+ return s;
+ };
+
+ dfs(root);
+
+ const ans: string[][] = [];
+ const path: string[] = [];
+
+ const dfs2 = (node: Trie): void => {
+ if (node.deleted) return;
+ if (path.length > 0) {
+ ans.push([...path]);
+ }
+ for (const [name, child] of Object.entries(node.children)) {
+ path.push(name);
+ dfs2(child);
+ path.pop();
+ }
+ };
+
+ dfs2(root);
+
+ return ans;
+}
```
diff --git a/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.cpp b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.cpp
new file mode 100644
index 0000000000000..3f7b140bc9353
--- /dev/null
+++ b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.cpp
@@ -0,0 +1,65 @@
+class Trie {
+public:
+ unordered_map children;
+ bool deleted = false;
+};
+
+class Solution {
+public:
+ vector> deleteDuplicateFolder(vector>& paths) {
+ Trie* root = new Trie();
+
+ for (auto& path : paths) {
+ Trie* cur = root;
+ for (auto& name : path) {
+ if (cur->children.find(name) == cur->children.end()) {
+ cur->children[name] = new Trie();
+ }
+ cur = cur->children[name];
+ }
+ }
+
+ unordered_map g;
+
+ auto dfs = [&](this auto&& dfs, Trie* node) -> string {
+ if (node->children.empty()) return "";
+
+ vector subs;
+ for (auto& child : node->children) {
+ subs.push_back(child.first + "(" + dfs(child.second) + ")");
+ }
+ sort(subs.begin(), subs.end());
+ string s = "";
+ for (auto& sub : subs) s += sub;
+
+ if (g.contains(s)) {
+ node->deleted = true;
+ g[s]->deleted = true;
+ } else {
+ g[s] = node;
+ }
+ return s;
+ };
+
+ dfs(root);
+
+ vector> ans;
+ vector path;
+
+ auto dfs2 = [&](this auto&& dfs2, Trie* node) -> void {
+ if (node->deleted) return;
+ if (!path.empty()) {
+ ans.push_back(path);
+ }
+ for (auto& child : node->children) {
+ path.push_back(child.first);
+ dfs2(child.second);
+ path.pop_back();
+ }
+ };
+
+ dfs2(root);
+
+ return ans;
+ }
+};
diff --git a/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.go b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.go
new file mode 100644
index 0000000000000..2b61f3796a413
--- /dev/null
+++ b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.go
@@ -0,0 +1,62 @@
+type Trie struct {
+ children map[string]*Trie
+ deleted bool
+}
+
+func NewTrie() *Trie {
+ return &Trie{
+ children: make(map[string]*Trie),
+ }
+}
+
+func deleteDuplicateFolder(paths [][]string) (ans [][]string) {
+ root := NewTrie()
+ for _, path := range paths {
+ cur := root
+ for _, name := range path {
+ if _, exists := cur.children[name]; !exists {
+ cur.children[name] = NewTrie()
+ }
+ cur = cur.children[name]
+ }
+ }
+
+ g := make(map[string]*Trie)
+
+ var dfs func(*Trie) string
+ dfs = func(node *Trie) string {
+ if len(node.children) == 0 {
+ return ""
+ }
+ var subs []string
+ for name, child := range node.children {
+ subs = append(subs, name+"("+dfs(child)+")")
+ }
+ sort.Strings(subs)
+ s := strings.Join(subs, "")
+ if existingNode, exists := g[s]; exists {
+ node.deleted = true
+ existingNode.deleted = true
+ } else {
+ g[s] = node
+ }
+ return s
+ }
+
+ var dfs2 func(*Trie, []string)
+ dfs2 = func(node *Trie, path []string) {
+ if node.deleted {
+ return
+ }
+ if len(path) > 0 {
+ ans = append(ans, append([]string{}, path...))
+ }
+ for name, child := range node.children {
+ dfs2(child, append(path, name))
+ }
+ }
+
+ dfs(root)
+ dfs2(root, []string{})
+ return ans
+}
diff --git a/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.java b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.java
new file mode 100644
index 0000000000000..cd5912d34b40c
--- /dev/null
+++ b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.java
@@ -0,0 +1,75 @@
+class Trie {
+ Map children;
+ boolean deleted;
+
+ public Trie() {
+ children = new HashMap<>();
+ deleted = false;
+ }
+}
+
+class Solution {
+ public List> deleteDuplicateFolder(List> paths) {
+ Trie root = new Trie();
+ for (List path : paths) {
+ Trie cur = root;
+ for (String name : path) {
+ if (!cur.children.containsKey(name)) {
+ cur.children.put(name, new Trie());
+ }
+ cur = cur.children.get(name);
+ }
+ }
+
+ Map g = new HashMap<>();
+
+ var dfs = new Function() {
+ @Override
+ public String apply(Trie node) {
+ if (node.children.isEmpty()) {
+ return "";
+ }
+ List subs = new ArrayList<>();
+ for (var entry : node.children.entrySet()) {
+ subs.add(entry.getKey() + "(" + apply(entry.getValue()) + ")");
+ }
+ Collections.sort(subs);
+ String s = String.join("", subs);
+ if (g.containsKey(s)) {
+ node.deleted = true;
+ g.get(s).deleted = true;
+ } else {
+ g.put(s, node);
+ }
+ return s;
+ }
+ };
+
+ dfs.apply(root);
+
+ List> ans = new ArrayList<>();
+ List path = new ArrayList<>();
+
+ var dfs2 = new Function() {
+ @Override
+ public Void apply(Trie node) {
+ if (node.deleted) {
+ return null;
+ }
+ if (!path.isEmpty()) {
+ ans.add(new ArrayList<>(path));
+ }
+ for (Map.Entry entry : node.children.entrySet()) {
+ path.add(entry.getKey());
+ apply(entry.getValue());
+ path.remove(path.size() - 1);
+ }
+ return null;
+ }
+ };
+
+ dfs2.apply(root);
+
+ return ans;
+ }
+}
diff --git a/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.py b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.py
new file mode 100644
index 0000000000000..9031f263762d1
--- /dev/null
+++ b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.py
@@ -0,0 +1,46 @@
+class Trie:
+ def __init__(self):
+ self.children: Dict[str, "Trie"] = defaultdict(Trie)
+ self.deleted: bool = False
+
+
+class Solution:
+ def deleteDuplicateFolder(self, paths: List[List[str]]) -> List[List[str]]:
+ root = Trie()
+ for path in paths:
+ cur = root
+ for name in path:
+ if cur.children[name] is None:
+ cur.children[name] = Trie()
+ cur = cur.children[name]
+
+ g: Dict[str, Trie] = {}
+
+ def dfs(node: Trie) -> str:
+ if not node.children:
+ return ""
+ subs: List[str] = []
+ for name, child in node.children.items():
+ subs.append(f"{name}({dfs(child)})")
+ s = "".join(sorted(subs))
+ if s in g:
+ node.deleted = g[s].deleted = True
+ else:
+ g[s] = node
+ return s
+
+ def dfs2(node: Trie) -> None:
+ if node.deleted:
+ return
+ if path:
+ ans.append(path[:])
+ for name, child in node.children.items():
+ path.append(name)
+ dfs2(child)
+ path.pop()
+
+ dfs(root)
+ ans: List[List[str]] = []
+ path: List[str] = []
+ dfs2(root)
+ return ans
diff --git a/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.ts b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.ts
new file mode 100644
index 0000000000000..10096fe3014d4
--- /dev/null
+++ b/solution/1900-1999/1948.Delete Duplicate Folders in System/Solution.ts
@@ -0,0 +1,60 @@
+function deleteDuplicateFolder(paths: string[][]): string[][] {
+ class Trie {
+ children: { [key: string]: Trie } = {};
+ deleted: boolean = false;
+ }
+
+ const root = new Trie();
+
+ for (const path of paths) {
+ let cur = root;
+ for (const name of path) {
+ if (!cur.children[name]) {
+ cur.children[name] = new Trie();
+ }
+ cur = cur.children[name];
+ }
+ }
+
+ const g: { [key: string]: Trie } = {};
+
+ const dfs = (node: Trie): string => {
+ if (Object.keys(node.children).length === 0) return '';
+
+ const subs: string[] = [];
+ for (const [name, child] of Object.entries(node.children)) {
+ subs.push(`${name}(${dfs(child)})`);
+ }
+ subs.sort();
+ const s = subs.join('');
+
+ if (g[s]) {
+ node.deleted = true;
+ g[s].deleted = true;
+ } else {
+ g[s] = node;
+ }
+ return s;
+ };
+
+ dfs(root);
+
+ const ans: string[][] = [];
+ const path: string[] = [];
+
+ const dfs2 = (node: Trie): void => {
+ if (node.deleted) return;
+ if (path.length > 0) {
+ ans.push([...path]);
+ }
+ for (const [name, child] of Object.entries(node.children)) {
+ path.push(name);
+ dfs2(child);
+ path.pop();
+ }
+ };
+
+ dfs2(root);
+
+ return ans;
+}
diff --git a/solution/1900-1999/1957.Delete Characters to Make Fancy String/README.md b/solution/1900-1999/1957.Delete Characters to Make Fancy String/README.md
index fbfab3d1aea3c..ec802af1344cc 100644
--- a/solution/1900-1999/1957.Delete Characters to Make Fancy String/README.md
+++ b/solution/1900-1999/1957.Delete Characters to Make Fancy String/README.md
@@ -72,11 +72,11 @@ tags:
### 方法一：模拟
-我们可以遍历字符串 $s$，并使用一个数组 $\textit{ans}$ 记录当前的答案。对于每一个字符 $c$，如果 $\textit{ans}$ 的长度小于 $2$ 或者 $\textit{ans}$ 的最后两个字符不等于 $c$，我们就将 $c$ 添加到 $\textit{ans}$ 中。
+我们可以遍历字符串 $s$，并使用一个数组 $\textit{ans}$ 记录当前的答案。对于每一个字符 $\textit{s[i]}$，如果 $i \lt 2$ 或者 $s[i]$ 与 $s[i - 1]$ 不等，或者 $s[i]$ 与 $s[i - 2]$ 不等，我们就将 $s[i]$ 添加到 $\textit{ans}$ 中。
最后，我们将 $\textit{ans}$ 中的字符连接起来，就得到了答案。
-时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为字符串 $s$ 的长度。
+时间复杂度 $O(n)$，其中 $n$ 为字符串 $s$ 的长度。忽略答案的空间消耗，空间复杂度 $O(1)$。
@@ -86,8 +86,8 @@ tags:
class Solution:
def makeFancyString(self, s: str) -> str:
ans = []
- for c in s:
- if len(ans) < 2 or ans[-1] != c or ans[-2] != c:
+ for i, c in enumerate(s):
+ if i < 2 or c != s[i - 1] or c != s[i - 2]:
ans.append(c)
return "".join(ans)
```
@@ -98,9 +98,9 @@ class Solution:
class Solution {
public String makeFancyString(String s) {
StringBuilder ans = new StringBuilder();
- for (char c : s.toCharArray()) {
- int n = ans.length();
- if (n < 2 || c != ans.charAt(n - 1) || c != ans.charAt(n - 2)) {
+ for (int i = 0; i < s.length(); ++i) {
+ char c = s.charAt(i);
+ if (i < 2 || c != s.charAt(i - 1) || c != s.charAt(i - 2)) {
ans.append(c);
}
}
@@ -116,9 +116,9 @@ class Solution {
public:
string makeFancyString(string s) {
string ans = "";
- for (char& c : s) {
- int n = ans.size();
- if (n < 2 || ans[n - 1] != c || ans[n - 2] != c) {
+ for (int i = 0; i < s.length(); ++i) {
+ char c = s[i];
+ if (i < 2 || c != s[i - 1] || c != s[i - 2]) {
ans += c;
}
}
@@ -131,9 +131,9 @@ public:
```go
func makeFancyString(s string) string {
- ans := []rune{}
- for _, c := range s {
- if n := len(ans); n < 2 || c != ans[n-1] || c != ans[n-2] {
+ ans := []byte{}
+ for i, ch := range s {
+ if c := byte(ch); i < 2 || c != s[i-1] || c != s[i-2] {
ans = append(ans, c)
}
}
@@ -145,28 +145,32 @@ func makeFancyString(s string) string {
```ts
function makeFancyString(s: string): string {
- let [n, ans] = [s.length, ''];
- for (let i = 0; i < n; i++) {
+ const ans: string[] = [];
+ for (let i = 0; i < s.length; ++i) {
if (s[i] !== s[i - 1] || s[i] !== s[i - 2]) {
- ans += s[i];
+ ans.push(s[i]);
}
}
- return ans;
+ return ans.join('');
}
```
#### JavaScript
```js
-function makeFancyString(s) {
- let [n, ans] = [s.length, ''];
- for (let i = 0; i < n; i++) {
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var makeFancyString = function (s) {
+ const ans = [];
+ for (let i = 0; i < s.length; ++i) {
if (s[i] !== s[i - 1] || s[i] !== s[i - 2]) {
- ans += s[i];
+ ans.push(s[i]);
}
}
- return ans;
-}
+ return ans.join('');
+};
```
#### PHP
@@ -178,17 +182,14 @@ class Solution {
* @return String
*/
function makeFancyString($s) {
- $ans = [];
- $length = strlen($s);
-
- for ($i = 0; $i < $length; $i++) {
- $n = count($ans);
- if ($n < 2 || $s[$i] !== $ans[$n - 1] || $s[$i] !== $ans[$n - 2]) {
- $ans[] = $s[$i];
+ $ans = '';
+ for ($i = 0; $i < strlen($s); $i++) {
+ $c = $s[$i];
+ if ($i < 2 || $c !== $s[$i - 1] || $c !== $s[$i - 2]) {
+ $ans .= $c;
}
}
-
- return implode('', $ans);
+ return $ans;
}
}
```
diff --git a/solution/1900-1999/1957.Delete Characters to Make Fancy String/README_EN.md b/solution/1900-1999/1957.Delete Characters to Make Fancy String/README_EN.md
index 466d7474105a2..2879eb33fac38 100644
--- a/solution/1900-1999/1957.Delete Characters to Make Fancy String/README_EN.md
+++ b/solution/1900-1999/1957.Delete Characters to Make Fancy String/README_EN.md
@@ -70,11 +70,11 @@ No three consecutive characters are equal, so return "aabaa".
### Solution 1: Simulation
-We can traverse the string $s$ and use an array $\textit{ans}$ to record the current answer. For each character $c$, if the length of $\textit{ans}$ is less than $2$ or the last two characters of $\textit{ans}$ are not equal to $c$, we add $c$ to $\textit{ans}$.
+We can iterate through the string $s$ and use an array $\textit{ans}$ to record the current answer. For each character $\textit{s[i]}$, if $i < 2$ or $s[i]$ is not equal to $s[i - 1]$, or $s[i]$ is not equal to $s[i - 2]$, we add $s[i]$ to $\textit{ans}$.
Finally, we concatenate the characters in $\textit{ans}$ to get the answer.
-The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the string $s$.
+The time complexity is $O(n)$, where $n$ is the length of the string $s$. Ignoring the space consumption of the answer, the space complexity is $O(1)$.
@@ -84,8 +84,8 @@ The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is
class Solution:
def makeFancyString(self, s: str) -> str:
ans = []
- for c in s:
- if len(ans) < 2 or ans[-1] != c or ans[-2] != c:
+ for i, c in enumerate(s):
+ if i < 2 or c != s[i - 1] or c != s[i - 2]:
ans.append(c)
return "".join(ans)
```
@@ -96,9 +96,9 @@ class Solution:
class Solution {
public String makeFancyString(String s) {
StringBuilder ans = new StringBuilder();
- for (char c : s.toCharArray()) {
- int n = ans.length();
- if (n < 2 || c != ans.charAt(n - 1) || c != ans.charAt(n - 2)) {
+ for (int i = 0; i < s.length(); ++i) {
+ char c = s.charAt(i);
+ if (i < 2 || c != s.charAt(i - 1) || c != s.charAt(i - 2)) {
ans.append(c);
}
}
@@ -114,9 +114,9 @@ class Solution {
public:
string makeFancyString(string s) {
string ans = "";
- for (char& c : s) {
- int n = ans.size();
- if (n < 2 || ans[n - 1] != c || ans[n - 2] != c) {
+ for (int i = 0; i < s.length(); ++i) {
+ char c = s[i];
+ if (i < 2 || c != s[i - 1] || c != s[i - 2]) {
ans += c;
}
}
@@ -129,9 +129,9 @@ public:
```go
func makeFancyString(s string) string {
- ans := []rune{}
- for _, c := range s {
- if n := len(ans); n < 2 || c != ans[n-1] || c != ans[n-2] {
+ ans := []byte{}
+ for i, ch := range s {
+ if c := byte(ch); i < 2 || c != s[i-1] || c != s[i-2] {
ans = append(ans, c)
}
}
@@ -143,28 +143,32 @@ func makeFancyString(s string) string {
```ts
function makeFancyString(s: string): string {
- let [n, ans] = [s.length, ''];
- for (let i = 0; i < n; i++) {
+ const ans: string[] = [];
+ for (let i = 0; i < s.length; ++i) {
if (s[i] !== s[i - 1] || s[i] !== s[i - 2]) {
- ans += s[i];
+ ans.push(s[i]);
}
}
- return ans;
+ return ans.join('');
}
```
#### JavaScript
```js
-function makeFancyString(s) {
- let [n, ans] = [s.length, ''];
- for (let i = 0; i < n; i++) {
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var makeFancyString = function (s) {
+ const ans = [];
+ for (let i = 0; i < s.length; ++i) {
if (s[i] !== s[i - 1] || s[i] !== s[i - 2]) {
- ans += s[i];
+ ans.push(s[i]);
}
}
- return ans;
-}
+ return ans.join('');
+};
```
#### PHP
@@ -176,17 +180,14 @@ class Solution {
* @return String
*/
function makeFancyString($s) {
- $ans = [];
- $length = strlen($s);
-
- for ($i = 0; $i < $length; $i++) {
- $n = count($ans);
- if ($n < 2 || $s[$i] !== $ans[$n - 1] || $s[$i] !== $ans[$n - 2]) {
- $ans[] = $s[$i];
+ $ans = '';
+ for ($i = 0; $i < strlen($s); $i++) {
+ $c = $s[$i];
+ if ($i < 2 || $c !== $s[$i - 1] || $c !== $s[$i - 2]) {
+ $ans .= $c;
}
}
-
- return implode('', $ans);
+ return $ans;
}
}
```
diff --git a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.cpp b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.cpp
index 79416b151e375..450b000663202 100644
--- a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.cpp
+++ b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.cpp
@@ -2,9 +2,9 @@ class Solution {
public:
string makeFancyString(string s) {
string ans = "";
- for (char& c : s) {
- int n = ans.size();
- if (n < 2 || ans[n - 1] != c || ans[n - 2] != c) {
+ for (int i = 0; i < s.length(); ++i) {
+ char c = s[i];
+ if (i < 2 || c != s[i - 1] || c != s[i - 2]) {
ans += c;
}
}
diff --git a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.go b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.go
index b472925d7fd9e..3118be7e97ed2 100644
--- a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.go
+++ b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.go
@@ -1,7 +1,7 @@
func makeFancyString(s string) string {
- ans := []rune{}
- for _, c := range s {
- if n := len(ans); n < 2 || c != ans[n-1] || c != ans[n-2] {
+ ans := []byte{}
+ for i, ch := range s {
+ if c := byte(ch); i < 2 || c != s[i-1] || c != s[i-2] {
ans = append(ans, c)
}
}
diff --git a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.java b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.java
index 0947382c03255..4828771d9f284 100644
--- a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.java
+++ b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.java
@@ -1,12 +1,12 @@
class Solution {
public String makeFancyString(String s) {
StringBuilder ans = new StringBuilder();
- for (char c : s.toCharArray()) {
- int n = ans.length();
- if (n < 2 || c != ans.charAt(n - 1) || c != ans.charAt(n - 2)) {
+ for (int i = 0; i < s.length(); ++i) {
+ char c = s.charAt(i);
+ if (i < 2 || c != s.charAt(i - 1) || c != s.charAt(i - 2)) {
ans.append(c);
}
}
return ans.toString();
}
-}
+}
\ No newline at end of file
diff --git a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.js b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.js
index 16bfe1a2a7c98..745e2443b1d37 100644
--- a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.js
+++ b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.js
@@ -1,9 +1,13 @@
-function makeFancyString(s) {
- let [n, ans] = [s.length, ''];
- for (let i = 0; i < n; i++) {
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var makeFancyString = function (s) {
+ const ans = [];
+ for (let i = 0; i < s.length; ++i) {
if (s[i] !== s[i - 1] || s[i] !== s[i - 2]) {
- ans += s[i];
+ ans.push(s[i]);
}
}
- return ans;
-}
+ return ans.join('');
+};
diff --git a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.php b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.php
index 41b56186c248a..dc20f0120a451 100644
--- a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.php
+++ b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.php
@@ -4,16 +4,13 @@ class Solution {
* @return String
*/
function makeFancyString($s) {
- $ans = [];
- $length = strlen($s);
-
- for ($i = 0; $i < $length; $i++) {
- $n = count($ans);
- if ($n < 2 || $s[$i] !== $ans[$n - 1] || $s[$i] !== $ans[$n - 2]) {
- $ans[] = $s[$i];
+ $ans = '';
+ for ($i = 0; $i < strlen($s); $i++) {
+ $c = $s[$i];
+ if ($i < 2 || $c !== $s[$i - 1] || $c !== $s[$i - 2]) {
+ $ans .= $c;
}
}
-
- return implode('', $ans);
+ return $ans;
}
-}
+}
\ No newline at end of file
diff --git a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.py b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.py
index 76eb795267313..d601ec8b77fb2 100644
--- a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.py
+++ b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.py
@@ -1,7 +1,7 @@
class Solution:
def makeFancyString(self, s: str) -> str:
ans = []
- for c in s:
- if len(ans) < 2 or ans[-1] != c or ans[-2] != c:
+ for i, c in enumerate(s):
+ if i < 2 or c != s[i - 1] or c != s[i - 2]:
ans.append(c)
return "".join(ans)
diff --git a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.ts b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.ts
index 6f86484842ea4..bc989a239c6d2 100644
--- a/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.ts
+++ b/solution/1900-1999/1957.Delete Characters to Make Fancy String/Solution.ts
@@ -1,9 +1,9 @@
function makeFancyString(s: string): string {
- let [n, ans] = [s.length, ''];
- for (let i = 0; i < n; i++) {
+ const ans: string[] = [];
+ for (let i = 0; i < s.length; ++i) {
if (s[i] !== s[i - 1] || s[i] !== s[i - 2]) {
- ans += s[i];
+ ans.push(s[i]);
}
}
- return ans;
+ return ans.join('');
}
diff --git a/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/README.md b/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/README.md
index b918ee2cb015b..f80ef7a0f97eb 100644
--- a/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/README.md
+++ b/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/README.md
@@ -68,25 +68,202 @@ tags:
#### Python3
```python
-
+class Solution:
+ def maxProduct(self, s: str) -> int:
+ n = len(s)
+ hlen = [0] * n
+ center = right = 0
+
+ for i in range(n):
+ if i < right:
+ hlen[i] = min(right - i, hlen[2 * center - i])
+ while (
+ 0 <= i - 1 - hlen[i]
+ and i + 1 + hlen[i] < len(s)
+ and s[i - 1 - hlen[i]] == s[i + 1 + hlen[i]]
+ ):
+ hlen[i] += 1
+ if right < i + hlen[i]:
+ center, right = i, i + hlen[i]
+
+ prefix = [0] * n
+ suffix = [0] * n
+
+ for i in range(n):
+ prefix[i + hlen[i]] = max(prefix[i + hlen[i]], 2 * hlen[i] + 1)
+ suffix[i - hlen[i]] = max(suffix[i - hlen[i]], 2 * hlen[i] + 1)
+
+ for i in range(1, n):
+ prefix[~i] = max(prefix[~i], prefix[~i + 1] - 2)
+ suffix[i] = max(suffix[i], suffix[i - 1] - 2)
+
+ for i in range(1, n):
+ prefix[i] = max(prefix[i - 1], prefix[i])
+ suffix[~i] = max(suffix[~i], suffix[~i + 1])
+
+ return max(prefix[i - 1] * suffix[i] for i in range(1, n))
```
#### Java
```java
-
+class Solution {
+ public long maxProduct(String s) {
+ int n = s.length();
+ if (n == 2) return 1;
+ int[] len = manachers(s);
+ long[] left = new long[n];
+ int max = 1;
+ left[0] = max;
+ for (int i = 1; i <= n - 1; i++) {
+ if (len[(i - max - 1 + i) / 2] > max) max += 2;
+ left[i] = max;
+ }
+ max = 1;
+ long[] right = new long[n];
+ right[n - 1] = max;
+ for (int i = n - 2; i >= 0; i--) {
+ if (len[(i + max + 1 + i) / 2] > max) max += 2;
+ right[i] = max;
+ }
+ long res = 1;
+ for (int i = 1; i < n; i++) {
+ res = Math.max(res, left[i - 1] * right[i]);
+ }
+ return res;
+ }
+ private int[] manachers(String s) {
+ int len = s.length();
+ int[] P = new int[len];
+ int c = 0;
+ int r = 0;
+ for (int i = 0; i < len; i++) {
+ int mirror = (2 * c) - i;
+ if (i < r) {
+ P[i] = Math.min(r - i, P[mirror]);
+ }
+ int a = i + (1 + P[i]);
+ int b = i - (1 + P[i]);
+ while (a < len && b >= 0 && s.charAt(a) == s.charAt(b)) {
+ P[i]++;
+ a++;
+ b--;
+ }
+ if (i + P[i] > r) {
+ c = i;
+ r = i + P[i];
+ }
+ }
+ for (int i = 0; i < len; i++) {
+ P[i] = 1 + 2 * P[i];
+ }
+ return P;
+ }
+}
```
#### C++
```cpp
-
+class Solution {
+public:
+ long long maxProduct(string s) {
+ long long res = 0, l = 0, n = s.size();
+ vector m(n), r(n);
+
+ for (int i = 0, l = 0, r = -1; i < n; ++i) {
+ int k = (i > r) ? 1 : min(m[l + r - i], r - i + 1);
+ while (0 <= i - k && i + k < n && s[i - k] == s[i + k])
+ k++;
+ m[i] = k--;
+ if (i + k > r) {
+ l = i - k;
+ r = i + k;
+ }
+ }
+
+ queue> q, q1;
+
+ for (int i = n - 1; i >= 0; --i) {
+ while (!q.empty() && q.front()[0] - q.front()[1] > i - 1)
+ q.pop();
+ r[i] = 1 + (q.empty() ? 0 : (q.front()[0] - i) * 2);
+ q.push({i, m[i]});
+ }
+
+ for (int i = 0; i < n - 1; i++) {
+ while (!q1.empty() && q1.front()[0] + q1.front()[1] < i + 1)
+ q1.pop();
+ l = max(l, 1ll + (q1.empty() ? 0 : (i - q1.front()[0]) * 2));
+ res = max(res, l * r[i + 1]);
+ q1.push({i, m[i]});
+ }
+
+ return res;
+ }
+};
```
#### Go
```go
-
+func maxProduct(s string) int64 {
+ n := len(s)
+ hlen := make([]int, n)
+ center, right := 0, 0
+
+ for i := 0; i < n; i++ {
+ if i < right {
+ mirror := 2*center - i
+ if mirror >= 0 && mirror < n {
+ hlen[i] = min(right-i, hlen[mirror])
+ }
+ }
+ for i-1-hlen[i] >= 0 && i+1+hlen[i] < n && s[i-1-hlen[i]] == s[i+1+hlen[i]] {
+ hlen[i]++
+ }
+ if i+hlen[i] > right {
+ center = i
+ right = i + hlen[i]
+ }
+ }
+
+ prefix := make([]int, n)
+ suffix := make([]int, n)
+
+ for i := 0; i < n; i++ {
+ r := i + hlen[i]
+ if r < n {
+ prefix[r] = max(prefix[r], 2*hlen[i]+1)
+ }
+ l := i - hlen[i]
+ if l >= 0 {
+ suffix[l] = max(suffix[l], 2*hlen[i]+1)
+ }
+ }
+
+ for i := 1; i < n; i++ {
+ if n-i-1 >= 0 {
+ prefix[n-i-1] = max(prefix[n-i-1], prefix[n-i]-2)
+ }
+ suffix[i] = max(suffix[i], suffix[i-1]-2)
+ }
+
+ for i := 1; i < n; i++ {
+ prefix[i] = max(prefix[i-1], prefix[i])
+ suffix[n-i-1] = max(suffix[n-i], suffix[n-i-1])
+ }
+
+ var res int64
+ for i := 1; i < n; i++ {
+ prod := int64(prefix[i-1]) * int64(suffix[i])
+ if prod > res {
+ res = prod
+ }
+ }
+
+ return res
+}
```
diff --git a/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/README_EN.md b/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/README_EN.md
index 044c570412d56..7959a940d8336 100644
--- a/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/README_EN.md
+++ b/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/README_EN.md
@@ -66,25 +66,202 @@ tags:
#### Python3
```python
-
+class Solution:
+ def maxProduct(self, s: str) -> int:
+ n = len(s)
+ hlen = [0] * n
+ center = right = 0
+
+ for i in range(n):
+ if i < right:
+ hlen[i] = min(right - i, hlen[2 * center - i])
+ while (
+ 0 <= i - 1 - hlen[i]
+ and i + 1 + hlen[i] < len(s)
+ and s[i - 1 - hlen[i]] == s[i + 1 + hlen[i]]
+ ):
+ hlen[i] += 1
+ if right < i + hlen[i]:
+ center, right = i, i + hlen[i]
+
+ prefix = [0] * n
+ suffix = [0] * n
+
+ for i in range(n):
+ prefix[i + hlen[i]] = max(prefix[i + hlen[i]], 2 * hlen[i] + 1)
+ suffix[i - hlen[i]] = max(suffix[i - hlen[i]], 2 * hlen[i] + 1)
+
+ for i in range(1, n):
+ prefix[~i] = max(prefix[~i], prefix[~i + 1] - 2)
+ suffix[i] = max(suffix[i], suffix[i - 1] - 2)
+
+ for i in range(1, n):
+ prefix[i] = max(prefix[i - 1], prefix[i])
+ suffix[~i] = max(suffix[~i], suffix[~i + 1])
+
+ return max(prefix[i - 1] * suffix[i] for i in range(1, n))
```
#### Java
```java
-
+class Solution {
+ public long maxProduct(String s) {
+ int n = s.length();
+ if (n == 2) return 1;
+ int[] len = manachers(s);
+ long[] left = new long[n];
+ int max = 1;
+ left[0] = max;
+ for (int i = 1; i <= n - 1; i++) {
+ if (len[(i - max - 1 + i) / 2] > max) max += 2;
+ left[i] = max;
+ }
+ max = 1;
+ long[] right = new long[n];
+ right[n - 1] = max;
+ for (int i = n - 2; i >= 0; i--) {
+ if (len[(i + max + 1 + i) / 2] > max) max += 2;
+ right[i] = max;
+ }
+ long res = 1;
+ for (int i = 1; i < n; i++) {
+ res = Math.max(res, left[i - 1] * right[i]);
+ }
+ return res;
+ }
+ private int[] manachers(String s) {
+ int len = s.length();
+ int[] P = new int[len];
+ int c = 0;
+ int r = 0;
+ for (int i = 0; i < len; i++) {
+ int mirror = (2 * c) - i;
+ if (i < r) {
+ P[i] = Math.min(r - i, P[mirror]);
+ }
+ int a = i + (1 + P[i]);
+ int b = i - (1 + P[i]);
+ while (a < len && b >= 0 && s.charAt(a) == s.charAt(b)) {
+ P[i]++;
+ a++;
+ b--;
+ }
+ if (i + P[i] > r) {
+ c = i;
+ r = i + P[i];
+ }
+ }
+ for (int i = 0; i < len; i++) {
+ P[i] = 1 + 2 * P[i];
+ }
+ return P;
+ }
+}
```
#### C++
```cpp
-
+class Solution {
+public:
+ long long maxProduct(string s) {
+ long long res = 0, l = 0, n = s.size();
+ vector m(n), r(n);
+
+ for (int i = 0, l = 0, r = -1; i < n; ++i) {
+ int k = (i > r) ? 1 : min(m[l + r - i], r - i + 1);
+ while (0 <= i - k && i + k < n && s[i - k] == s[i + k])
+ k++;
+ m[i] = k--;
+ if (i + k > r) {
+ l = i - k;
+ r = i + k;
+ }
+ }
+
+ queue> q, q1;
+
+ for (int i = n - 1; i >= 0; --i) {
+ while (!q.empty() && q.front()[0] - q.front()[1] > i - 1)
+ q.pop();
+ r[i] = 1 + (q.empty() ? 0 : (q.front()[0] - i) * 2);
+ q.push({i, m[i]});
+ }
+
+ for (int i = 0; i < n - 1; i++) {
+ while (!q1.empty() && q1.front()[0] + q1.front()[1] < i + 1)
+ q1.pop();
+ l = max(l, 1ll + (q1.empty() ? 0 : (i - q1.front()[0]) * 2));
+ res = max(res, l * r[i + 1]);
+ q1.push({i, m[i]});
+ }
+
+ return res;
+ }
+};
```
#### Go
```go
-
+func maxProduct(s string) int64 {
+ n := len(s)
+ hlen := make([]int, n)
+ center, right := 0, 0
+
+ for i := 0; i < n; i++ {
+ if i < right {
+ mirror := 2*center - i
+ if mirror >= 0 && mirror < n {
+ hlen[i] = min(right-i, hlen[mirror])
+ }
+ }
+ for i-1-hlen[i] >= 0 && i+1+hlen[i] < n && s[i-1-hlen[i]] == s[i+1+hlen[i]] {
+ hlen[i]++
+ }
+ if i+hlen[i] > right {
+ center = i
+ right = i + hlen[i]
+ }
+ }
+
+ prefix := make([]int, n)
+ suffix := make([]int, n)
+
+ for i := 0; i < n; i++ {
+ r := i + hlen[i]
+ if r < n {
+ prefix[r] = max(prefix[r], 2*hlen[i]+1)
+ }
+ l := i - hlen[i]
+ if l >= 0 {
+ suffix[l] = max(suffix[l], 2*hlen[i]+1)
+ }
+ }
+
+ for i := 1; i < n; i++ {
+ if n-i-1 >= 0 {
+ prefix[n-i-1] = max(prefix[n-i-1], prefix[n-i]-2)
+ }
+ suffix[i] = max(suffix[i], suffix[i-1]-2)
+ }
+
+ for i := 1; i < n; i++ {
+ prefix[i] = max(prefix[i-1], prefix[i])
+ suffix[n-i-1] = max(suffix[n-i], suffix[n-i-1])
+ }
+
+ var res int64
+ for i := 1; i < n; i++ {
+ prod := int64(prefix[i-1]) * int64(suffix[i])
+ if prod > res {
+ res = prod
+ }
+ }
+
+ return res
+}
```
diff --git a/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/Solution.cpp b/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/Solution.cpp
new file mode 100644
index 0000000000000..c287fd98d7883
--- /dev/null
+++ b/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/Solution.cpp
@@ -0,0 +1,37 @@
+class Solution {
+public:
+ long long maxProduct(string s) {
+ long long res = 0, l = 0, n = s.size();
+ vector m(n), r(n);
+
+ for (int i = 0, l = 0, r = -1; i < n; ++i) {
+ int k = (i > r) ? 1 : min(m[l + r - i], r - i + 1);
+ while (0 <= i - k && i + k < n && s[i - k] == s[i + k])
+ k++;
+ m[i] = k--;
+ if (i + k > r) {
+ l = i - k;
+ r = i + k;
+ }
+ }
+
+ queue> q, q1;
+
+ for (int i = n - 1; i >= 0; --i) {
+ while (!q.empty() && q.front()[0] - q.front()[1] > i - 1)
+ q.pop();
+ r[i] = 1 + (q.empty() ? 0 : (q.front()[0] - i) * 2);
+ q.push({i, m[i]});
+ }
+
+ for (int i = 0; i < n - 1; i++) {
+ while (!q1.empty() && q1.front()[0] + q1.front()[1] < i + 1)
+ q1.pop();
+ l = max(l, 1ll + (q1.empty() ? 0 : (i - q1.front()[0]) * 2));
+ res = max(res, l * r[i + 1]);
+ q1.push({i, m[i]});
+ }
+
+ return res;
+ }
+};
diff --git a/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/Solution.go b/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/Solution.go
new file mode 100644
index 0000000000000..56fa1a39b45cb
--- /dev/null
+++ b/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/Solution.go
@@ -0,0 +1,57 @@
+func maxProduct(s string) int64 {
+ n := len(s)
+ hlen := make([]int, n)
+ center, right := 0, 0
+
+ for i := 0; i < n; i++ {
+ if i < right {
+ mirror := 2*center - i
+ if mirror >= 0 && mirror < n {
+ hlen[i] = min(right-i, hlen[mirror])
+ }
+ }
+ for i-1-hlen[i] >= 0 && i+1+hlen[i] < n && s[i-1-hlen[i]] == s[i+1+hlen[i]] {
+ hlen[i]++
+ }
+ if i+hlen[i] > right {
+ center = i
+ right = i + hlen[i]
+ }
+ }
+
+ prefix := make([]int, n)
+ suffix := make([]int, n)
+
+ for i := 0; i < n; i++ {
+ r := i + hlen[i]
+ if r < n {
+ prefix[r] = max(prefix[r], 2*hlen[i]+1)
+ }
+ l := i - hlen[i]
+ if l >= 0 {
+ suffix[l] = max(suffix[l], 2*hlen[i]+1)
+ }
+ }
+
+ for i := 1; i < n; i++ {
+ if n-i-1 >= 0 {
+ prefix[n-i-1] = max(prefix[n-i-1], prefix[n-i]-2)
+ }
+ suffix[i] = max(suffix[i], suffix[i-1]-2)
+ }
+
+ for i := 1; i < n; i++ {
+ prefix[i] = max(prefix[i-1], prefix[i])
+ suffix[n-i-1] = max(suffix[n-i], suffix[n-i-1])
+ }
+
+ var res int64
+ for i := 1; i < n; i++ {
+ prod := int64(prefix[i-1]) * int64(suffix[i])
+ if prod > res {
+ res = prod
+ }
+ }
+
+ return res
+}
diff --git a/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/Solution.java b/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/Solution.java
new file mode 100644
index 0000000000000..7f6946576cbae
--- /dev/null
+++ b/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/Solution.java
@@ -0,0 +1,53 @@
+class Solution {
+ public long maxProduct(String s) {
+ int n = s.length();
+ if (n == 2) return 1;
+ int[] len = manachers(s);
+ long[] left = new long[n];
+ int max = 1;
+ left[0] = max;
+ for (int i = 1; i <= n - 1; i++) {
+ if (len[(i - max - 1 + i) / 2] > max) max += 2;
+ left[i] = max;
+ }
+ max = 1;
+ long[] right = new long[n];
+ right[n - 1] = max;
+ for (int i = n - 2; i >= 0; i--) {
+ if (len[(i + max + 1 + i) / 2] > max) max += 2;
+ right[i] = max;
+ }
+ long res = 1;
+ for (int i = 1; i < n; i++) {
+ res = Math.max(res, left[i - 1] * right[i]);
+ }
+ return res;
+ }
+ private int[] manachers(String s) {
+ int len = s.length();
+ int[] P = new int[len];
+ int c = 0;
+ int r = 0;
+ for (int i = 0; i < len; i++) {
+ int mirror = (2 * c) - i;
+ if (i < r) {
+ P[i] = Math.min(r - i, P[mirror]);
+ }
+ int a = i + (1 + P[i]);
+ int b = i - (1 + P[i]);
+ while (a < len && b >= 0 && s.charAt(a) == s.charAt(b)) {
+ P[i]++;
+ a++;
+ b--;
+ }
+ if (i + P[i] > r) {
+ c = i;
+ r = i + P[i];
+ }
+ }
+ for (int i = 0; i < len; i++) {
+ P[i] = 1 + 2 * P[i];
+ }
+ return P;
+ }
+}
diff --git a/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/Solution.py b/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/Solution.py
new file mode 100644
index 0000000000000..196786c37fecd
--- /dev/null
+++ b/solution/1900-1999/1960.Maximum Product of the Length of Two Palindromic Substrings/Solution.py
@@ -0,0 +1,34 @@
+class Solution:
+ def maxProduct(self, s: str) -> int:
+ n = len(s)
+ hlen = [0] * n
+ center = right = 0
+
+ for i in range(n):
+ if i < right:
+ hlen[i] = min(right - i, hlen[2 * center - i])
+ while (
+ 0 <= i - 1 - hlen[i]
+ and i + 1 + hlen[i] < len(s)
+ and s[i - 1 - hlen[i]] == s[i + 1 + hlen[i]]
+ ):
+ hlen[i] += 1
+ if right < i + hlen[i]:
+ center, right = i, i + hlen[i]
+
+ prefix = [0] * n
+ suffix = [0] * n
+
+ for i in range(n):
+ prefix[i + hlen[i]] = max(prefix[i + hlen[i]], 2 * hlen[i] + 1)
+ suffix[i - hlen[i]] = max(suffix[i - hlen[i]], 2 * hlen[i] + 1)
+
+ for i in range(1, n):
+ prefix[~i] = max(prefix[~i], prefix[~i + 1] - 2)
+ suffix[i] = max(suffix[i], suffix[i - 1] - 2)
+
+ for i in range(1, n):
+ prefix[i] = max(prefix[i - 1], prefix[i])
+ suffix[~i] = max(suffix[~i], suffix[~i + 1])
+
+ return max(prefix[i - 1] * suffix[i] for i in range(1, n))
diff --git a/solution/1900-1999/1962.Remove Stones to Minimize the Total/README.md b/solution/1900-1999/1962.Remove Stones to Minimize the Total/README.md
index de6ec8f6b68bf..347d8989c2680 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
@@ -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/2044.Count Number of Maximum Bitwise-OR Subsets/README.md b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/README.md
index e2c3dbe051e3e..25d2759b63984 100644
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/README.md
+++ b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/README.md
@@ -77,9 +77,15 @@ tags:
### 方法一：DFS
-简单 DFS。可以预先算出按位或的最大值 mx，然后 DFS 搜索按位或结果等于 mx 的所有子集数。也可以在 DFS 搜索中逐渐更新 mx 与对应的子集数。
+数组 $\textit{nums}$ 中按位或的最大值 $\textit{mx}$ 可以通过对数组中所有元素按位或得到。
-时间复杂度 $O(2^n)$。
+然后我们可以使用深度优先搜索来枚举所有子集，统计按位或等于 $\textit{mx}$ 的子集个数。我们设计一个函数 $\text{dfs(i, t)}$，表示从下标 $\textit{i}$ 开始，当前按位或的值为 $\textit{t}$ 的子集个数。初始时 $\textit{i} = 0$, $\textit{t} = 0$。
+
+在函数 $\text{dfs(i, t)}$ 中，如果 $\textit{i}$ 等于数组长度，说明已经枚举完所有元素，此时如果 $\textit{t}$ 等于 $\textit{mx}$，则答案加一。否则，我们可以选择不包含当前元素 $\textit{nums[i]}$，或者包含当前元素 $\textit{nums[i]}$，因此我们可以递归调用 $\text{dfs(i + 1, t)}$ 和 $\text{dfs(i + 1, t | nums[i])}$。
+
+最后返回答案即可。
+
+时间复杂度 $O(2^n)$，空间复杂度 $O(n)$。其中 $n$ 是数组 $\textit{nums}$ 的长度。
@@ -88,12 +94,8 @@ tags:
```python
class Solution:
def countMaxOrSubsets(self, nums: List[int]) -> int:
- mx = ans = 0
- for x in nums:
- mx |= x
-
def dfs(i, t):
- nonlocal mx, ans
+ nonlocal ans, mx
if i == len(nums):
if t == mx:
ans += 1
@@ -101,6 +103,8 @@ class Solution:
dfs(i + 1, t)
dfs(i + 1, t | nums[i])
+ ans = 0
+ mx = reduce(lambda x, y: x | y, nums)
dfs(0, 0)
return ans
```
@@ -141,35 +145,30 @@ class Solution {
```cpp
class Solution {
public:
- int mx;
- int ans;
- vector nums;
-
int countMaxOrSubsets(vector& nums) {
- this->nums = nums;
- mx = 0;
- ans = 0;
- for (int x : nums) mx |= x;
+ int ans = 0;
+ int mx = accumulate(nums.begin(), nums.end(), 0, bit_or());
+ auto dfs = [&](this auto&& dfs, int i, int t) {
+ if (i == nums.size()) {
+ if (t == mx) {
+ ans++;
+ }
+ return;
+ }
+ dfs(i + 1, t);
+ dfs(i + 1, t | nums[i]);
+ };
dfs(0, 0);
return ans;
}
-
- void dfs(int i, int t) {
- if (i == nums.size()) {
- if (t == mx) ++ans;
- return;
- }
- dfs(i + 1, t);
- dfs(i + 1, t | nums[i]);
- }
};
```
#### Go
```go
-func countMaxOrSubsets(nums []int) int {
- mx, ans := 0, 0
+func countMaxOrSubsets(nums []int) (ans int) {
+ mx := 0
for _, x := range nums {
mx |= x
}
@@ -187,7 +186,7 @@ func countMaxOrSubsets(nums []int) int {
}
dfs(0, 0)
- return ans
+ return
}
```
@@ -195,20 +194,20 @@ func countMaxOrSubsets(nums []int) int {
```ts
function countMaxOrSubsets(nums: number[]): number {
- let n = nums.length;
- let max = 0;
- for (let i = 0; i < n; i++) {
- max |= nums[i];
- }
let ans = 0;
- function dfs(pre: number, depth: number): void {
- if (depth == n) {
- if (pre == max) ++ans;
+ const mx = nums.reduce((x, y) => x | y, 0);
+
+ const dfs = (i: number, t: number) => {
+ if (i === nums.length) {
+ if (t === mx) {
+ ans++;
+ }
return;
}
- dfs(pre, depth + 1);
- dfs(pre | nums[depth], depth + 1);
- }
+ dfs(i + 1, t);
+ dfs(i + 1, t | nums[i]);
+ };
+
dfs(0, 0);
return ans;
}
@@ -218,33 +217,23 @@ function countMaxOrSubsets(nums: number[]): number {
```rust
impl Solution {
- fn dfs(nums: &Vec, i: usize, sum: i32) -> (i32, i32) {
- let n = nums.len();
- let mut max = i32::MIN;
- let mut res = 0;
- for j in i..n {
- let num = sum | nums[j];
- if num >= max {
- if num > max {
- max = num;
- res = 0;
- }
- res += 1;
- }
- let (r_max, r_res) = Self::dfs(nums, j + 1, num);
- if r_max >= max {
- if r_max > max {
- max = r_max;
- res = 0;
+ pub fn count_max_or_subsets(nums: Vec) -> i32 {
+ let mut ans = 0;
+ let mx = nums.iter().fold(0, |x, &y| x | y);
+
+ fn dfs(i: usize, t: i32, nums: &Vec, mx: i32, ans: &mut i32) {
+ if i == nums.len() {
+ if t == mx {
+ *ans += 1;
}
- res += r_res;
+ return;
}
+ dfs(i + 1, t, nums, mx, ans);
+ dfs(i + 1, t | nums[i], nums, mx, ans);
}
- (max, res)
- }
- pub fn count_max_or_subsets(nums: Vec) -> i32 {
- Self::dfs(&nums, 0, 0).1
+ dfs(0, 0, &nums, mx, &mut ans);
+ ans
}
}
```
@@ -257,147 +246,11 @@ impl Solution {
### 方法二：二进制枚举
-时间复杂度 $O(n*2^n)$。
+我们可以使用二进制枚举来统计所有子集的按位或结果。对于长度为 $n$ 的数组 $\textit{nums}$，我们可以使用一个整数 $\textit{mask}$ 来表示一个子集，其中 $\textit{mask}$ 的第 $i$ 位为 1 表示包含元素 $\textit{nums[i]}$，为 0 则表示不包含。
-
+我们可以遍历所有可能的 $\textit{mask}$，从 $0$ 到 $2^n - 1$。对于每个 $\textit{mask}$，我们可以计算出对应子集的按位或结果，并更新最大值 $\textit{mx}$ 和答案 $\textit{ans}$。
-#### Python3
-
-```python
-class Solution:
- def countMaxOrSubsets(self, nums: List[int]) -> int:
- def dfs(u, t):
- nonlocal ans, mx
- if u == len(nums):
- if t > mx:
- mx, ans = t, 1
- elif t == mx:
- ans += 1
- return
- dfs(u + 1, t | nums[u])
- dfs(u + 1, t)
-
- ans = mx = 0
- dfs(0, 0)
- return ans
-```
-
-#### Java
-
-```java
-class Solution {
- private int mx;
- private int ans;
- private int[] nums;
-
- public int countMaxOrSubsets(int[] nums) {
- this.nums = nums;
- dfs(0, 0);
- return ans;
- }
-
- private void dfs(int u, int t) {
- if (u == nums.length) {
- if (t > mx) {
- mx = t;
- ans = 1;
- } else if (t == mx) {
- ++ans;
- }
- return;
- }
- dfs(u + 1, t);
- dfs(u + 1, t | nums[u]);
- }
-}
-```
-
-#### C++
-
-```cpp
-class Solution {
-public:
- int mx;
- int ans;
-
- int countMaxOrSubsets(vector& nums) {
- dfs(0, 0, nums);
- return ans;
- }
-
- void dfs(int u, int t, vector& nums) {
- if (u == nums.size()) {
- if (t > mx) {
- mx = t;
- ans = 1;
- } else if (t == mx)
- ++ans;
- return;
- }
- dfs(u + 1, t, nums);
- dfs(u + 1, t | nums[u], nums);
- }
-};
-```
-
-#### Go
-
-```go
-func countMaxOrSubsets(nums []int) int {
- n := len(nums)
- ans := 0
- mx := 0
- for mask := 1; mask < 1<> i) & 1) == 1 {
- t |= v
- }
- }
- if mx < t {
- mx = t
- ans = 1
- } else if mx == t {
- ans++
- }
- }
- return ans
-}
-```
-
-#### TypeScript
-
-```ts
-function countMaxOrSubsets(nums: number[]): number {
- const n = nums.length;
- let res = 0;
- let max = -Infinity;
- const dfs = (i: number, sum: number) => {
- for (let j = i; j < n; j++) {
- const num = sum | nums[j];
- if (num >= max) {
- if (num > max) {
- max = num;
- res = 0;
- }
- res++;
- }
- dfs(j + 1, num);
- }
- };
- dfs(0, 0);
-
- return res;
-}
-```
-
-
-
-
-
-
-
-### 方法三
+时间复杂度 $O(2^n \cdot n)$，其中 $n$ 是数组 $\textit{nums}$ 的长度。空间复杂度 $O(1)$。
@@ -479,23 +332,82 @@ public:
#### Go
```go
-func countMaxOrSubsets(nums []int) int {
- mx, ans := 0, 0
- var dfs func(u, t int)
- dfs = func(u, t int) {
- if u == len(nums) {
- if t > mx {
- mx, ans = t, 1
- } else if t == mx {
- ans++
+func countMaxOrSubsets(nums []int) (ans int) {
+ n := len(nums)
+ mx := 0
+
+ for mask := 0; mask < (1 << n); mask++ {
+ t := 0
+ for i, v := range nums {
+ if (mask>>i)&1 == 1 {
+ t |= v
}
- return
}
- dfs(u+1, t)
- dfs(u+1, t|nums[u])
+ if mx < t {
+ mx = t
+ ans = 1
+ } else if mx == t {
+ ans++
+ }
}
- dfs(0, 0)
- return ans
+
+ return
+}
+```
+
+#### TypeScript
+
+```ts
+function countMaxOrSubsets(nums: number[]): number {
+ const n = nums.length;
+ let ans = 0;
+ let mx = 0;
+
+ for (let mask = 0; mask < 1 << n; mask++) {
+ let t = 0;
+ for (let i = 0; i < n; i++) {
+ if ((mask >> i) & 1) {
+ t |= nums[i];
+ }
+ }
+ if (mx < t) {
+ mx = t;
+ ans = 1;
+ } else if (mx === t) {
+ ans++;
+ }
+ }
+
+ return ans;
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+ pub fn count_max_or_subsets(nums: Vec) -> i32 {
+ let n = nums.len();
+ let mut ans = 0;
+ let mut mx = 0;
+
+ for mask in 0..(1 << n) {
+ let mut t = 0;
+ for i in 0..n {
+ if (mask >> i) & 1 == 1 {
+ t |= nums[i];
+ }
+ }
+ if mx < t {
+ mx = t;
+ ans = 1;
+ } else if mx == t {
+ ans += 1;
+ }
+ }
+
+ ans
+ }
}
```
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/README_EN.md b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/README_EN.md
index 8f9aa2c0c8fa3..210bb8e736522 100644
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/README_EN.md
+++ b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/README_EN.md
@@ -73,7 +73,17 @@ tags:
-### Solution 1
+### Solution 1: DFS
+
+The maximum bitwise OR value $\textit{mx}$ in the array $\textit{nums}$ can be obtained by performing bitwise OR on all elements in the array.
+
+Then we can use depth-first search to enumerate all subsets and count the number of subsets whose bitwise OR equals $\textit{mx}$. We design a function $\text{dfs(i, t)}$, which represents the number of subsets starting from index $\textit{i}$ with the current bitwise OR value being $\textit{t}$. Initially, $\textit{i} = 0$ and $\textit{t} = 0$.
+
+In the function $\text{dfs(i, t)}$, if $\textit{i}$ equals the array length, it means we have enumerated all elements. At this point, if $\textit{t}$ equals $\textit{mx}$, we increment the answer by one. Otherwise, we can choose to either exclude the current element $\textit{nums[i]}$ or include the current element $\textit{nums[i]}$, so we can recursively call $\text{dfs(i + 1, t)}$ and $\text{dfs(i + 1, t | nums[i])}$.
+
+Finally, we return the answer.
+
+The time complexity is $O(2^n)$, and the space complexity is $O(n)$, where $n$ is the length of the array $\textit{nums}$.
@@ -82,12 +92,8 @@ tags:
```python
class Solution:
def countMaxOrSubsets(self, nums: List[int]) -> int:
- mx = ans = 0
- for x in nums:
- mx |= x
-
def dfs(i, t):
- nonlocal mx, ans
+ nonlocal ans, mx
if i == len(nums):
if t == mx:
ans += 1
@@ -95,6 +101,8 @@ class Solution:
dfs(i + 1, t)
dfs(i + 1, t | nums[i])
+ ans = 0
+ mx = reduce(lambda x, y: x | y, nums)
dfs(0, 0)
return ans
```
@@ -135,35 +143,30 @@ class Solution {
```cpp
class Solution {
public:
- int mx;
- int ans;
- vector nums;
-
int countMaxOrSubsets(vector& nums) {
- this->nums = nums;
- mx = 0;
- ans = 0;
- for (int x : nums) mx |= x;
+ int ans = 0;
+ int mx = accumulate(nums.begin(), nums.end(), 0, bit_or());
+ auto dfs = [&](this auto&& dfs, int i, int t) {
+ if (i == nums.size()) {
+ if (t == mx) {
+ ans++;
+ }
+ return;
+ }
+ dfs(i + 1, t);
+ dfs(i + 1, t | nums[i]);
+ };
dfs(0, 0);
return ans;
}
-
- void dfs(int i, int t) {
- if (i == nums.size()) {
- if (t == mx) ++ans;
- return;
- }
- dfs(i + 1, t);
- dfs(i + 1, t | nums[i]);
- }
};
```
#### Go
```go
-func countMaxOrSubsets(nums []int) int {
- mx, ans := 0, 0
+func countMaxOrSubsets(nums []int) (ans int) {
+ mx := 0
for _, x := range nums {
mx |= x
}
@@ -181,7 +184,7 @@ func countMaxOrSubsets(nums []int) int {
}
dfs(0, 0)
- return ans
+ return
}
```
@@ -189,20 +192,20 @@ func countMaxOrSubsets(nums []int) int {
```ts
function countMaxOrSubsets(nums: number[]): number {
- let n = nums.length;
- let max = 0;
- for (let i = 0; i < n; i++) {
- max |= nums[i];
- }
let ans = 0;
- function dfs(pre: number, depth: number): void {
- if (depth == n) {
- if (pre == max) ++ans;
+ const mx = nums.reduce((x, y) => x | y, 0);
+
+ const dfs = (i: number, t: number) => {
+ if (i === nums.length) {
+ if (t === mx) {
+ ans++;
+ }
return;
}
- dfs(pre, depth + 1);
- dfs(pre | nums[depth], depth + 1);
- }
+ dfs(i + 1, t);
+ dfs(i + 1, t | nums[i]);
+ };
+
dfs(0, 0);
return ans;
}
@@ -212,33 +215,23 @@ function countMaxOrSubsets(nums: number[]): number {
```rust
impl Solution {
- fn dfs(nums: &Vec, i: usize, sum: i32) -> (i32, i32) {
- let n = nums.len();
- let mut max = i32::MIN;
- let mut res = 0;
- for j in i..n {
- let num = sum | nums[j];
- if num >= max {
- if num > max {
- max = num;
- res = 0;
- }
- res += 1;
- }
- let (r_max, r_res) = Self::dfs(nums, j + 1, num);
- if r_max >= max {
- if r_max > max {
- max = r_max;
- res = 0;
+ pub fn count_max_or_subsets(nums: Vec) -> i32 {
+ let mut ans = 0;
+ let mx = nums.iter().fold(0, |x, &y| x | y);
+
+ fn dfs(i: usize, t: i32, nums: &Vec, mx: i32, ans: &mut i32) {
+ if i == nums.len() {
+ if t == mx {
+ *ans += 1;
}
- res += r_res;
+ return;
}
+ dfs(i + 1, t, nums, mx, ans);
+ dfs(i + 1, t | nums[i], nums, mx, ans);
}
- (max, res)
- }
- pub fn count_max_or_subsets(nums: Vec) -> i32 {
- Self::dfs(&nums, 0, 0).1
+ dfs(0, 0, &nums, mx, &mut ans);
+ ans
}
}
```
@@ -249,147 +242,13 @@ impl Solution {
-### Solution 2
-
-
-
-#### Python3
-
-```python
-class Solution:
- def countMaxOrSubsets(self, nums: List[int]) -> int:
- def dfs(u, t):
- nonlocal ans, mx
- if u == len(nums):
- if t > mx:
- mx, ans = t, 1
- elif t == mx:
- ans += 1
- return
- dfs(u + 1, t | nums[u])
- dfs(u + 1, t)
-
- ans = mx = 0
- dfs(0, 0)
- return ans
-```
-
-#### Java
-
-```java
-class Solution {
- private int mx;
- private int ans;
- private int[] nums;
-
- public int countMaxOrSubsets(int[] nums) {
- this.nums = nums;
- dfs(0, 0);
- return ans;
- }
-
- private void dfs(int u, int t) {
- if (u == nums.length) {
- if (t > mx) {
- mx = t;
- ans = 1;
- } else if (t == mx) {
- ++ans;
- }
- return;
- }
- dfs(u + 1, t);
- dfs(u + 1, t | nums[u]);
- }
-}
-```
-
-#### C++
-
-```cpp
-class Solution {
-public:
- int mx;
- int ans;
-
- int countMaxOrSubsets(vector& nums) {
- dfs(0, 0, nums);
- return ans;
- }
-
- void dfs(int u, int t, vector& nums) {
- if (u == nums.size()) {
- if (t > mx) {
- mx = t;
- ans = 1;
- } else if (t == mx)
- ++ans;
- return;
- }
- dfs(u + 1, t, nums);
- dfs(u + 1, t | nums[u], nums);
- }
-};
-```
-
-#### Go
-
-```go
-func countMaxOrSubsets(nums []int) int {
- n := len(nums)
- ans := 0
- mx := 0
- for mask := 1; mask < 1<> i) & 1) == 1 {
- t |= v
- }
- }
- if mx < t {
- mx = t
- ans = 1
- } else if mx == t {
- ans++
- }
- }
- return ans
-}
-```
-
-#### TypeScript
+### Solution 2: Binary Enumeration
-```ts
-function countMaxOrSubsets(nums: number[]): number {
- const n = nums.length;
- let res = 0;
- let max = -Infinity;
- const dfs = (i: number, sum: number) => {
- for (let j = i; j < n; j++) {
- const num = sum | nums[j];
- if (num >= max) {
- if (num > max) {
- max = num;
- res = 0;
- }
- res++;
- }
- dfs(j + 1, num);
- }
- };
- dfs(0, 0);
+We can use binary enumeration to count the bitwise OR results of all subsets. For an array $\textit{nums}$ of length $n$, we can use an integer $\textit{mask}$ to represent a subset, where the $i$-th bit of $\textit{mask}$ being 1 means including element $\textit{nums[i]}$, and 0 means not including it.
- return res;
-}
-```
+We can iterate through all possible $\textit{mask}$ values from $0$ to $2^n - 1$. For each $\textit{mask}$, we can calculate the bitwise OR result of the corresponding subset and update the maximum value $\textit{mx}$ and answer $\textit{ans}$.
-
-
-
-
-
-
-### Solution 3
+The time complexity is $O(2^n \cdot n)$, where $n$ is the length of the array $\textit{nums}$. The space complexity is $O(1)$.
@@ -471,23 +330,82 @@ public:
#### Go
```go
-func countMaxOrSubsets(nums []int) int {
- mx, ans := 0, 0
- var dfs func(u, t int)
- dfs = func(u, t int) {
- if u == len(nums) {
- if t > mx {
- mx, ans = t, 1
- } else if t == mx {
- ans++
+func countMaxOrSubsets(nums []int) (ans int) {
+ n := len(nums)
+ mx := 0
+
+ for mask := 0; mask < (1 << n); mask++ {
+ t := 0
+ for i, v := range nums {
+ if (mask>>i)&1 == 1 {
+ t |= v
}
- return
}
- dfs(u+1, t)
- dfs(u+1, t|nums[u])
+ if mx < t {
+ mx = t
+ ans = 1
+ } else if mx == t {
+ ans++
+ }
}
- dfs(0, 0)
- return ans
+
+ return
+}
+```
+
+#### TypeScript
+
+```ts
+function countMaxOrSubsets(nums: number[]): number {
+ const n = nums.length;
+ let ans = 0;
+ let mx = 0;
+
+ for (let mask = 0; mask < 1 << n; mask++) {
+ let t = 0;
+ for (let i = 0; i < n; i++) {
+ if ((mask >> i) & 1) {
+ t |= nums[i];
+ }
+ }
+ if (mx < t) {
+ mx = t;
+ ans = 1;
+ } else if (mx === t) {
+ ans++;
+ }
+ }
+
+ return ans;
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+ pub fn count_max_or_subsets(nums: Vec) -> i32 {
+ let n = nums.len();
+ let mut ans = 0;
+ let mut mx = 0;
+
+ for mask in 0..(1 << n) {
+ let mut t = 0;
+ for i in 0..n {
+ if (mask >> i) & 1 == 1 {
+ t |= nums[i];
+ }
+ }
+ if mx < t {
+ mx = t;
+ ans = 1;
+ } else if mx == t {
+ ans += 1;
+ }
+ }
+
+ ans
+ }
}
```
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.cpp b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.cpp
index c8939eb26024f..4e32478c50149 100644
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.cpp
+++ b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.cpp
@@ -1,24 +1,19 @@
class Solution {
public:
- int mx;
- int ans;
- vector nums;
-
int countMaxOrSubsets(vector& nums) {
- this->nums = nums;
- mx = 0;
- ans = 0;
- for (int x : nums) mx |= x;
+ int ans = 0;
+ int mx = accumulate(nums.begin(), nums.end(), 0, bit_or());
+ auto dfs = [&](this auto&& dfs, int i, int t) {
+ if (i == nums.size()) {
+ if (t == mx) {
+ ans++;
+ }
+ return;
+ }
+ dfs(i + 1, t);
+ dfs(i + 1, t | nums[i]);
+ };
dfs(0, 0);
return ans;
}
-
- void dfs(int i, int t) {
- if (i == nums.size()) {
- if (t == mx) ++ans;
- return;
- }
- dfs(i + 1, t);
- dfs(i + 1, t | nums[i]);
- }
-};
\ No newline at end of file
+};
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.go b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.go
index 19cc168adee93..88813db6ec65e 100644
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.go
+++ b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.go
@@ -1,5 +1,5 @@
-func countMaxOrSubsets(nums []int) int {
- mx, ans := 0, 0
+func countMaxOrSubsets(nums []int) (ans int) {
+ mx := 0
for _, x := range nums {
mx |= x
}
@@ -17,5 +17,5 @@ func countMaxOrSubsets(nums []int) int {
}
dfs(0, 0)
- return ans
+ return
}
\ No newline at end of file
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.py b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.py
index 334d606fccb6b..c8718ffec466c 100644
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.py
+++ b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.py
@@ -1,11 +1,7 @@
class Solution:
def countMaxOrSubsets(self, nums: List[int]) -> int:
- mx = ans = 0
- for x in nums:
- mx |= x
-
def dfs(i, t):
- nonlocal mx, ans
+ nonlocal ans, mx
if i == len(nums):
if t == mx:
ans += 1
@@ -13,5 +9,7 @@ def dfs(i, t):
dfs(i + 1, t)
dfs(i + 1, t | nums[i])
+ ans = 0
+ mx = reduce(lambda x, y: x | y, nums)
dfs(0, 0)
return ans
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.rs b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.rs
index 9132d7dd6b653..4362bfdb0cdd8 100644
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.rs
+++ b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.rs
@@ -1,30 +1,20 @@
impl Solution {
- fn dfs(nums: &Vec, i: usize, sum: i32) -> (i32, i32) {
- let n = nums.len();
- let mut max = i32::MIN;
- let mut res = 0;
- for j in i..n {
- let num = sum | nums[j];
- if num >= max {
- if num > max {
- max = num;
- res = 0;
- }
- res += 1;
- }
- let (r_max, r_res) = Self::dfs(nums, j + 1, num);
- if r_max >= max {
- if r_max > max {
- max = r_max;
- res = 0;
+ pub fn count_max_or_subsets(nums: Vec) -> i32 {
+ let mut ans = 0;
+ let mx = nums.iter().fold(0, |x, &y| x | y);
+
+ fn dfs(i: usize, t: i32, nums: &Vec, mx: i32, ans: &mut i32) {
+ if i == nums.len() {
+ if t == mx {
+ *ans += 1;
}
- res += r_res;
+ return;
}
+ dfs(i + 1, t, nums, mx, ans);
+ dfs(i + 1, t | nums[i], nums, mx, ans);
}
- (max, res)
- }
- pub fn count_max_or_subsets(nums: Vec) -> i32 {
- Self::dfs(&nums, 0, 0).1
+ dfs(0, 0, &nums, mx, &mut ans);
+ ans
}
}
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.ts b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.ts
index 7892d8fa13ba1..fca84d99fb8d7 100644
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.ts
+++ b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution.ts
@@ -1,18 +1,18 @@
function countMaxOrSubsets(nums: number[]): number {
- let n = nums.length;
- let max = 0;
- for (let i = 0; i < n; i++) {
- max |= nums[i];
- }
let ans = 0;
- function dfs(pre: number, depth: number): void {
- if (depth == n) {
- if (pre == max) ++ans;
+ const mx = nums.reduce((x, y) => x | y, 0);
+
+ const dfs = (i: number, t: number) => {
+ if (i === nums.length) {
+ if (t === mx) {
+ ans++;
+ }
return;
}
- dfs(pre, depth + 1);
- dfs(pre | nums[depth], depth + 1);
- }
+ dfs(i + 1, t);
+ dfs(i + 1, t | nums[i]);
+ };
+
dfs(0, 0);
return ans;
}
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.cpp b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.cpp
index c8e8122f8587b..aebbbcaebe217 100644
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.cpp
+++ b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.cpp
@@ -1,23 +1,22 @@
class Solution {
public:
- int mx;
- int ans;
-
int countMaxOrSubsets(vector& nums) {
- dfs(0, 0, nums);
- return ans;
- }
-
- void dfs(int u, int t, vector& nums) {
- if (u == nums.size()) {
- if (t > mx) {
+ int n = nums.size();
+ int ans = 0;
+ int mx = 0;
+ for (int mask = 1; mask < 1 << n; ++mask) {
+ int t = 0;
+ for (int i = 0; i < n; ++i) {
+ if ((mask >> i) & 1) {
+ t |= nums[i];
+ }
+ }
+ if (mx < t) {
mx = t;
ans = 1;
- } else if (t == mx)
+ } else if (mx == t)
++ans;
- return;
}
- dfs(u + 1, t, nums);
- dfs(u + 1, t | nums[u], nums);
+ return ans;
}
};
\ No newline at end of file
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.go b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.go
index d017ea1ba963b..ecd53632e8a91 100644
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.go
+++ b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.go
@@ -1,11 +1,11 @@
-func countMaxOrSubsets(nums []int) int {
+func countMaxOrSubsets(nums []int) (ans int) {
n := len(nums)
- ans := 0
mx := 0
- for mask := 1; mask < 1<> i) & 1) == 1 {
+ if (mask>>i)&1 == 1 {
t |= v
}
}
@@ -16,5 +16,6 @@ func countMaxOrSubsets(nums []int) int {
ans++
}
}
- return ans
-}
\ No newline at end of file
+
+ return
+}
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.java b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.java
index 75143a8b30763..401802a01543c 100644
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.java
+++ b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.java
@@ -1,25 +1,22 @@
class Solution {
- private int mx;
- private int ans;
- private int[] nums;
-
public int countMaxOrSubsets(int[] nums) {
- this.nums = nums;
- dfs(0, 0);
- return ans;
- }
-
- private void dfs(int u, int t) {
- if (u == nums.length) {
- if (t > mx) {
+ int n = nums.length;
+ int ans = 0;
+ int mx = 0;
+ for (int mask = 1; mask < 1 << n; ++mask) {
+ int t = 0;
+ for (int i = 0; i < n; ++i) {
+ if (((mask >> i) & 1) == 1) {
+ t |= nums[i];
+ }
+ }
+ if (mx < t) {
mx = t;
ans = 1;
- } else if (t == mx) {
+ } else if (mx == t) {
++ans;
}
- return;
}
- dfs(u + 1, t);
- dfs(u + 1, t | nums[u]);
+ return ans;
}
}
\ No newline at end of file
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.py b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.py
index c7fb372d8f204..7f6b040cf392b 100644
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.py
+++ b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.py
@@ -1,16 +1,16 @@
class Solution:
def countMaxOrSubsets(self, nums: List[int]) -> int:
- def dfs(u, t):
- nonlocal ans, mx
- if u == len(nums):
- if t > mx:
- mx, ans = t, 1
- elif t == mx:
- ans += 1
- return
- dfs(u + 1, t | nums[u])
- dfs(u + 1, t)
-
- ans = mx = 0
- dfs(0, 0)
+ n = len(nums)
+ ans = 0
+ mx = 0
+ for mask in range(1 << n):
+ t = 0
+ for i, v in enumerate(nums):
+ if (mask >> i) & 1:
+ t |= v
+ if mx < t:
+ mx = t
+ ans = 1
+ elif mx == t:
+ ans += 1
return ans
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.rs b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.rs
new file mode 100644
index 0000000000000..d924bfcf3befa
--- /dev/null
+++ b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.rs
@@ -0,0 +1,24 @@
+impl Solution {
+ pub fn count_max_or_subsets(nums: Vec) -> i32 {
+ let n = nums.len();
+ let mut ans = 0;
+ let mut mx = 0;
+
+ for mask in 0..(1 << n) {
+ let mut t = 0;
+ for i in 0..n {
+ if (mask >> i) & 1 == 1 {
+ t |= nums[i];
+ }
+ }
+ if mx < t {
+ mx = t;
+ ans = 1;
+ } else if mx == t {
+ ans += 1;
+ }
+ }
+
+ ans
+ }
+}
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.ts b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.ts
index e3c35b2161906..3da88b9c02132 100644
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.ts
+++ b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution2.ts
@@ -1,21 +1,22 @@
function countMaxOrSubsets(nums: number[]): number {
const n = nums.length;
- let res = 0;
- let max = -Infinity;
- const dfs = (i: number, sum: number) => {
- for (let j = i; j < n; j++) {
- const num = sum | nums[j];
- if (num >= max) {
- if (num > max) {
- max = num;
- res = 0;
- }
- res++;
+ let ans = 0;
+ let mx = 0;
+
+ for (let mask = 0; mask < 1 << n; mask++) {
+ let t = 0;
+ for (let i = 0; i < n; i++) {
+ if ((mask >> i) & 1) {
+ t |= nums[i];
}
- dfs(j + 1, num);
}
- };
- dfs(0, 0);
+ if (mx < t) {
+ mx = t;
+ ans = 1;
+ } else if (mx === t) {
+ ans++;
+ }
+ }
- return res;
+ return ans;
}
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution3.cpp b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution3.cpp
deleted file mode 100644
index aebbbcaebe217..0000000000000
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution3.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-class Solution {
-public:
- int countMaxOrSubsets(vector& nums) {
- int n = nums.size();
- int ans = 0;
- int mx = 0;
- for (int mask = 1; mask < 1 << n; ++mask) {
- int t = 0;
- for (int i = 0; i < n; ++i) {
- if ((mask >> i) & 1) {
- t |= nums[i];
- }
- }
- if (mx < t) {
- mx = t;
- ans = 1;
- } else if (mx == t)
- ++ans;
- }
- return ans;
- }
-};
\ No newline at end of file
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution3.go b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution3.go
deleted file mode 100644
index 0047a1dbf7d07..0000000000000
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution3.go
+++ /dev/null
@@ -1,18 +0,0 @@
-func countMaxOrSubsets(nums []int) int {
- mx, ans := 0, 0
- var dfs func(u, t int)
- dfs = func(u, t int) {
- if u == len(nums) {
- if t > mx {
- mx, ans = t, 1
- } else if t == mx {
- ans++
- }
- return
- }
- dfs(u+1, t)
- dfs(u+1, t|nums[u])
- }
- dfs(0, 0)
- return ans
-}
\ No newline at end of file
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution3.java b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution3.java
deleted file mode 100644
index 401802a01543c..0000000000000
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution3.java
+++ /dev/null
@@ -1,22 +0,0 @@
-class Solution {
- public int countMaxOrSubsets(int[] nums) {
- int n = nums.length;
- int ans = 0;
- int mx = 0;
- for (int mask = 1; mask < 1 << n; ++mask) {
- int t = 0;
- for (int i = 0; i < n; ++i) {
- if (((mask >> i) & 1) == 1) {
- t |= nums[i];
- }
- }
- if (mx < t) {
- mx = t;
- ans = 1;
- } else if (mx == t) {
- ++ans;
- }
- }
- return ans;
- }
-}
\ No newline at end of file
diff --git a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution3.py b/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution3.py
deleted file mode 100644
index 7f6b040cf392b..0000000000000
--- a/solution/2000-2099/2044.Count Number of Maximum Bitwise-OR Subsets/Solution3.py
+++ /dev/null
@@ -1,16 +0,0 @@
-class Solution:
- def countMaxOrSubsets(self, nums: List[int]) -> int:
- n = len(nums)
- ans = 0
- mx = 0
- for mask in range(1 << n):
- t = 0
- for i, v in enumerate(nums):
- if (mask >> i) & 1:
- t |= v
- if mx < t:
- mx = t
- ans = 1
- elif mx == t:
- ans += 1
- return ans
diff --git a/solution/2100-2199/2106.Maximum Fruits Harvested After at Most K Steps/README.md b/solution/2100-2199/2106.Maximum Fruits Harvested After at Most K Steps/README.md
index d487c6ae2cdbf..c3bae1c3e11f4 100644
--- a/solution/2100-2199/2106.Maximum Fruits Harvested After at Most K Steps/README.md
+++ b/solution/2100-2199/2106.Maximum Fruits Harvested After at Most K Steps/README.md
@@ -83,24 +83,24 @@ tags:
### 方法一：双指针
-我们不妨假设移动的位置区间为 $[l,r]$，开始位置为 $startPos$，来看看如何算出移动的最小步数。根据 $startPos$ 所处的位置，我们可以分为三种情况：
+我们不妨假设移动的位置区间为 $[l, r]$，开始位置为 $\textit{startPos}$，来看看如何算出移动的最小步数。根据 $\textit{startPos}$ 所处的位置，我们可以分为三种情况：
-1. 如果 $startPos \leq l$，那么就是从 $startPos$ 一直向右移动到 $r$。移动的最小步数为 $r - startPos$；
-2. 如果 $startPos \geq r$，那么就是从 $startPos$ 一直向左移动到 $l$。移动的最小步数为 $startPos - l$；
-3. 如果 $l \lt startPos \lt r$，那么可以从 $startPos$ 向左移动到 $l$，再向右移动到 $r$；也可以从 $startPos$ 向右移动到 $r$，再向左移动到 $l$。移动的最小步数为 $r - l + \min(\lvert startPos - l \rvert, \lvert r - startPos \rvert)$。
+1. 如果 $\textit{startPos} \leq l$，那么就是从 $\textit{startPos}$ 一直向右移动到 $r$。移动的最小步数为 $r - \textit{startPos}$；
+2. 如果 $\textit{startPos} \geq r$，那么就是从 $\textit{startPos}$ 一直向左移动到 $l$。移动的最小步数为 $\textit{startPos} - l$；
+3. 如果 $l < \textit{startPos} < r$，那么可以从 $\textit{startPos}$ 向左移动到 $l$，再向右移动到 $r$；也可以从 $\textit{startPos}$ 向右移动到 $r$，再向左移动到 $l$。移动的最小步数为 $r - l + \min(\lvert \textit{startPos} - l \rvert, \lvert r - \textit{startPos} \rvert)$。
-以上三种情况可以统一用式子 $r - l + \min(\lvert startPos - l \rvert, \lvert r - startPos \rvert)$ 表示。
+以上三种情况可以统一用式子 $r - l + \min(\lvert \textit{startPos} - l \rvert, \lvert r - \textit{startPos} \rvert)$ 表示。
假设我们固定区间右端点 $r$，向右移动左端点 $l$，我们来看看最小移动步数是怎么变化的。
-1. 如果 $startPos \leq l$，随着 $l$ 的增大，最小步数不会发生变化。
-2. 如果 $startPos \gt l$，随着 $l$ 的增大，最小步数会减小。
+1. 如果 $\textit{startPos} \leq l$，随着 $l$ 的增大，最小步数不会发生变化。
+2. 如果 $\textit{startPos} > l$，随着 $l$ 的增大，最小步数会减小。
因此，随着 $l$ 的增大，最小移动步数一定是非严格单调递减的。基于此，我们可以使用双指针的方法，找出所有符合条件的最大区间，然后取所有符合条件的区间中水果总数最大的一个作为答案。
具体地，我们用两个指针 $i$ 和 $j$ 分别指向区间的左右下标，初始时 $i = j = 0$。另外用一个变量 $s$ 记录区间内的水果总数，初始时 $s = 0$。
-每次我们将 $j$ 加入区间中，然后更新 $s = s + fruits[j][1]$。如果此时区间内的最小步数 $fruits[j][0] - fruits[i][0] + \min(\lvert startPos - fruits[i][0] \rvert, \lvert startPos - fruits[j][0] \rvert)$ 大于 $k$，那么我们就将 $i$ 循环向右移动，直到 $i \gt j$ 或者区间内的最小步数小于等于 $k$。此时我们更新答案 $ans = \max(ans, s)$。继续移动 $j$，直到 $j$ 到达数组末尾。
+每次我们将 $j$ 加入区间中，然后更新 $s = s + \textit{fruits}[j][1]$。如果此时区间内的最小步数 $\textit{fruits}[j][0] - \textit{fruits}[i][0] + \min(\lvert \textit{startPos} - \textit{fruits}[i][0] \rvert, \lvert \textit{startPos} - \textit{fruits}[j][0] \rvert)$ 大于 $k$，那么我们就将 $i$ 循环向右移动，直到 $i > j$ 或者区间内的最小步数小于等于 $k$。此时我们更新答案 $\textit{ans} = \max(\textit{ans}, s)$。继续移动 $j$，直到 $j$ 到达数组末尾。
最后返回答案即可。
@@ -219,6 +219,29 @@ function maxTotalFruits(fruits: number[][], startPos: number, k: number): number
}
```
+#### Rust
+
+```rust
+impl Solution {
+ pub fn max_total_fruits(fruits: Vec>, start_pos: i32, k: i32) -> i32 {
+ let mut ans = 0;
+ let mut s = 0;
+ let mut i = 0;
+ for j in 0..fruits.len() {
+ let pj = fruits[j][0];
+ let fj = fruits[j][1];
+ s += fj;
+ while i <= j && pj - fruits[i][0] + std::cmp::min((start_pos - fruits[i][0]).abs(), (start_pos - pj).abs()) > k {
+ s -= fruits[i][1];
+ i += 1;
+ }
+ ans = ans.max(s)
+ }
+ ans
+ }
+}
+```
+
diff --git a/solution/2100-2199/2106.Maximum Fruits Harvested After at Most K Steps/README_EN.md b/solution/2100-2199/2106.Maximum Fruits Harvested After at Most K Steps/README_EN.md
index 3f9a05e1dfb76..465c59a41e48f 100644
--- a/solution/2100-2199/2106.Maximum Fruits Harvested After at Most K Steps/README_EN.md
+++ b/solution/2100-2199/2106.Maximum Fruits Harvested After at Most K Steps/README_EN.md
@@ -82,7 +82,30 @@ You can move at most k = 2 steps and cannot reach any position with fruits.
-### Solution 1
+### Solution 1: Two Pointers
+
+Let's assume the movement range is $[l, r]$ and the starting position is $\textit{startPos}$. We need to calculate the minimum number of steps required. Based on the position of $\textit{startPos}$, we can divide this into three cases:
+
+1. If $\textit{startPos} \leq l$, then we move right from $\textit{startPos}$ to $r$. The minimum number of steps is $r - \textit{startPos}$;
+2. If $\textit{startPos} \geq r$, then we move left from $\textit{startPos}$ to $l$. The minimum number of steps is $\textit{startPos} - l$;
+3. If $l < \textit{startPos} < r$, we can either move left from $\textit{startPos}$ to $l$ then right to $r$, or move right from $\textit{startPos}$ to $r$ then left to $l$. The minimum number of steps is $r - l + \min(\lvert \textit{startPos} - l \rvert, \lvert r - \textit{startPos} \rvert)$.
+
+All three cases can be unified by the formula $r - l + \min(\lvert \textit{startPos} - l \rvert, \lvert r - \textit{startPos} \rvert)$.
+
+Suppose we fix the right endpoint $r$ of the interval and move the left endpoint $l$ to the right. Let's see how the minimum number of steps changes:
+
+1. If $\textit{startPos} \leq l$, as $l$ increases, the minimum number of steps remains unchanged.
+2. If $\textit{startPos} > l$, as $l$ increases, the minimum number of steps decreases.
+
+Therefore, as $l$ increases, the minimum number of steps is non-strictly monotonically decreasing. Based on this, we can use the two-pointer approach to find all qualifying maximum intervals, then take the one with the maximum total fruits among all qualifying intervals as the answer.
+
+Specifically, we use two pointers $i$ and $j$ to point to the left and right indices of the interval, initially $i = j = 0$. We also use a variable $s$ to record the total number of fruits in the interval, initially $s = 0$.
+
+Each time we include $j$ in the interval, then update $s = s + \textit{fruits}[j][1]$. If the minimum number of steps in the current interval $\textit{fruits}[j][0] - \textit{fruits}[i][0] + \min(\lvert \textit{startPos} - \textit{fruits}[i][0] \rvert, \lvert \textit{startPos} - \textit{fruits}[j][0] \rvert)$ is greater than $k$, we move $i$ to the right in a loop until $i > j$ or the minimum number of steps in the interval is less than or equal to $k$. At this point, we update the answer $\textit{ans} = \max(\textit{ans}, s)$. Continue moving $j$ until $j$ reaches the end of the array.
+
+Finally, return the answer.
+
+The time complexity is $O(n)$, where $n$ is the length of the array. The space complexity is $O(1)$.
@@ -197,6 +220,29 @@ function maxTotalFruits(fruits: number[][], startPos: number, k: number): number
}
```
+#### Rust
+
+```rust
+impl Solution {
+ pub fn max_total_fruits(fruits: Vec>, start_pos: i32, k: i32) -> i32 {
+ let mut ans = 0;
+ let mut s = 0;
+ let mut i = 0;
+ for j in 0..fruits.len() {
+ let pj = fruits[j][0];
+ let fj = fruits[j][1];
+ s += fj;
+ while i <= j && pj - fruits[i][0] + std::cmp::min((start_pos - fruits[i][0]).abs(), (start_pos - pj).abs()) > k {
+ s -= fruits[i][1];
+ i += 1;
+ }
+ ans = ans.max(s)
+ }
+ ans
+ }
+}
+```
+
diff --git a/solution/2100-2199/2106.Maximum Fruits Harvested After at Most K Steps/Solution.rs b/solution/2100-2199/2106.Maximum Fruits Harvested After at Most K Steps/Solution.rs
new file mode 100644
index 0000000000000..e9c789b82dc2e
--- /dev/null
+++ b/solution/2100-2199/2106.Maximum Fruits Harvested After at Most K Steps/Solution.rs
@@ -0,0 +1,22 @@
+impl Solution {
+ pub fn max_total_fruits(fruits: Vec>, start_pos: i32, k: i32) -> i32 {
+ let mut ans = 0;
+ let mut s = 0;
+ let mut i = 0;
+ for j in 0..fruits.len() {
+ let pj = fruits[j][0];
+ let fj = fruits[j][1];
+ s += fj;
+ while i <= j
+ && pj - fruits[i][0]
+ + std::cmp::min((start_pos - fruits[i][0]).abs(), (start_pos - pj).abs())
+ > k
+ {
+ s -= fruits[i][1];
+ i += 1;
+ }
+ ans = ans.max(s)
+ }
+ ans
+ }
+}
diff --git a/solution/2100-2199/2143.Choose Numbers From Two Arrays in Range/README.md b/solution/2100-2199/2143.Choose Numbers From Two Arrays in Range/README.md
index 8a601e38ad610..21f650b5ddf8f 100644
--- a/solution/2100-2199/2143.Choose Numbers From Two Arrays in Range/README.md
+++ b/solution/2100-2199/2143.Choose Numbers From Two Arrays in Range/README.md
@@ -44,7 +44,7 @@ tags:
输入: nums1 = [1,2,5], nums2 = [2,6,3]
输出: 3
解释: 平衡的区间有:
-- [0, 1], 我们选取 nums2[0] 和 nums2[1]。
+- [0, 1], 我们选取 nums2[0] 和 nums1[1]。
从 nums1 中选取的数字和与从 nums2 中选取的数字和相等: 2 = 2.
- [0, 2], 我们选取 nums1[0], nums2[1] 和 nums1[2]。
从 nums1 中选取的数字和与从 nums2 中选取的数字和相等: 1 + 5 = 6。
diff --git a/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/README.md b/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/README.md
index fc6d85ba96c64..f3b21d53007b9 100644
--- a/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/README.md
+++ b/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/README.md
@@ -264,25 +264,25 @@ function minimumDifference(nums: number[]): number {
const n = Math.floor(m / 3);
let s = 0;
const pre: number[] = Array(m + 1);
- const q1 = new MaxPriorityQueue();
+ const q1 = new MaxPriorityQueue();
for (let i = 1; i <= n * 2; ++i) {
const x = nums[i - 1];
s += x;
- q1.enqueue(x, x);
+ q1.enqueue(x);
if (q1.size() > n) {
- s -= q1.dequeue().element;
+ s -= q1.dequeue();
}
pre[i] = s;
}
s = 0;
const suf: number[] = Array(m + 1);
- const q2 = new MinPriorityQueue();
+ const q2 = new MinPriorityQueue();
for (let i = m; i > n; --i) {
const x = nums[i - 1];
s += x;
- q2.enqueue(x, x);
+ q2.enqueue(x);
if (q2.size() > n) {
- s -= q2.dequeue().element;
+ s -= q2.dequeue();
}
suf[i] = s;
}
@@ -294,6 +294,58 @@ function minimumDifference(nums: number[]): number {
}
```
+#### Rust
+
+```rust
+use std::collections::BinaryHeap;
+use std::cmp::Reverse;
+
+impl Solution {
+ pub fn minimum_difference(nums: Vec) -> i64 {
+ let m = nums.len();
+ let n = m / 3;
+ let mut s = 0i64;
+ let mut pre = vec![0i64; m + 1];
+ let mut pq = BinaryHeap::new(); // max-heap
+
+ for i in 1..=2 * n {
+ let x = nums[i - 1] as i64;
+ s += x;
+ pq.push(x);
+ if pq.len() > n {
+ if let Some(top) = pq.pop() {
+ s -= top;
+ }
+ }
+ pre[i] = s;
+ }
+
+ s = 0;
+ let mut suf = vec![0i64; m + 1];
+ let mut pq = BinaryHeap::new();
+
+ for i in (n + 1..=m).rev() {
+ let x = nums[i - 1] as i64;
+ s += x;
+ pq.push(Reverse(x));
+ if pq.len() > n {
+ if let Some(Reverse(top)) = pq.pop() {
+ s -= top;
+ }
+ }
+ suf[i] = s;
+ }
+
+ let mut ans = i64::MAX;
+ for i in n..=2 * n {
+ ans = ans.min(pre[i] - suf[i + 1]);
+ }
+
+ ans
+ }
+}
+```
+
diff --git a/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/README_EN.md b/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/README_EN.md
index a3219e509b366..141608a7e8fcc 100644
--- a/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/README_EN.md
+++ b/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/README_EN.md
@@ -264,25 +264,25 @@ function minimumDifference(nums: number[]): number {
const n = Math.floor(m / 3);
let s = 0;
const pre: number[] = Array(m + 1);
- const q1 = new MaxPriorityQueue();
+ const q1 = new MaxPriorityQueue();
for (let i = 1; i <= n * 2; ++i) {
const x = nums[i - 1];
s += x;
- q1.enqueue(x, x);
+ q1.enqueue(x);
if (q1.size() > n) {
- s -= q1.dequeue().element;
+ s -= q1.dequeue();
}
pre[i] = s;
}
s = 0;
const suf: number[] = Array(m + 1);
- const q2 = new MinPriorityQueue();
+ const q2 = new MinPriorityQueue();
for (let i = m; i > n; --i) {
const x = nums[i - 1];
s += x;
- q2.enqueue(x, x);
+ q2.enqueue(x);
if (q2.size() > n) {
- s -= q2.dequeue().element;
+ s -= q2.dequeue();
}
suf[i] = s;
}
@@ -294,6 +294,58 @@ function minimumDifference(nums: number[]): number {
}
```
+#### Rust
+
+```rust
+use std::collections::BinaryHeap;
+use std::cmp::Reverse;
+
+impl Solution {
+ pub fn minimum_difference(nums: Vec) -> i64 {
+ let m = nums.len();
+ let n = m / 3;
+ let mut s = 0i64;
+ let mut pre = vec![0i64; m + 1];
+ let mut pq = BinaryHeap::new(); // max-heap
+
+ for i in 1..=2 * n {
+ let x = nums[i - 1] as i64;
+ s += x;
+ pq.push(x);
+ if pq.len() > n {
+ if let Some(top) = pq.pop() {
+ s -= top;
+ }
+ }
+ pre[i] = s;
+ }
+
+ s = 0;
+ let mut suf = vec![0i64; m + 1];
+ let mut pq = BinaryHeap::new();
+
+ for i in (n + 1..=m).rev() {
+ let x = nums[i - 1] as i64;
+ s += x;
+ pq.push(Reverse(x));
+ if pq.len() > n {
+ if let Some(Reverse(top)) = pq.pop() {
+ s -= top;
+ }
+ }
+ suf[i] = s;
+ }
+
+ let mut ans = i64::MAX;
+ for i in n..=2 * n {
+ ans = ans.min(pre[i] - suf[i + 1]);
+ }
+
+ ans
+ }
+}
+```
+
diff --git a/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/Solution.rs b/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/Solution.rs
new file mode 100644
index 0000000000000..c0081d3a69131
--- /dev/null
+++ b/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/Solution.rs
@@ -0,0 +1,47 @@
+use std::cmp::Reverse;
+use std::collections::BinaryHeap;
+
+impl Solution {
+ pub fn minimum_difference(nums: Vec) -> i64 {
+ let m = nums.len();
+ let n = m / 3;
+ let mut s = 0i64;
+ let mut pre = vec![0i64; m + 1];
+ let mut pq = BinaryHeap::new(); // max-heap
+
+ for i in 1..=2 * n {
+ let x = nums[i - 1] as i64;
+ s += x;
+ pq.push(x);
+ if pq.len() > n {
+ if let Some(top) = pq.pop() {
+ s -= top;
+ }
+ }
+ pre[i] = s;
+ }
+
+ s = 0;
+ let mut suf = vec![0i64; m + 1];
+ let mut pq = BinaryHeap::new();
+
+ for i in (n + 1..=m).rev() {
+ let x = nums[i - 1] as i64;
+ s += x;
+ pq.push(Reverse(x));
+ if pq.len() > n {
+ if let Some(Reverse(top)) = pq.pop() {
+ s -= top;
+ }
+ }
+ suf[i] = s;
+ }
+
+ let mut ans = i64::MAX;
+ for i in n..=2 * n {
+ ans = ans.min(pre[i] - suf[i + 1]);
+ }
+
+ ans
+ }
+}
diff --git a/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/Solution.ts b/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/Solution.ts
index 2ae41810bf305..d407e351f40a5 100644
--- a/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/Solution.ts
+++ b/solution/2100-2199/2163.Minimum Difference in Sums After Removal of Elements/Solution.ts
@@ -3,25 +3,25 @@ function minimumDifference(nums: number[]): number {
const n = Math.floor(m / 3);
let s = 0;
const pre: number[] = Array(m + 1);
- const q1 = new MaxPriorityQueue();
+ const q1 = new MaxPriorityQueue();
for (let i = 1; i <= n * 2; ++i) {
const x = nums[i - 1];
s += x;
- q1.enqueue(x, x);
+ q1.enqueue(x);
if (q1.size() > n) {
- s -= q1.dequeue().element;
+ s -= q1.dequeue();
}
pre[i] = s;
}
s = 0;
const suf: number[] = Array(m + 1);
- const q2 = new MinPriorityQueue();
+ const q2 = new MinPriorityQueue();
for (let i = m; i > n; --i) {
const x = nums[i - 1];
s += x;
- q2.enqueue(x, x);
+ q2.enqueue(x);
if (q2.size() > n) {
- s -= q2.dequeue().element;
+ s -= q2.dequeue();
}
suf[i] = s;
}
diff --git a/solution/2300-2399/2322.Minimum Score After Removals on a Tree/README.md b/solution/2300-2399/2322.Minimum Score After Removals on a Tree/README.md
index b41b68cd1bac7..65904785b7ae2 100644
--- a/solution/2300-2399/2322.Minimum Score After Removals on a Tree/README.md
+++ b/solution/2300-2399/2322.Minimum Score After Removals on a Tree/README.md
@@ -87,11 +87,13 @@ tags:
### 方法一：DFS + 子树异或和
-枚举 $[0,n)$ 的每个点 $i$ 作为树的根节点，将根节点与某个子节点相连的边作为第一条被删除的边。这样我们就获得了两个连通块，我们记包含根节点 $i$ 的连通块为 $A$，不包含根节点 $i$ 的连通块为 $B$。
+我们记树的异或和为 $s$，即 $s = \text{nums}[0] \oplus \text{nums}[1] \oplus \ldots \oplus \text{nums}[n-1]$。
-在 $A$ 中枚举第二条被删除的边。那么 $A$ 也会被划分成两个连通块 $C$ 和 $D$。
+接下来，枚举 $[0..n)$ 的每个点 $i$ 作为树的根节点，将根节点与某个子节点 $j$ 相连的边作为第一条被删除的边。这样我们就获得了两个连通块，我们记包含根节点 $i$ 的连通块的异或和为 $s_1$，然后我们对包含根节点 $i$ 的连通块进行 DFS，计算出每个子树的异或和，记每次 DFS 计算出的子树异或和为 $s_2$。那么三个连通块的异或和分别为 $s \oplus s_1$, $s_2$ 和 $s_1 \oplus s_2$。我们需要计算这三个异或和的最大值和最小值，记为 $\textit{mx}$ 和 $\textit{mn}$，那么对于枚举的每一种情况，得到的分数为 $\textit{mx} - \textit{mn}$。求所有情况的最小值作为答案。
-记每个连通块的异或和为 $S_i$，那么对于枚举的每一种情况，得到的分数为 $max(S_B, S_C, S_D)-min(S_B, S_C, S_D)$。求所有情况的最小值作为答案。
+计算每个子树的异或和可以通过 DFS 实现。定义一个函数 $\text{dfs}(i, fa)$，表示从节点 $i$ 开始 DFS，而 $fa$ 是节点 $i$ 的父节点。函数返回值为以节点 $i$ 为根的子树的异或和。
+
+时间复杂度 $O(n^2)$，空间复杂度 $O(n)$。其中 $n$ 是树的节点数。
@@ -100,40 +102,36 @@ tags:
```python
class Solution:
def minimumScore(self, nums: List[int], edges: List[List[int]]) -> int:
- def dfs(i, fa, x):
+ def dfs(i: int, fa: int) -> int:
res = nums[i]
for j in g[i]:
- if j != fa and j != x:
- res ^= dfs(j, i, x)
+ if j != fa:
+ res ^= dfs(j, i)
return res
- def dfs2(i, fa, x):
+ def dfs2(i: int, fa: int) -> int:
nonlocal s, s1, ans
res = nums[i]
for j in g[i]:
- if j != fa and j != x:
- a = dfs2(j, i, x)
- res ^= a
- b = s1 ^ a
- c = s ^ s1
- t = max(a, b, c) - min(a, b, c)
- ans = min(ans, t)
+ if j != fa:
+ s2 = dfs2(j, i)
+ res ^= s2
+ mx = max(s ^ s1, s2, s1 ^ s2)
+ mn = min(s ^ s1, s2, s1 ^ s2)
+ ans = min(ans, mx - mn)
return res
g = defaultdict(list)
for a, b in edges:
g[a].append(b)
g[b].append(a)
-
- s = 0
- for v in nums:
- s ^= v
+ s = reduce(lambda x, y: x ^ y, nums)
n = len(nums)
ans = inf
for i in range(n):
for j in g[i]:
- s1 = dfs(i, -1, j)
- dfs2(i, -1, j)
+ s1 = dfs(i, j)
+ dfs2(i, j)
return ans
```
@@ -141,55 +139,53 @@ class Solution:
```java
class Solution {
- private int s;
- private int s1;
- private int n;
- private int ans = Integer.MAX_VALUE;
private int[] nums;
private List[] g;
+ private int ans = Integer.MAX_VALUE;
+ private int s;
+ private int s1;
public int minimumScore(int[] nums, int[][] edges) {
- n = nums.length;
- g = new List[n];
+ int n = nums.length;
this.nums = nums;
+ g = new List[n];
Arrays.setAll(g, k -> new ArrayList<>());
for (int[] e : edges) {
int a = e[0], b = e[1];
g[a].add(b);
g[b].add(a);
}
- for (int v : nums) {
- s ^= v;
+ for (int x : nums) {
+ s ^= x;
}
for (int i = 0; i < n; ++i) {
for (int j : g[i]) {
- s1 = dfs(i, -1, j);
- dfs2(i, -1, j);
+ s1 = dfs(i, j);
+ dfs2(i, j);
}
}
return ans;
}
- private int dfs(int i, int fa, int x) {
+ private int dfs(int i, int fa) {
int res = nums[i];
for (int j : g[i]) {
- if (j != fa && j != x) {
- res ^= dfs(j, i, x);
+ if (j != fa) {
+ res ^= dfs(j, i);
}
}
return res;
}
- private int dfs2(int i, int fa, int x) {
+ private int dfs2(int i, int fa) {
int res = nums[i];
for (int j : g[i]) {
- if (j != fa && j != x) {
- int a = dfs2(j, i, x);
- res ^= a;
- int b = s1 ^ a;
- int c = s ^ s1;
- int t = Math.max(Math.max(a, b), c) - Math.min(Math.min(a, b), c);
- ans = Math.min(ans, t);
+ if (j != fa) {
+ int s2 = dfs2(j, i);
+ res ^= s2;
+ int mx = Math.max(Math.max(s ^ s1, s2), s1 ^ s2);
+ int mn = Math.min(Math.min(s ^ s1, s2), s1 ^ s2);
+ ans = Math.min(ans, mx - mn);
}
}
return res;
@@ -202,52 +198,49 @@ class Solution {
```cpp
class Solution {
public:
- vector nums;
- int s;
- int s1;
- int n;
- int ans = INT_MAX;
- vector> g;
-
int minimumScore(vector& nums, vector>& edges) {
- n = nums.size();
- g.resize(n, vector());
- for (auto& e : edges) {
+ int n = nums.size();
+ vector g[n];
+ for (const auto& e : edges) {
int a = e[0], b = e[1];
g[a].push_back(b);
g[b].push_back(a);
}
- for (int& v : nums) s ^= v;
- this->nums = nums;
+ int s = 0, s1 = 0;
+ int ans = INT_MAX;
+ for (int x : nums) {
+ s ^= x;
+ }
+ auto dfs = [&](this auto&& dfs, int i, int fa) -> int {
+ int res = nums[i];
+ for (int j : g[i]) {
+ if (j != fa) {
+ res ^= dfs(j, i);
+ }
+ }
+ return res;
+ };
+ auto dfs2 = [&](this auto&& dfs2, int i, int fa) -> int {
+ int res = nums[i];
+ for (int j : g[i]) {
+ if (j != fa) {
+ int s2 = dfs2(j, i);
+ res ^= s2;
+ int mx = max({s ^ s1, s2, s1 ^ s2});
+ int mn = min({s ^ s1, s2, s1 ^ s2});
+ ans = min(ans, mx - mn);
+ }
+ }
+ return res;
+ };
for (int i = 0; i < n; ++i) {
for (int j : g[i]) {
- s1 = dfs(i, -1, j);
- dfs2(i, -1, j);
+ s1 = dfs(i, j);
+ dfs2(i, j);
}
}
return ans;
}
-
- int dfs(int i, int fa, int x) {
- int res = nums[i];
- for (int j : g[i])
- if (j != fa && j != x) res ^= dfs(j, i, x);
- return res;
- }
-
- int dfs2(int i, int fa, int x) {
- int res = nums[i];
- for (int j : g[i])
- if (j != fa && j != x) {
- int a = dfs2(j, i, x);
- res ^= a;
- int b = s1 ^ a;
- int c = s ^ s1;
- int t = max(max(a, b), c) - min(min(a, b), c);
- ans = min(ans, t);
- }
- return res;
- }
};
```
@@ -262,47 +255,210 @@ func minimumScore(nums []int, edges [][]int) int {
g[a] = append(g[a], b)
g[b] = append(g[b], a)
}
- s := 0
- for _, v := range nums {
- s ^= v
- }
- s1 := 0
+ s, s1 := 0, 0
ans := math.MaxInt32
- var dfs func(int, int, int) int
- var dfs2 func(int, int, int) int
- dfs = func(i, fa, x int) int {
+ for _, x := range nums {
+ s ^= x
+ }
+ var dfs func(i, fa int) int
+ dfs = func(i, fa int) int {
res := nums[i]
for _, j := range g[i] {
- if j != fa && j != x {
- res ^= dfs(j, i, x)
+ if j != fa {
+ res ^= dfs(j, i)
}
}
return res
}
- dfs2 = func(i, fa, x int) int {
+ var dfs2 func(i, fa int) int
+ dfs2 = func(i, fa int) int {
res := nums[i]
for _, j := range g[i] {
- if j != fa && j != x {
- a := dfs2(j, i, x)
- res ^= a
- b := s1 ^ a
- c := s ^ s1
- t := max(max(a, b), c) - min(min(a, b), c)
- ans = min(ans, t)
+ if j != fa {
+ s2 := dfs2(j, i)
+ res ^= s2
+ mx := max(s^s1, s2, s1^s2)
+ mn := min(s^s1, s2, s1^s2)
+ ans = min(ans, mx-mn)
}
}
return res
}
for i := 0; i < n; i++ {
for _, j := range g[i] {
- s1 = dfs(i, -1, j)
- dfs2(i, -1, j)
+ s1 = dfs(i, j)
+ dfs2(i, j)
}
}
return ans
}
```
+#### TypeScript
+
+```ts
+function minimumScore(nums: number[], edges: number[][]): number {
+ const n = nums.length;
+ const g: number[][] = Array.from({ length: n }, () => []);
+ for (const [a, b] of edges) {
+ g[a].push(b);
+ g[b].push(a);
+ }
+ const s = nums.reduce((a, b) => a ^ b, 0);
+ let s1 = 0;
+ let ans = Number.MAX_SAFE_INTEGER;
+ function dfs(i: number, fa: number): number {
+ let res = nums[i];
+ for (const j of g[i]) {
+ if (j !== fa) {
+ res ^= dfs(j, i);
+ }
+ }
+ return res;
+ }
+ function dfs2(i: number, fa: number): number {
+ let res = nums[i];
+ for (const j of g[i]) {
+ if (j !== fa) {
+ const s2 = dfs2(j, i);
+ res ^= s2;
+ const mx = Math.max(s ^ s1, s2, s1 ^ s2);
+ const mn = Math.min(s ^ s1, s2, s1 ^ s2);
+ ans = Math.min(ans, mx - mn);
+ }
+ }
+ return res;
+ }
+ for (let i = 0; i < n; ++i) {
+ for (const j of g[i]) {
+ s1 = dfs(i, j);
+ dfs2(i, j);
+ }
+ }
+ return ans;
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+ pub fn minimum_score(nums: Vec, edges: Vec>) -> i32 {
+ let n = nums.len();
+ let mut g = vec![vec![]; n];
+ for e in edges.iter() {
+ let a = e[0] as usize;
+ let b = e[1] as usize;
+ g[a].push(b);
+ g[b].push(a);
+ }
+ let mut s1 = 0;
+ let mut ans = i32::MAX;
+ let s = nums.iter().fold(0, |acc, &x| acc ^ x);
+
+ fn dfs(i: usize, fa: usize, g: &Vec>, nums: &Vec) -> i32 {
+ let mut res = nums[i];
+ for &j in &g[i] {
+ if j != fa {
+ res ^= dfs(j, i, g, nums);
+ }
+ }
+ res
+ }
+
+ fn dfs2(
+ i: usize,
+ fa: usize,
+ g: &Vec>,
+ nums: &Vec,
+ s: i32,
+ s1: i32,
+ ans: &mut i32
+ ) -> i32 {
+ let mut res = nums[i];
+ for &j in &g[i] {
+ if j != fa {
+ let s2 = dfs2(j, i, g, nums, s, s1, ans);
+ res ^= s2;
+ let mx = (s ^ s1).max(s2).max(s1 ^ s2);
+ let mn = (s ^ s1).min(s2).min(s1 ^ s2);
+ *ans = (*ans).min(mx - mn);
+ }
+ }
+ res
+ }
+
+ for i in 0..n {
+ for &j in &g[i] {
+ s1 = dfs(i, j, &g, &nums);
+ dfs2(i, j, &g, &nums, s, s1, &mut ans);
+ }
+ }
+ ans
+ }
+}
+```
+
+#### C#
+
+```cs
+public class Solution {
+ public int MinimumScore(int[] nums, int[][] edges) {
+ int n = nums.Length;
+ List[] g = new List[n];
+ for (int i = 0; i < n; i++) {
+ g[i] = new List();
+ }
+ foreach (var e in edges) {
+ int a = e[0], b = e[1];
+ g[a].Add(b);
+ g[b].Add(a);
+ }
+
+ int s = 0;
+ foreach (int x in nums) {
+ s ^= x;
+ }
+
+ int ans = int.MaxValue;
+ int s1 = 0;
+
+ int Dfs(int i, int fa) {
+ int res = nums[i];
+ foreach (int j in g[i]) {
+ if (j != fa) {
+ res ^= Dfs(j, i);
+ }
+ }
+ return res;
+ }
+
+ int Dfs2(int i, int fa) {
+ int res = nums[i];
+ foreach (int j in g[i]) {
+ if (j != fa) {
+ int s2 = Dfs2(j, i);
+ res ^= s2;
+ int mx = Math.Max(Math.Max(s ^ s1, s2), s1 ^ s2);
+ int mn = Math.Min(Math.Min(s ^ s1, s2), s1 ^ s2);
+ ans = Math.Min(ans, mx - mn);
+ }
+ }
+ return res;
+ }
+
+ for (int i = 0; i < n; ++i) {
+ foreach (int j in g[i]) {
+ s1 = Dfs(i, j);
+ Dfs2(i, j);
+ }
+ }
+
+ return ans;
+ }
+}
+```
+
diff --git a/solution/2300-2399/2322.Minimum Score After Removals on a Tree/README_EN.md b/solution/2300-2399/2322.Minimum Score After Removals on a Tree/README_EN.md
index 693b479f9db27..a2e646213d544 100644
--- a/solution/2300-2399/2322.Minimum Score After Removals on a Tree/README_EN.md
+++ b/solution/2300-2399/2322.Minimum Score After Removals on a Tree/README_EN.md
@@ -85,7 +85,15 @@ We cannot obtain a smaller score than 0.
-### Solution 1
+### Solution 1: DFS + Subtree XOR Sum
+
+We denote the XOR sum of the tree as $s$, i.e., $s = \text{nums}[0] \oplus \text{nums}[1] \oplus \ldots \oplus \text{nums}[n-1]$.
+
+Next, we enumerate each node $i$ in $[0..n)$ as the root of the tree, and treat the edge connecting the root node to some child node $j$ as the first edge to be removed. This gives us two connected components. We denote the XOR sum of the connected component containing root node $i$ as $s_1$, then we perform DFS on the connected component containing root node $i$ to calculate the XOR sum of each subtree, denoting each XOR sum calculated by DFS as $s_2$. The XOR sums of the three connected components are $s \oplus s_1$, $s_2$, and $s_1 \oplus s_2$. We need to calculate the maximum and minimum values of these three XOR sums, denoted as $\textit{mx}$ and $\textit{mn}$. For each enumerated case, the score is $\textit{mx} - \textit{mn}$. We find the minimum value among all cases as the answer.
+
+The XOR sum of each subtree can be calculated through DFS. We define a function $\text{dfs}(i, fa)$, which represents starting DFS from node $i$, where $fa$ is the parent node of node $i$. The function returns the XOR sum of the subtree rooted at node $i$.
+
+The time complexity is $O(n^2)$, and the space complexity is $O(n)$, where $n$ is the number of nodes in the tree.
@@ -94,40 +102,36 @@ We cannot obtain a smaller score than 0.
```python
class Solution:
def minimumScore(self, nums: List[int], edges: List[List[int]]) -> int:
- def dfs(i, fa, x):
+ def dfs(i: int, fa: int) -> int:
res = nums[i]
for j in g[i]:
- if j != fa and j != x:
- res ^= dfs(j, i, x)
+ if j != fa:
+ res ^= dfs(j, i)
return res
- def dfs2(i, fa, x):
+ def dfs2(i: int, fa: int) -> int:
nonlocal s, s1, ans
res = nums[i]
for j in g[i]:
- if j != fa and j != x:
- a = dfs2(j, i, x)
- res ^= a
- b = s1 ^ a
- c = s ^ s1
- t = max(a, b, c) - min(a, b, c)
- ans = min(ans, t)
+ if j != fa:
+ s2 = dfs2(j, i)
+ res ^= s2
+ mx = max(s ^ s1, s2, s1 ^ s2)
+ mn = min(s ^ s1, s2, s1 ^ s2)
+ ans = min(ans, mx - mn)
return res
g = defaultdict(list)
for a, b in edges:
g[a].append(b)
g[b].append(a)
-
- s = 0
- for v in nums:
- s ^= v
+ s = reduce(lambda x, y: x ^ y, nums)
n = len(nums)
ans = inf
for i in range(n):
for j in g[i]:
- s1 = dfs(i, -1, j)
- dfs2(i, -1, j)
+ s1 = dfs(i, j)
+ dfs2(i, j)
return ans
```
@@ -135,55 +139,53 @@ class Solution:
```java
class Solution {
- private int s;
- private int s1;
- private int n;
- private int ans = Integer.MAX_VALUE;
private int[] nums;
private List[] g;
+ private int ans = Integer.MAX_VALUE;
+ private int s;
+ private int s1;
public int minimumScore(int[] nums, int[][] edges) {
- n = nums.length;
- g = new List[n];
+ int n = nums.length;
this.nums = nums;
+ g = new List[n];
Arrays.setAll(g, k -> new ArrayList<>());
for (int[] e : edges) {
int a = e[0], b = e[1];
g[a].add(b);
g[b].add(a);
}
- for (int v : nums) {
- s ^= v;
+ for (int x : nums) {
+ s ^= x;
}
for (int i = 0; i < n; ++i) {
for (int j : g[i]) {
- s1 = dfs(i, -1, j);
- dfs2(i, -1, j);
+ s1 = dfs(i, j);
+ dfs2(i, j);
}
}
return ans;
}
- private int dfs(int i, int fa, int x) {
+ private int dfs(int i, int fa) {
int res = nums[i];
for (int j : g[i]) {
- if (j != fa && j != x) {
- res ^= dfs(j, i, x);
+ if (j != fa) {
+ res ^= dfs(j, i);
}
}
return res;
}
- private int dfs2(int i, int fa, int x) {
+ private int dfs2(int i, int fa) {
int res = nums[i];
for (int j : g[i]) {
- if (j != fa && j != x) {
- int a = dfs2(j, i, x);
- res ^= a;
- int b = s1 ^ a;
- int c = s ^ s1;
- int t = Math.max(Math.max(a, b), c) - Math.min(Math.min(a, b), c);
- ans = Math.min(ans, t);
+ if (j != fa) {
+ int s2 = dfs2(j, i);
+ res ^= s2;
+ int mx = Math.max(Math.max(s ^ s1, s2), s1 ^ s2);
+ int mn = Math.min(Math.min(s ^ s1, s2), s1 ^ s2);
+ ans = Math.min(ans, mx - mn);
}
}
return res;
@@ -196,52 +198,49 @@ class Solution {
```cpp
class Solution {
public:
- vector nums;
- int s;
- int s1;
- int n;
- int ans = INT_MAX;
- vector> g;
-
int minimumScore(vector& nums, vector>& edges) {
- n = nums.size();
- g.resize(n, vector());
- for (auto& e : edges) {
+ int n = nums.size();
+ vector g[n];
+ for (const auto& e : edges) {
int a = e[0], b = e[1];
g[a].push_back(b);
g[b].push_back(a);
}
- for (int& v : nums) s ^= v;
- this->nums = nums;
+ int s = 0, s1 = 0;
+ int ans = INT_MAX;
+ for (int x : nums) {
+ s ^= x;
+ }
+ auto dfs = [&](this auto&& dfs, int i, int fa) -> int {
+ int res = nums[i];
+ for (int j : g[i]) {
+ if (j != fa) {
+ res ^= dfs(j, i);
+ }
+ }
+ return res;
+ };
+ auto dfs2 = [&](this auto&& dfs2, int i, int fa) -> int {
+ int res = nums[i];
+ for (int j : g[i]) {
+ if (j != fa) {
+ int s2 = dfs2(j, i);
+ res ^= s2;
+ int mx = max({s ^ s1, s2, s1 ^ s2});
+ int mn = min({s ^ s1, s2, s1 ^ s2});
+ ans = min(ans, mx - mn);
+ }
+ }
+ return res;
+ };
for (int i = 0; i < n; ++i) {
for (int j : g[i]) {
- s1 = dfs(i, -1, j);
- dfs2(i, -1, j);
+ s1 = dfs(i, j);
+ dfs2(i, j);
}
}
return ans;
}
-
- int dfs(int i, int fa, int x) {
- int res = nums[i];
- for (int j : g[i])
- if (j != fa && j != x) res ^= dfs(j, i, x);
- return res;
- }
-
- int dfs2(int i, int fa, int x) {
- int res = nums[i];
- for (int j : g[i])
- if (j != fa && j != x) {
- int a = dfs2(j, i, x);
- res ^= a;
- int b = s1 ^ a;
- int c = s ^ s1;
- int t = max(max(a, b), c) - min(min(a, b), c);
- ans = min(ans, t);
- }
- return res;
- }
};
```
@@ -256,47 +255,210 @@ func minimumScore(nums []int, edges [][]int) int {
g[a] = append(g[a], b)
g[b] = append(g[b], a)
}
- s := 0
- for _, v := range nums {
- s ^= v
- }
- s1 := 0
+ s, s1 := 0, 0
ans := math.MaxInt32
- var dfs func(int, int, int) int
- var dfs2 func(int, int, int) int
- dfs = func(i, fa, x int) int {
+ for _, x := range nums {
+ s ^= x
+ }
+ var dfs func(i, fa int) int
+ dfs = func(i, fa int) int {
res := nums[i]
for _, j := range g[i] {
- if j != fa && j != x {
- res ^= dfs(j, i, x)
+ if j != fa {
+ res ^= dfs(j, i)
}
}
return res
}
- dfs2 = func(i, fa, x int) int {
+ var dfs2 func(i, fa int) int
+ dfs2 = func(i, fa int) int {
res := nums[i]
for _, j := range g[i] {
- if j != fa && j != x {
- a := dfs2(j, i, x)
- res ^= a
- b := s1 ^ a
- c := s ^ s1
- t := max(max(a, b), c) - min(min(a, b), c)
- ans = min(ans, t)
+ if j != fa {
+ s2 := dfs2(j, i)
+ res ^= s2
+ mx := max(s^s1, s2, s1^s2)
+ mn := min(s^s1, s2, s1^s2)
+ ans = min(ans, mx-mn)
}
}
return res
}
for i := 0; i < n; i++ {
for _, j := range g[i] {
- s1 = dfs(i, -1, j)
- dfs2(i, -1, j)
+ s1 = dfs(i, j)
+ dfs2(i, j)
}
}
return ans
}
```
+#### TypeScript
+
+```ts
+function minimumScore(nums: number[], edges: number[][]): number {
+ const n = nums.length;
+ const g: number[][] = Array.from({ length: n }, () => []);
+ for (const [a, b] of edges) {
+ g[a].push(b);
+ g[b].push(a);
+ }
+ const s = nums.reduce((a, b) => a ^ b, 0);
+ let s1 = 0;
+ let ans = Number.MAX_SAFE_INTEGER;
+ function dfs(i: number, fa: number): number {
+ let res = nums[i];
+ for (const j of g[i]) {
+ if (j !== fa) {
+ res ^= dfs(j, i);
+ }
+ }
+ return res;
+ }
+ function dfs2(i: number, fa: number): number {
+ let res = nums[i];
+ for (const j of g[i]) {
+ if (j !== fa) {
+ const s2 = dfs2(j, i);
+ res ^= s2;
+ const mx = Math.max(s ^ s1, s2, s1 ^ s2);
+ const mn = Math.min(s ^ s1, s2, s1 ^ s2);
+ ans = Math.min(ans, mx - mn);
+ }
+ }
+ return res;
+ }
+ for (let i = 0; i < n; ++i) {
+ for (const j of g[i]) {
+ s1 = dfs(i, j);
+ dfs2(i, j);
+ }
+ }
+ return ans;
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+ pub fn minimum_score(nums: Vec, edges: Vec>) -> i32 {
+ let n = nums.len();
+ let mut g = vec![vec![]; n];
+ for e in edges.iter() {
+ let a = e[0] as usize;
+ let b = e[1] as usize;
+ g[a].push(b);
+ g[b].push(a);
+ }
+ let mut s1 = 0;
+ let mut ans = i32::MAX;
+ let s = nums.iter().fold(0, |acc, &x| acc ^ x);
+
+ fn dfs(i: usize, fa: usize, g: &Vec>, nums: &Vec) -> i32 {
+ let mut res = nums[i];
+ for &j in &g[i] {
+ if j != fa {
+ res ^= dfs(j, i, g, nums);
+ }
+ }
+ res
+ }
+
+ fn dfs2(
+ i: usize,
+ fa: usize,
+ g: &Vec>,
+ nums: &Vec,
+ s: i32,
+ s1: i32,
+ ans: &mut i32
+ ) -> i32 {
+ let mut res = nums[i];
+ for &j in &g[i] {
+ if j != fa {
+ let s2 = dfs2(j, i, g, nums, s, s1, ans);
+ res ^= s2;
+ let mx = (s ^ s1).max(s2).max(s1 ^ s2);
+ let mn = (s ^ s1).min(s2).min(s1 ^ s2);
+ *ans = (*ans).min(mx - mn);
+ }
+ }
+ res
+ }
+
+ for i in 0..n {
+ for &j in &g[i] {
+ s1 = dfs(i, j, &g, &nums);
+ dfs2(i, j, &g, &nums, s, s1, &mut ans);
+ }
+ }
+ ans
+ }
+}
+```
+
+#### C#
+
+```cs
+public class Solution {
+ public int MinimumScore(int[] nums, int[][] edges) {
+ int n = nums.Length;
+ List[] g = new List[n];
+ for (int i = 0; i < n; i++) {
+ g[i] = new List();
+ }
+ foreach (var e in edges) {
+ int a = e[0], b = e[1];
+ g[a].Add(b);
+ g[b].Add(a);
+ }
+
+ int s = 0;
+ foreach (int x in nums) {
+ s ^= x;
+ }
+
+ int ans = int.MaxValue;
+ int s1 = 0;
+
+ int Dfs(int i, int fa) {
+ int res = nums[i];
+ foreach (int j in g[i]) {
+ if (j != fa) {
+ res ^= Dfs(j, i);
+ }
+ }
+ return res;
+ }
+
+ int Dfs2(int i, int fa) {
+ int res = nums[i];
+ foreach (int j in g[i]) {
+ if (j != fa) {
+ int s2 = Dfs2(j, i);
+ res ^= s2;
+ int mx = Math.Max(Math.Max(s ^ s1, s2), s1 ^ s2);
+ int mn = Math.Min(Math.Min(s ^ s1, s2), s1 ^ s2);
+ ans = Math.Min(ans, mx - mn);
+ }
+ }
+ return res;
+ }
+
+ for (int i = 0; i < n; ++i) {
+ foreach (int j in g[i]) {
+ s1 = Dfs(i, j);
+ Dfs2(i, j);
+ }
+ }
+
+ return ans;
+ }
+}
+```
+
diff --git a/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.cpp b/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.cpp
index f802fca15468a..feb43c0045a46 100644
--- a/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.cpp
+++ b/solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.cpp
@@ -1,49 +1,46 @@
class Solution {
public:
- vector nums;
- int s;
- int s1;
- int n;
- int ans = INT_MAX;
- vector> g;
-
int minimumScore(vector& nums, vector>& edges) {
- n = nums.size();
- g.resize(n, vector
+
+输入： 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 +解释： 无法由这些点组成任何矩形。