Skip to content

Commit 5583c4d

Browse files
yanglbmeyanglbme
authored
feat: add Rust solutions for lc No.3010 and No.3013 (#5006)
1 parent 6097d01 commit 5583c4d

6 files changed

Lines changed: 393 additions & 0 deletions

File tree

‎solution/3000-3099/3010.Divide an Array Into Subarrays With Minimum Cost I/README.md‎

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -167,6 +167,29 @@ function minimumCost(nums: number[]): number {
167167
}
168168
```
169169

170+
#### Rust
171+
172+
```rust
173+
impl Solution {
174+
pub fn minimum_cost(nums: Vec<i32>) -> i32 {
175+
let a: i32 = nums[0];
176+
let mut b: i32 = i32::MAX;
177+
let mut c: i32 = i32::MAX;
178+
179+
for &x in nums.iter().skip(1) {
180+
if x < b {
181+
c = b;
182+
b = x;
183+
} else if x < c {
184+
c = x;
185+
}
186+
}
187+
188+
a + b + c
189+
}
190+
}
191+
```
192+
170193
<!-- tabs:end -->
171194

172195
<!-- solution:end -->

‎solution/3000-3099/3010.Divide an Array Into Subarrays With Minimum Cost I/README_EN.md‎

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -165,6 +165,29 @@ function minimumCost(nums: number[]): number {
165165
}
166166
```
167167

168+
#### Rust
169+
170+
```rust
171+
impl Solution {
172+
pub fn minimum_cost(nums: Vec<i32>) -> i32 {
173+
let a: i32 = nums[0];
174+
let mut b: i32 = i32::MAX;
175+
let mut c: i32 = i32::MAX;
176+
177+
for &x in nums.iter().skip(1) {
178+
if x < b {
179+
c = b;
180+
b = x;
181+
} else if x < c {
182+
c = x;
183+
}
184+
}
185+
186+
a + b + c
187+
}
188+
}
189+
```
190+
168191
<!-- tabs:end -->
169192

170193
<!-- solution:end -->

‎solution/3000-3099/3010.Divide an Array Into Subarrays With Minimum Cost I/Solution.rs‎

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
impl Solution {
2+
pub fn minimum_cost(nums: Vec<i32>) -> i32 {
3+
let a: i32 = nums[0];
4+
let mut b: i32 = i32::MAX;
5+
let mut c: i32 = i32::MAX;
6+
7+
for &x in nums.iter().skip(1) {
8+
if x < b {
9+
c = b;
10+
b = x;
11+
} else if x < c {
12+
c = x;
13+
}
14+
}
15+
16+
a + b + c
17+
}
18+
}

‎solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README.md‎

Lines changed: 112 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1006,6 +1006,118 @@ class TreapMultiSet<T = number> implements ITreapMultiSet<T> {
10061006
}
10071007
```
10081008

1009+
#### Rust
1010+
1011+
1012+
```rust
1013+
use std::collections::BTreeMap;
1014+
1015+
impl Solution {
1016+
pub fn minimum_cost(nums: Vec<i32>, k: i32, dist: i32) -> i64 {
1017+
let n = nums.len();
1018+
let k = (k - 1) as usize;
1019+
let dist = dist as usize;
1020+
1021+
let mut l: BTreeMap<i32, i32> = BTreeMap::new();
1022+
let mut r: BTreeMap<i32, i32> = BTreeMap::new();
1023+
1024+
let mut s: i64 = nums[0] as i64;
1025+
let mut size: usize = 0;
1026+
1027+
for i in 1..=dist + 1 {
1028+
s += nums[i] as i64;
1029+
*l.entry(nums[i]).or_insert(0) += 1;
1030+
}
1031+
size = dist + 1;
1032+
1033+
while size > k {
1034+
l2r(&mut l, &mut r, &mut s, &mut size);
1035+
}
1036+
1037+
let mut ans = s;
1038+
1039+
for i in dist + 2..n {
1040+
let x = nums[i - dist - 1];
1041+
if let Some(v) = l.get_mut(&x) {
1042+
*v -= 1;
1043+
if *v == 0 {
1044+
l.remove(&x);
1045+
}
1046+
s -= x as i64;
1047+
size -= 1;
1048+
} else {
1049+
let v = r.get_mut(&x).unwrap();
1050+
*v -= 1;
1051+
if *v == 0 {
1052+
r.remove(&x);
1053+
}
1054+
}
1055+
1056+
let y = nums[i];
1057+
let l_max = *l.iter().next_back().unwrap().0;
1058+
if y < l_max {
1059+
*l.entry(y).or_insert(0) += 1;
1060+
size += 1;
1061+
s += y as i64;
1062+
} else {
1063+
*r.entry(y).or_insert(0) += 1;
1064+
}
1065+
1066+
while size < k {
1067+
r2l(&mut l, &mut r, &mut s, &mut size);
1068+
}
1069+
while size > k {
1070+
l2r(&mut l, &mut r, &mut s, &mut size);
1071+
}
1072+
1073+
ans = ans.min(s);
1074+
}
1075+
1076+
ans
1077+
}
1078+
}
1079+
1080+
fn l2r(
1081+
l: &mut BTreeMap<i32, i32>,
1082+
r: &mut BTreeMap<i32, i32>,
1083+
s: &mut i64,
1084+
size: &mut usize,
1085+
) {
1086+
let x = *l.iter().next_back().unwrap().0;
1087+
*s -= x as i64;
1088+
1089+
if let Some(v) = l.get_mut(&x) {
1090+
*v -= 1;
1091+
if *v == 0 {
1092+
l.remove(&x);
1093+
}
1094+
}
1095+
1096+
*size -= 1;
1097+
*r.entry(x).or_insert(0) += 1;
1098+
}
1099+
1100+
fn r2l(
1101+
l: &mut BTreeMap<i32, i32>,
1102+
r: &mut BTreeMap<i32, i32>,
1103+
s: &mut i64,
1104+
size: &mut usize,
1105+
) {
1106+
let x = *r.iter().next().unwrap().0;
1107+
1108+
if let Some(v) = r.get_mut(&x) {
1109+
*v -= 1;
1110+
if *v == 0 {
1111+
r.remove(&x);
1112+
}
1113+
}
1114+
1115+
*l.entry(x).or_insert(0) += 1;
1116+
*s += x as i64;
1117+
*size += 1;
1118+
}
1119+
```
1120+
10091121
<!-- tabs:end -->
10101122

10111123
<!-- solution:end -->

‎solution/3000-3099/3013.Divide an Array Into Subarrays With Minimum Cost II/README_EN.md‎

Lines changed: 111 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1004,6 +1004,117 @@ class TreapMultiSet<T = number> implements ITreapMultiSet<T> {
10041004
}
10051005
```
10061006

1007+
#### Rust
1008+
1009+
```rust
1010+
use std::collections::BTreeMap;
1011+
1012+
impl Solution {
1013+
pub fn minimum_cost(nums: Vec<i32>, k: i32, dist: i32) -> i64 {
1014+
let n = nums.len();
1015+
let k = (k - 1) as usize;
1016+
let dist = dist as usize;
1017+
1018+
let mut l: BTreeMap<i32, i32> = BTreeMap::new();
1019+
let mut r: BTreeMap<i32, i32> = BTreeMap::new();
1020+
1021+
let mut s: i64 = nums[0] as i64;
1022+
let mut size: usize = 0;
1023+
1024+
for i in 1..=dist + 1 {
1025+
s += nums[i] as i64;
1026+
*l.entry(nums[i]).or_insert(0) += 1;
1027+
}
1028+
size = dist + 1;
1029+
1030+
while size > k {
1031+
l2r(&mut l, &mut r, &mut s, &mut size);
1032+
}
1033+
1034+
let mut ans = s;
1035+
1036+
for i in dist + 2..n {
1037+
let x = nums[i - dist - 1];
1038+
if let Some(v) = l.get_mut(&x) {
1039+
*v -= 1;
1040+
if *v == 0 {
1041+
l.remove(&x);
1042+
}
1043+
s -= x as i64;
1044+
size -= 1;
1045+
} else {
1046+
let v = r.get_mut(&x).unwrap();
1047+
*v -= 1;
1048+
if *v == 0 {
1049+
r.remove(&x);
1050+
}
1051+
}
1052+
1053+
let y = nums[i];
1054+
let l_max = *l.iter().next_back().unwrap().0;
1055+
if y < l_max {
1056+
*l.entry(y).or_insert(0) += 1;
1057+
size += 1;
1058+
s += y as i64;
1059+
} else {
1060+
*r.entry(y).or_insert(0) += 1;
1061+
}
1062+
1063+
while size < k {
1064+
r2l(&mut l, &mut r, &mut s, &mut size);
1065+
}
1066+
while size > k {
1067+
l2r(&mut l, &mut r, &mut s, &mut size);
1068+
}
1069+
1070+
ans = ans.min(s);
1071+
}
1072+
1073+
ans
1074+
}
1075+
}
1076+
1077+
fn l2r(
1078+
l: &mut BTreeMap<i32, i32>,
1079+
r: &mut BTreeMap<i32, i32>,
1080+
s: &mut i64,
1081+
size: &mut usize,
1082+
) {
1083+
let x = *l.iter().next_back().unwrap().0;
1084+
*s -= x as i64;
1085+
1086+
if let Some(v) = l.get_mut(&x) {
1087+
*v -= 1;
1088+
if *v == 0 {
1089+
l.remove(&x);
1090+
}
1091+
}
1092+
1093+
*size -= 1;
1094+
*r.entry(x).or_insert(0) += 1;
1095+
}
1096+
1097+
fn r2l(
1098+
l: &mut BTreeMap<i32, i32>,
1099+
r: &mut BTreeMap<i32, i32>,
1100+
s: &mut i64,
1101+
size: &mut usize,
1102+
) {
1103+
let x = *r.iter().next().unwrap().0;
1104+
1105+
if let Some(v) = r.get_mut(&x) {
1106+
*v -= 1;
1107+
if *v == 0 {
1108+
r.remove(&x);
1109+
}
1110+
}
1111+
1112+
*l.entry(x).or_insert(0) += 1;
1113+
*s += x as i64;
1114+
*size += 1;
1115+
}
1116+
```
1117+
10071118
<!-- tabs:end -->
10081119

10091120
<!-- solution:end -->

0 commit comments

Comments
 (0)