+ problem 2424

Author: fruit-in

Problemset/2424-Longest Uploaded Prefix/README.md

@@ -0,0 +1,80 @@
+# 2424. Longest Uploaded Prefix
+You are given a stream of `n` videos, each represented by a **distinct** number from `1` to `n` that you need to "upload" to a server. You need to implement a data structure that calculates the length of the **longest uploaded prefix** at various points in the upload process.
+
+We consider `i` to be an uploaded prefix if all videos in the range `1` to `i` (**inclusive**) have been uploaded to the server. The longest uploaded prefix is the **maximum** value of `i` that satisfies this definition.
+
+Implement the `LUPrefix` class:
+* `LUPrefix(int n)` Initializes the object for a stream of `n` videos.
+* `void upload(int video)` Uploads `video` to the server.
+* `int longest()` Returns the length of the **longest uploaded prefix** defined above.
+
+#### Example 1:
+<pre>
+<strong>Input:</strong>
+["LUPrefix", "upload", "longest", "upload", "longest", "upload", "longest"]
+[[4], [3], [], [1], [], [2], []]
+<strong>Output:</strong>
+[null, null, 0, null, 1, null, 3]
+<strong>Explanation:</strong>
+LUPrefix server = new LUPrefix(4);   // Initialize a stream of 4 videos.
+server.upload(3);                    // Upload video 3.
+server.longest();                    // Since video 1 has not been uploaded yet, there is no prefix.
+                                     // So, we return 0.
+server.upload(1);                    // Upload video 1.
+server.longest();                    // The prefix [1] is the longest uploaded prefix, so we return 1.
+server.upload(2);                    // Upload video 2.
+server.longest();                    // The prefix [1,2,3] is the longest uploaded prefix, so we return 3.
+</pre>
+
+#### Constraints:
+* <code>1 <= n <= 10<sup>5</sup></code>
+* `1 <= video <= n`
+* All values of `video` are **distinct**.
+* At most <code>2 * 10<sup>5</sup></code> calls **in total** will be made to `upload` and `longest`.
+* At least one call will be made to `longest`.
+
+## Solutions (Rust)
+
+### 1. Solution
+```Rust
+use std::cmp::Reverse;
+use std::collections::BinaryHeap;
+
+struct LUPrefix {
+    heap: BinaryHeap<Reverse<i32>>,
+    longest_uploaded_prefix: i32,
+}
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl LUPrefix {
+    fn new(n: i32) -> Self {
+        Self {
+            heap: BinaryHeap::new(),
+            longest_uploaded_prefix: 0,
+        }
+    }
+
+    fn upload(&mut self, video: i32) {
+        self.heap.push(Reverse(video));
+    }
+
+    fn longest(&mut self) -> i32 {
+        while self.heap.peek().unwrap_or(&Reverse(0)).0 == self.longest_uploaded_prefix + 1 {
+            self.heap.pop();
+            self.longest_uploaded_prefix += 1;
+        }
+
+        self.longest_uploaded_prefix
+    }
+}
+
+/**
+ * Your LUPrefix object will be instantiated and called as such:
+ * let obj = LUPrefix::new(n);
+ * obj.upload(video);
+ * let ret_2: i32 = obj.longest();
+ */
+```

Problemset/2424-Longest Uploaded Prefix/README_CN.md

