feat: add Rust solution for lc No.3851 (#5046)

Author: yanglbme

solution/3800-3899/3851.Maximum Requests Without Violating the Limit/README.md

@@ -94,7 +94,11 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3800-3899/3851.Ma
 
 我们可以将请求按照用户进行分组，放在哈希表 $g$ 中，其中 $g[u]$ 是用户 $u$ 的请求时间列表。对于每个用户，我们需要从请求时间列表中删除一些请求，使得在任意长度为 $window$ 的区间内，剩余的请求数不超过 $k$。
 
-对于用户 $u$ 的请求时间列表 $g[u]$，我们首先对其进行排序。然后，我们使用一个双端队列 $kept$ 来维护当前保留的请求时间。我们遍历请求时间列表中的每个请求时间 $t$，对于每个请求时间，我们需要将 $kept$ 中所有与 $t$ 的差值大于 $window$ 的请求时间删除掉。然后，我们将 $t$ 添加到 $kept$ 中。如果此时 $kept$ 中的请求数超过了 $k$，我们需要删除掉 $kept$ 中的最后一个请求时间，并增加删除的请求数。最后，我们将用户 $u$ 的请求数减去删除的请求数，累加到答案中。
+我们初始化答案 $\textit{ans}$ 为请求的总数。
+
+对于用户 $u$ 的请求时间列表 $g[u]$，我们首先对其进行排序。然后，我们使用一个双端队列 $kept$ 来维护当前保留的请求时间。我们遍历请求时间列表中的每个请求时间 $t$，对于每个请求时间，我们需要将 $kept$ 中所有与 $t$ 的差值大于 $window$ 的请求时间删除掉。然后，如果 $kept$ 中剩余的请求数小于 $k$，我们就将 $t$ 添加到 $kept$ 中，否则我们需要删除 $t$，并将答案减 1。
+
+最后返回答案 $\textit{ans}$。
 
 时间复杂度 $O(n \log n)$，空间复杂度 $O(n)$，其中 $n$ 是请求的数量。每个请求被访问一次，排序需要 $O(n \log n)$ 的时间，哈希表和双端队列的操作需要 $O(n)$ 的时间。
 
@@ -108,19 +112,17 @@ class Solution:
         g = defaultdict(list)
         for u, t in requests:
             g[u].append(t)
-        ans = 0
+        ans = len(requests)
         for ts in g.values():
             ts.sort()
             kept = deque()
-            deletions = 0
             for t in ts:
                 while kept and t - kept[0] > window:
                     kept.popleft()
-                kept.append(t)
-                if len(kept) > k:
-                    kept.pop()
-                    deletions += 1
-            ans += len(ts) - deletions
+                if len(kept) < k:
+                    kept.append(t)
+                else:
+                    ans -= 1
         return ans
 ```
 
@@ -135,25 +137,22 @@ class Solution {
             g.computeIfAbsent(u, x -> new ArrayList<>()).add(t);
         }
 
-        int ans = 0;
+        int ans = requests.length;
         ArrayDeque<Integer> kept = new ArrayDeque<>();
 
         for (List<Integer> ts : g.values()) {
             Collections.sort(ts);
             kept.clear();
-            int deletions = 0;
-
             for (int t : ts) {
                 while (!kept.isEmpty() && t - kept.peekFirst() > window) {
                     kept.pollFirst();
                 }
-                kept.addLast(t);
-                if (kept.size() > k) {
-                    kept.pollLast();
-                    deletions++;
+                if (kept.size() < k) {
+                    kept.addLast(t);
+                } else {
+                    --ans;
                 }
             }
-            ans += ts.size() - deletions;
         }
         return ans;
     }
@@ -167,31 +166,26 @@ class Solution {
 public:
     int maxRequests(vector<vector<int>>& requests, int k, int window) {
         unordered_map<int, vector<int>> g;
-        g.reserve(requests.size() * 2);
-
         for (auto& r : requests) {
             g[r[0]].push_back(r[1]);
         }
 
-        int ans = 0;
-        deque<int> kept;
-
+        int ans = requests.size();
         for (auto& [_, ts] : g) {
             sort(ts.begin(), ts.end());
-            kept.clear();
+            queue<int> kept;
             int deletions = 0;
 
             for (int t : ts) {
                 while (!kept.empty() && t - kept.front() > window) {
-                    kept.pop_front();
+                    kept.pop();
                 }
-                kept.push_back(t);
-                if (kept.size() > k) {
-                    kept.pop_back();
-                    deletions++;
+                if (kept.size() < k) {
+                    kept.push(t);
+                } else {
+                    ans--;
                 }
             }
-            ans += ts.size() - deletions;
         }
         return ans;
     }
@@ -201,33 +195,28 @@ public:
 #### Go
 
 ```go
-func maxRequests(requests [][]int, k int, window int) (ans int) {
+func maxRequests(requests [][]int, k int, window int) int {
 	g := make(map[int][]int)
 	for _, r := range requests {
 		u, t := r[0], r[1]
 		g[u] = append(g[u], t)
 	}
+	ans := len(requests)
 	for _, ts := range g {
 		sort.Ints(ts)
-
 		kept := make([]int, 0)
-		head := 0
-		deletions := 0
-
 		for _, t := range ts {
-			for head < len(kept) && t-kept[head] > window {
-				head++
+			for len(kept) > 0 && t-kept[0] > window {
+				kept = kept[1:]
 			}
-			kept = append(kept, t)
-			if len(kept)-head > k {
-				kept = kept[:len(kept)-1]
-				deletions++
+			if len(kept) < k {
+				kept = append(kept, t)
+			} else {
+				ans--
 			}
 		}
-
-		ans += len(ts) - deletions
 	}
-	return
+	return ans
 }
 ```
 
@@ -240,32 +229,69 @@ function maxRequests(requests: number[][], k: number, window: number): number {
         if (!g.has(u)) g.set(u, []);
         g.get(u)!.push(t);
     }
-
-    let ans = 0;
-
+    let ans = requests.length;
     for (const ts of g.values()) {
         ts.sort((a, b) => a - b);
-
         const kept: number[] = [];
         let head = 0;
-        let deletions = 0;
-
         for (const t of ts) {
-            while (head < kept.length && t - kept[head] > window) head++;
-            kept.push(t);
-            if (kept.length - head > k) {
-                kept.pop();
-                deletions++;
+            while (head < kept.length && t - kept[head] > window) {
+                head++;
+            }
+            if (kept.length - head < k) {
+                kept.push(t);
+            } else {
+                --ans;
             }
         }
-
-        ans += ts.length - deletions;
     }
-
     return ans;
 }
 ```
 
+#### Rust
+
+```rust
+use std::collections::{HashMap, VecDeque};
+
+impl Solution {
+    pub fn max_requests(requests: Vec<Vec<i32>>, k: i32, window: i32) -> i32 {
+        let mut g: HashMap<i32, Vec<i32>> = HashMap::new();
+        for r in &requests {
+            let u: i32 = r[0];
+            let t: i32 = r[1];
+            g.entry(u).or_insert_with(Vec::new).push(t);
+        }
+
+        let mut ans: i32 = requests.len() as i32;
+        let mut kept: VecDeque<i32> = VecDeque::new();
+
+        for ts in g.values_mut() {
+            ts.sort();
+            kept.clear();
+
+            for &t in ts.iter() {
+                while let Some(&front) = kept.front() {
+                    if t - front > window {
+                        kept.pop_front();
+                    } else {
+                        break;
+                    }
+                }
+
+                if kept.len() < k as usize {
+                    kept.push_back(t);
+                } else {
+                    ans -= 1;
+                }
+            }
+        }
+
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->