Skip to content

Commit 55d4ea1

Browse files
yanglbmeyanglbme
authored
feat: add rust solution to lc problem: No.1751 (#4556)
No.1751.Maximum Number of Events That Can Be Attended II
1 parent 15c59ee commit 55d4ea1

File tree

4 files changed

+224
-0
lines changed

4 files changed

+224
-0
lines changed

‎solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/README.md

Lines changed: 78 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -257,6 +257,47 @@ function maxValue(events: number[][], k: number): number {
257257
}
258258
```
259259

260+
#### Rust
261+
262+
```rust
263+
impl Solution {
264+
pub fn max_value(mut events: Vec<Vec<i32>>, k: i32) -> i32 {
265+
events.sort_by_key(|e| e[0]);
266+
let n = events.len();
267+
let mut f = vec![vec![0; (k + 1) as usize]; n];
268+
269+
fn dfs(i: usize, k: i32, events: &Vec<Vec<i32>>, f: &mut Vec<Vec<i32>>, n: usize) -> i32 {
270+
if i >= n || k <= 0 {
271+
return 0;
272+
}
273+
if f[i][k as usize] != 0 {
274+
return f[i][k as usize];
275+
}
276+
let j = search(events, events[i][1], i + 1, n);
277+
let ans = dfs(i + 1, k, events, f, n).max(dfs(j, k - 1, events, f, n) + events[i][2]);
278+
f[i][k as usize] = ans;
279+
ans
280+
}
281+
282+
fn search(events: &Vec<Vec<i32>>, x: i32, lo: usize, n: usize) -> usize {
283+
let mut l = lo;
284+
let mut r = n;
285+
while l < r {
286+
let mid = (l + r) / 2;
287+
if events[mid][0] > x {
288+
r = mid;
289+
} else {
290+
l = mid + 1;
291+
}
292+
}
293+
l
294+
}
295+
296+
dfs(0, k, &events, &mut f, n)
297+
}
298+
}
299+
```
300+
260301
<!-- tabs:end -->
261302

262303
<!-- solution:end -->
@@ -409,6 +450,43 @@ function maxValue(events: number[][], k: number): number {
409450
}
410451
```
411452

453+
#### Rust
454+
455+
```rust
456+
impl Solution {
457+
pub fn max_value(mut events: Vec<Vec<i32>>, k: i32) -> i32 {
458+
events.sort_by_key(|e| e[1]);
459+
let n = events.len();
460+
let mut f = vec![vec![0; (k + 1) as usize]; n + 1];
461+
462+
for i in 1..=n {
463+
let st = events[i - 1][0];
464+
let val = events[i - 1][2];
465+
let p = search(&events, st, i - 1);
466+
for j in 1..=k as usize {
467+
f[i][j] = f[i - 1][j].max(f[p][j - 1] + val);
468+
}
469+
}
470+
471+
f[n][k as usize]
472+
}
473+
}
474+
475+
fn search(events: &Vec<Vec<i32>>, x: i32, hi: usize) -> usize {
476+
let mut l = 0;
477+
let mut r = hi;
478+
while l < r {
479+
let mid = (l + r) / 2;
480+
if events[mid][1] >= x {
481+
r = mid;
482+
} else {
483+
l = mid + 1;
484+
}
485+
}
486+
l
487+
}
488+
```
489+
412490
<!-- tabs:end -->
413491

414492
<!-- solution:end -->

‎solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/README_EN.md

Lines changed: 78 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -255,6 +255,47 @@ function maxValue(events: number[][], k: number): number {
255255
}
256256
```
257257

258+
#### Rust
259+
260+
```rust
261+
impl Solution {
262+
pub fn max_value(mut events: Vec<Vec<i32>>, k: i32) -> i32 {
263+
events.sort_by_key(|e| e[0]);
264+
let n = events.len();
265+
let mut f = vec![vec![0; (k + 1) as usize]; n];
266+
267+
fn dfs(i: usize, k: i32, events: &Vec<Vec<i32>>, f: &mut Vec<Vec<i32>>, n: usize) -> i32 {
268+
if i >= n || k <= 0 {
269+
return 0;
270+
}
271+
if f[i][k as usize] != 0 {
272+
return f[i][k as usize];
273+
}
274+
let j = search(events, events[i][1], i + 1, n);
275+
let ans = dfs(i + 1, k, events, f, n).max(dfs(j, k - 1, events, f, n) + events[i][2]);
276+
f[i][k as usize] = ans;
277+
ans
278+
}
279+
280+
fn search(events: &Vec<Vec<i32>>, x: i32, lo: usize, n: usize) -> usize {
281+
let mut l = lo;
282+
let mut r = n;
283+
while l < r {
284+
let mid = (l + r) / 2;
285+
if events[mid][0] > x {
286+
r = mid;
287+
} else {
288+
l = mid + 1;
289+
}
290+
}
291+
l
292+
}
293+
294+
dfs(0, k, &events, &mut f, n)
295+
}
296+
}
297+
```
298+
258299
<!-- tabs:end -->
259300

260301
<!-- solution:end -->
@@ -407,6 +448,43 @@ function maxValue(events: number[][], k: number): number {
407448
}
408449
```
409450

451+
#### Rust
452+
453+
```rust
454+
impl Solution {
455+
pub fn max_value(mut events: Vec<Vec<i32>>, k: i32) -> i32 {
456+
events.sort_by_key(|e| e[1]);
457+
let n = events.len();
458+
let mut f = vec![vec![0; (k + 1) as usize]; n + 1];
459+
460+
for i in 1..=n {
461+
let st = events[i - 1][0];
462+
let val = events[i - 1][2];
463+
let p = search(&events, st, i - 1);
464+
for j in 1..=k as usize {
465+
f[i][j] = f[i - 1][j].max(f[p][j - 1] + val);
466+
}
467+
}
468+
469+
f[n][k as usize]
470+
}
471+
}
472+
473+
fn search(events: &Vec<Vec<i32>>, x: i32, hi: usize) -> usize {
474+
let mut l = 0;
475+
let mut r = hi;
476+
while l < r {
477+
let mid = (l + r) / 2;
478+
if events[mid][1] >= x {
479+
r = mid;
480+
} else {
481+
l = mid + 1;
482+
}
483+
}
484+
l
485+
}
486+
```
487+
410488
<!-- tabs:end -->
411489

412490
<!-- solution:end -->

‎solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/Solution.rs

Lines changed: 36 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,36 @@
1+
impl Solution {
2+
pub fn max_value(mut events: Vec<Vec<i32>>, k: i32) -> i32 {
3+
events.sort_by_key(|e| e[0]);
4+
let n = events.len();
5+
let mut f = vec![vec![0; (k + 1) as usize]; n];
6+
7+
fn dfs(i: usize, k: i32, events: &Vec<Vec<i32>>, f: &mut Vec<Vec<i32>>, n: usize) -> i32 {
8+
if i >= n || k <= 0 {
9+
return 0;
10+
}
11+
if f[i][k as usize] != 0 {
12+
return f[i][k as usize];
13+
}
14+
let j = search(events, events[i][1], i + 1, n);
15+
let ans = dfs(i + 1, k, events, f, n).max(dfs(j, k - 1, events, f, n) + events[i][2]);
16+
f[i][k as usize] = ans;
17+
ans
18+
}
19+
20+
fn search(events: &Vec<Vec<i32>>, x: i32, lo: usize, n: usize) -> usize {
21+
let mut l = lo;
22+
let mut r = n;
23+
while l < r {
24+
let mid = (l + r) / 2;
25+
if events[mid][0] > x {
26+
r = mid;
27+
} else {
28+
l = mid + 1;
29+
}
30+
}
31+
l
32+
}
33+
34+
dfs(0, k, &events, &mut f, n)
35+
}
36+
}

‎solution/1700-1799/1751.Maximum Number of Events That Can Be Attended II/Solution2.rs

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
impl Solution {
2+
pub fn max_value(mut events: Vec<Vec<i32>>, k: i32) -> i32 {
3+
events.sort_by_key(|e| e[1]);
4+
let n = events.len();
5+
let mut f = vec![vec![0; (k + 1) as usize]; n + 1];
6+
7+
for i in 1..=n {
8+
let st = events[i - 1][0];
9+
let val = events[i - 1][2];
10+
let p = search(&events, st, i - 1);
11+
for j in 1..=k as usize {
12+
f[i][j] = f[i - 1][j].max(f[p][j - 1] + val);
13+
}
14+
}
15+
16+
f[n][k as usize]
17+
}
18+
}
19+
20+
fn search(events: &Vec<Vec<i32>>, x: i32, hi: usize) -> usize {
21+
let mut l = 0;
22+
let mut r = hi;
23+
while l < r {
24+
let mid = (l + r) / 2;
25+
if events[mid][1] >= x {
26+
r = mid;
27+
} else {
28+
l = mid + 1;
29+
}
30+
}
31+
l
32+
}

0 commit comments

Comments
 (0)