@@ -0,0 +1,79 @@
+# 2424. 最长上传前缀
+给你一个 `n` 个视频的上传序列，每个视频编号为 `1` 到 `n` 之间的 **不同** 数字，你需要依次将这些视频上传到服务器。请你实现一个数据结构，在上传的过程中计算 **最长上传前缀** 。
+
+如果 **闭区间** `1` 到 `i` 之间的视频全部都已经被上传到服务器，那么我们称 `i` 是上传前缀。最长上传前缀指的是符合定义的 `i` 中的 **最大值** 。
+
+请你实现 `LUPrefix` 类：
+* `LUPrefix(int n)` 初始化一个 `n` 个视频的流对象。
+* `void upload(int video)` 上传 `video` 到服务器。
+* `int longest()` 返回上述定义的 **最长上传前缀** 的长度。
+
+#### 示例 1:
+<pre>
+<strong>输入:</strong>
+["LUPrefix", "upload", "longest", "upload", "longest", "upload", "longest"]
+[[4], [3], [], [1], [], [2], []]
+<strong>输出:</strong>
+[null, null, 0, null, 1, null, 3]
+<strong>解释:</strong>
+LUPrefix server = new LUPrefix(4);   // 初始化 4个视频的上传流
+server.upload(3);                    // 上传视频 3 。
+server.longest();                    // 由于视频 1 还没有被上传，最长上传前缀是 0 。
+server.upload(1);                    // 上传视频 1 。
+server.longest();                    // 前缀 [1] 是最长上传前缀，所以我们返回 1 。
+server.upload(2);                    // 上传视频 2 。
+server.longest();                    // 前缀 [1,2,3] 是最长上传前缀，所以我们返回 3 。
+</pre>
+
+#### 提示:
+* <code>1 <= n <= 10<sup>5</sup></code>
+* `1 <= video <= n`
+* `video` 中所有值 **互不相同** 。
+* `upload` 和 `longest` **总调用** 次数至多不超过 <code>2 * 10<sup>5</sup></code> 次。
+* 至少会调用 `longest` 一次。
+
+## 题解 (Rust)
+
+### 1. 题解
+```Rust
+use std::cmp::Reverse;
+use std::collections::BinaryHeap;
+
+struct LUPrefix {
+    heap: BinaryHeap<Reverse<i32>>,
+    longest_uploaded_prefix: i32,
+}
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl LUPrefix {
+    fn new(n: i32) -> Self {
+        Self {
+            heap: BinaryHeap::new(),
+            longest_uploaded_prefix: 0,
+        }
+    }
+
+    fn upload(&mut self, video: i32) {
+        self.heap.push(Reverse(video));
+    }
+
+    fn longest(&mut self) -> i32 {
+        while self.heap.peek().unwrap_or(&Reverse(0)).0 == self.longest_uploaded_prefix + 1 {
+            self.heap.pop();
+            self.longest_uploaded_prefix += 1;
+        }
+
+        self.longest_uploaded_prefix
+    }
+}
+
+/**
+ * Your LUPrefix object will be instantiated and called as such:
+ * let obj = LUPrefix::new(n);
+ * obj.upload(video);
+ * let ret_2: i32 = obj.longest();
+ */
+```

Problemset/2424-Longest Uploaded Prefix/Solution.rs

@@ -0,0 +1,40 @@
+use std::cmp::Reverse;
+use std::collections::BinaryHeap;
+
+struct LUPrefix {
+    heap: BinaryHeap<Reverse<i32>>,
+    longest_uploaded_prefix: i32,
+}
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl LUPrefix {
+    fn new(n: i32) -> Self {
+        Self {
+            heap: BinaryHeap::new(),
+            longest_uploaded_prefix: 0,
+        }
+    }
+
+    fn upload(&mut self, video: i32) {
+        self.heap.push(Reverse(video));
+    }
+
+    fn longest(&mut self) -> i32 {
+        while self.heap.peek().unwrap_or(&Reverse(0)).0 == self.longest_uploaded_prefix + 1 {
+            self.heap.pop();
+            self.longest_uploaded_prefix += 1;
+        }
+
+        self.longest_uploaded_prefix
+    }
+}
+
+/**
+ * Your LUPrefix object will be instantiated and called as such:
+ * let obj = LUPrefix::new(n);
+ * obj.upload(video);
+ * let ret_2: i32 = obj.longest();
+ */

README.md

@@ -1594,6 +1594,7 @@
 [2419][2419l]|[Longest Subarray With Maximum Bitwise AND][2419]                                     |![rs]
 [2420][2420l]|[Find All Good Indices][2420]                                                         |![rs]
 [2423][2423l]|[Remove Letter To Equalize Frequency][2423]                                           |![rs]
+[2424][2424l]|[Longest Uploaded Prefix][2424]                                                       |![rs]
 [2425][2425l]|[Bitwise XOR of All Pairings][2425]                                                   |![rs]
 [2426][2426l]|[Number of Pairs Satisfying Inequality][2426]                                         |![rs]
 [2427][2427l]|[Number of Common Factors][2427]                                                      |![rs]
