feat: add rust solution to lc problem: No.1751

No.1751.Maximum Number of Events That Can Be Attended II
doocs · yanglbme · Jul 7, 2025 · Jul 7, 2025 · Jul 7, 2025 · f866ee0199f44189c5188a244f9731f685f1b496
commit f866ee0199f44189c5188a244f9731f685f1b496
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
@@ -257,6 +257,47 @@ function maxValue(events: number[][], k: number): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn max_value(mut events: Vec<Vec<i32>>, 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<Vec<i32>>, f: &mut Vec<Vec<i32>>, 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<Vec<i32>>, 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)
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
@@ -409,6 +450,43 @@ function maxValue(events: number[][], k: number): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn max_value(mut events: Vec<Vec<i32>>, 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<Vec<i32>>, 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
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

diff --git a/...on/1700-1799/1751.Maximum Number of Events That Can Be Attended II/README_EN.md b/...on/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<Vec<i32>>, 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<Vec<i32>>, f: &mut Vec<Vec<i32>>, 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<Vec<i32>>, 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)
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
@@ -407,6 +448,43 @@ function maxValue(events: number[][], k: number): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn max_value(mut events: Vec<Vec<i32>>, 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<Vec<i32>>, 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
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

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
@@ -0,0 +1,36 @@
+impl Solution {
+    pub fn max_value(mut events: Vec<Vec<i32>>, 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<Vec<i32>>, f: &mut Vec<Vec<i32>>, 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<Vec<i32>>, 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
@@ -0,0 +1,32 @@
+impl Solution {
+    pub fn max_value(mut events: Vec<Vec<i32>>, 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<Vec<i32>>, 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
+}