@@ -3308,6 +3309,7 @@
 [2419]:Problemset/2419-Longest%20Subarray%20With%20Maximum%20Bitwise%20AND/README.md#2419-longest-subarray-with-maximum-bitwise-and
 [2420]:Problemset/2420-Find%20All%20Good%20Indices/README.md#2420-find-all-good-indices
 [2423]:Problemset/2423-Remove%20Letter%20To%20Equalize%20Frequency/README.md#2423-remove-letter-to-equalize-frequency
+[2424]:Problemset/2424-Longest%20Uploaded%20Prefix/README.md#2424-longest-uploaded-prefix
 [2425]:Problemset/2425-Bitwise%20XOR%20of%20All%20Pairings/README.md#2425-bitwise-xor-of-all-pairings
 [2426]:Problemset/2426-Number%20of%20Pairs%20Satisfying%20Inequality/README.md#2426-number-of-pairs-satisfying-inequality
 [2427]:Problemset/2427-Number%20of%20Common%20Factors/README.md#2427-number-of-common-factors
@@ -5016,6 +5018,7 @@
 [2419l]:https://leetcode.com/problems/longest-subarray-with-maximum-bitwise-and/
 [2420l]:https://leetcode.com/problems/find-all-good-indices/
 [2423l]:https://leetcode.com/problems/remove-letter-to-equalize-frequency/
+[2424l]:https://leetcode.com/problems/longest-uploaded-prefix/
 [2425l]:https://leetcode.com/problems/bitwise-xor-of-all-pairings/
 [2426l]:https://leetcode.com/problems/number-of-pairs-satisfying-inequality/
 [2427l]:https://leetcode.com/problems/number-of-common-factors/

README_CN.md

@@ -1594,6 +1594,7 @@
 [2419][2419l]|[按位与最大的最长子数组][2419]                            |![rs]
 [2420][2420l]|[找到所有好下标][2420]                                    |![rs]
 [2423][2423l]|[删除字符使频率相同][2423]                                |![rs]
+[2424][2424l]|[最长上传前缀][2424]                                      |![rs]
 [2425][2425l]|[所有数对的异或和][2425]                                  |![rs]
 [2426][2426l]|[满足不等式的数对数目][2426]                              |![rs]
 [2427][2427l]|[公因子的数目][2427]                                      |![rs]
@@ -3308,6 +3309,7 @@
 [2419]:Problemset/2419-Longest%20Subarray%20With%20Maximum%20Bitwise%20AND/README_CN.md#2419-按位与最大的最长子数组
 [2420]:Problemset/2420-Find%20All%20Good%20Indices/README_CN.md#2420-找到所有好下标
 [2423]:Problemset/2423-Remove%20Letter%20To%20Equalize%20Frequency/README_CN.md#2423-删除字符使频率相同
+[2424]:Problemset/2424-Longest%20Uploaded%20Prefix/README_CN.md#2424-最长上传前缀
 [2425]:Problemset/2425-Bitwise%20XOR%20of%20All%20Pairings/README_CN.md#2425-所有数对的异或和
 [2426]:Problemset/2426-Number%20of%20Pairs%20Satisfying%20Inequality/README_CN.md#2426-满足不等式的数对数目
 [2427]:Problemset/2427-Number%20of%20Common%20Factors/README_CN.md#2427-公因子的数目
@@ -5016,6 +5018,7 @@
 [2419l]:https://leetcode.cn/problems/longest-subarray-with-maximum-bitwise-and/
 [2420l]:https://leetcode.cn/problems/find-all-good-indices/
 [2423l]:https://leetcode.cn/problems/remove-letter-to-equalize-frequency/
+[2424l]:https://leetcode.cn/problems/longest-uploaded-prefix/
 [2425l]:https://leetcode.cn/problems/bitwise-xor-of-all-pairings/
 [2426l]:https://leetcode.cn/problems/number-of-pairs-satisfying-inequality/
 [2427l]:https://leetcode.cn/problems/number-of-common-factors/