Skip to content

Commit 6569141

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problems: No.3487,3488 (#4594)
1 parent 65f3542 commit 6569141

File tree

8 files changed

+406
-0
lines changed

8 files changed

+406
-0
lines changed

‎solution/3400-3499/3487.Maximum Unique Subarray Sum After Deletion/README.md

Lines changed: 54 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -201,6 +201,60 @@ function maxSum(nums: number[]): number {
201201
}
202202
```
203203

204+
#### Rust
205+
206+
```rust
207+
use std::collections::HashSet;
208+
209+
impl Solution {
210+
pub fn max_sum(nums: Vec<i32>) -> i32 {
211+
let mx = *nums.iter().max().unwrap_or(&0);
212+
if mx <= 0 {
213+
return mx;
214+
}
215+
216+
let mut s = HashSet::new();
217+
let mut ans = 0;
218+
219+
for &x in &nums {
220+
if x < 0 || s.contains(&x) {
221+
continue;
222+
}
223+
ans += x;
224+
s.insert(x);
225+
}
226+
227+
ans
228+
}
229+
}
230+
```
231+
232+
#### C#
233+
234+
```cs
235+
public class Solution {
236+
public int MaxSum(int[] nums) {
237+
int mx = nums.Max();
238+
if (mx <= 0) {
239+
return mx;
240+
}
241+
242+
HashSet<int> s = new HashSet<int>();
243+
int ans = 0;
244+
245+
foreach (int x in nums) {
246+
if (x < 0 || s.Contains(x)) {
247+
continue;
248+
}
249+
ans += x;
250+
s.Add(x);
251+
}
252+
253+
return ans;
254+
}
255+
}
256+
```
257+
204258
<!-- tabs:end -->
205259

206260
<!-- solution:end -->

‎solution/3400-3499/3487.Maximum Unique Subarray Sum After Deletion/README_EN.md

Lines changed: 54 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -198,6 +198,60 @@ function maxSum(nums: number[]): number {
198198
}
199199
```
200200

201+
#### Rust
202+
203+
```rust
204+
use std::collections::HashSet;
205+
206+
impl Solution {
207+
pub fn max_sum(nums: Vec<i32>) -> i32 {
208+
let mx = *nums.iter().max().unwrap_or(&0);
209+
if mx <= 0 {
210+
return mx;
211+
}
212+
213+
let mut s = HashSet::new();
214+
let mut ans = 0;
215+
216+
for &x in &nums {
217+
if x < 0 || s.contains(&x) {
218+
continue;
219+
}
220+
ans += x;
221+
s.insert(x);
222+
}
223+
224+
ans
225+
}
226+
}
227+
```
228+
229+
#### C#
230+
231+
```cs
232+
public class Solution {
233+
public int MaxSum(int[] nums) {
234+
int mx = nums.Max();
235+
if (mx <= 0) {
236+
return mx;
237+
}
238+
239+
HashSet<int> s = new HashSet<int>();
240+
int ans = 0;
241+
242+
foreach (int x in nums) {
243+
if (x < 0 || s.Contains(x)) {
244+
continue;
245+
}
246+
ans += x;
247+
s.Add(x);
248+
}
249+
250+
return ans;
251+
}
252+
}
253+
```
254+
201255
<!-- tabs:end -->
202256

203257
<!-- solution:end -->

‎solution/3400-3499/3487.Maximum Unique Subarray Sum After Deletion/Solution.cs

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
1+
public class Solution {
2+
public int MaxSum(int[] nums) {
3+
int mx = nums.Max();
4+
if (mx <= 0) {
5+
return mx;
6+
}
7+
8+
HashSet<int> s = new HashSet<int>();
9+
int ans = 0;
10+
11+
foreach (int x in nums) {
12+
if (x < 0 || s.Contains(x)) {
13+
continue;
14+
}
15+
ans += x;
16+
s.Add(x);
17+
}
18+
19+
return ans;
20+
}
21+
}

‎solution/3400-3499/3487.Maximum Unique Subarray Sum After Deletion/Solution.rs

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
use std::collections::HashSet;
2+
3+
impl Solution {
4+
pub fn max_sum(nums: Vec<i32>) -> i32 {
5+
let mx = *nums.iter().max().unwrap_or(&0);
6+
if mx <= 0 {
7+
return mx;
8+
}
9+
10+
let mut s = HashSet::new();
11+
let mut ans = 0;
12+
13+
for &x in &nums {
14+
if x < 0 || s.contains(&x) {
15+
continue;
16+
}
17+
ans += x;
18+
s.insert(x);
19+
}
20+
21+
ans
22+
}
23+
}

‎solution/3400-3499/3488.Closest Equal Element Queries/README.md

Lines changed: 87 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -270,6 +270,93 @@ function solveQueries(nums: number[], queries: number[]): number[] {
270270
}
271271
```
272272

273+
#### Rust
274+
275+
```rust
276+
use std::collections::HashMap;
277+
278+
impl Solution {
279+
pub fn solve_queries(nums: Vec<i32>, queries: Vec<i32>) -> Vec<i32> {
280+
let n = nums.len();
281+
let m = n * 2;
282+
let mut d = vec![m as i32; m];
283+
let mut left = HashMap::new();
284+
285+
for i in 0..m {
286+
let x = nums[i % n];
287+
if let Some(&l) = left.get(&x) {
288+
d[i] = d[i].min((i - l) as i32);
289+
}
290+
left.insert(x, i);
291+
}
292+
293+
let mut right = HashMap::new();
294+
295+
for i in (0..m).rev() {
296+
let x = nums[i % n];
297+
if let Some(&r) = right.get(&x) {
298+
d[i] = d[i].min((r - i) as i32);
299+
}
300+
right.insert(x, i);
301+
}
302+
303+
for i in 0..n {
304+
d[i] = d[i].min(d[i + n]);
305+
}
306+
307+
queries.iter().map(|&query| {
308+
if d[query as usize] >= n as i32 {
309+
-1
310+
} else {
311+
d[query as usize]
312+
}
313+
}).collect()
314+
}
315+
}
316+
```
317+
318+
#### C#
319+
320+
```cs
321+
public class Solution {
322+
public IList<int> SolveQueries(int[] nums, int[] queries) {
323+
int n = nums.Length;
324+
int m = n * 2;
325+
int[] d = new int[m];
326+
Array.Fill(d, m);
327+
328+
Dictionary<int, int> left = new Dictionary<int, int>();
329+
for (int i = 0; i < m; i++) {
330+
int x = nums[i % n];
331+
if (left.ContainsKey(x)) {
332+
d[i] = Math.Min(d[i], i - left[x]);
333+
}
334+
left[x] = i;
335+
}
336+
337+
Dictionary<int, int> right = new Dictionary<int, int>();
338+
for (int i = m - 1; i >= 0; i--) {
339+
int x = nums[i % n];
340+
if (right.ContainsKey(x)) {
341+
d[i] = Math.Min(d[i], right[x] - i);
342+
}
343+
right[x] = i;
344+
}
345+
346+
for (int i = 0; i < n; i++) {
347+
d[i] = Math.Min(d[i], d[i + n]);
348+
}
349+
350+
List<int> ans = new List<int>();
351+
foreach (int query in queries) {
352+
ans.Add(d[query] >= n ? -1 : d[query]);
353+
}
354+
355+
return ans;
356+
}
357+
}
358+
```
359+
273360
<!-- tabs:end -->
274361

275362
<!-- solution:end -->

‎solution/3400-3499/3488.Closest Equal Element Queries/README_EN.md

Lines changed: 87 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -268,6 +268,93 @@ function solveQueries(nums: number[], queries: number[]): number[] {
268268
}
269269
```
270270

271+
#### Rust
272+
273+
```rust
274+
use std::collections::HashMap;
275+
276+
impl Solution {
277+
pub fn solve_queries(nums: Vec<i32>, queries: Vec<i32>) -> Vec<i32> {
278+
let n = nums.len();
279+
let m = n * 2;
280+
let mut d = vec![m as i32; m];
281+
let mut left = HashMap::new();
282+
283+
for i in 0..m {
284+
let x = nums[i % n];
285+
if let Some(&l) = left.get(&x) {
286+
d[i] = d[i].min((i - l) as i32);
287+
}
288+
left.insert(x, i);
289+
}
290+
291+
let mut right = HashMap::new();
292+
293+
for i in (0..m).rev() {
294+
let x = nums[i % n];
295+
if let Some(&r) = right.get(&x) {
296+
d[i] = d[i].min((r - i) as i32);
297+
}
298+
right.insert(x, i);
299+
}
300+
301+
for i in 0..n {
302+
d[i] = d[i].min(d[i + n]);
303+
}
304+
305+
queries.iter().map(|&query| {
306+
if d[query as usize] >= n as i32 {
307+
-1
308+
} else {
309+
d[query as usize]
310+
}
311+
}).collect()
312+
}
313+
}
314+
```
315+
316+
#### C#
317+
318+
```cs
319+
public class Solution {
320+
public IList<int> SolveQueries(int[] nums, int[] queries) {
321+
int n = nums.Length;
322+
int m = n * 2;
323+
int[] d = new int[m];
324+
Array.Fill(d, m);
325+
326+
Dictionary<int, int> left = new Dictionary<int, int>();
327+
for (int i = 0; i < m; i++) {
328+
int x = nums[i % n];
329+
if (left.ContainsKey(x)) {
330+
d[i] = Math.Min(d[i], i - left[x]);
331+
}
332+
left[x] = i;
333+
}
334+
335+
Dictionary<int, int> right = new Dictionary<int, int>();
336+
for (int i = m - 1; i >= 0; i--) {
337+
int x = nums[i % n];
338+
if (right.ContainsKey(x)) {
339+
d[i] = Math.Min(d[i], right[x] - i);
340+
}
341+
right[x] = i;
342+
}
343+
344+
for (int i = 0; i < n; i++) {
345+
d[i] = Math.Min(d[i], d[i + n]);
346+
}
347+
348+
List<int> ans = new List<int>();
349+
foreach (int query in queries) {
350+
ans.Add(d[query] >= n ? -1 : d[query]);
351+
}
352+
353+
return ans;
354+
}
355+
}
356+
```
357+
271358
<!-- tabs:end -->
272359

273360
<!-- solution:end -->

‎solution/3400-3499/3488.Closest Equal Element Queries/Solution.cs

Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
public class Solution {
2+
public IList<int> SolveQueries(int[] nums, int[] queries) {
3+
int n = nums.Length;
4+
int m = n * 2;
5+
int[] d = new int[m];
6+
Array.Fill(d, m);
7+
8+
Dictionary<int, int> left = new Dictionary<int, int>();
9+
for (int i = 0; i < m; i++) {
10+
int x = nums[i % n];
11+
if (left.ContainsKey(x)) {
12+
d[i] = Math.Min(d[i], i - left[x]);
13+
}
14+
left[x] = i;
15+
}
16+
17+
Dictionary<int, int> right = new Dictionary<int, int>();
18+
for (int i = m - 1; i >= 0; i--) {
19+
int x = nums[i % n];
20+
if (right.ContainsKey(x)) {
21+
d[i] = Math.Min(d[i], right[x] - i);
22+
}
23+
right[x] = i;
24+
}
25+
26+
for (int i = 0; i < n; i++) {
27+
d[i] = Math.Min(d[i], d[i + n]);
28+
}
29+
30+
List<int> ans = new List<int>();
31+
foreach (int query in queries) {
32+
ans.Add(d[query] >= n ? -1 : d[query]);
33+
}
34+
35+
return ans;
36+
}
37+
}

0 commit comments

Comments
 (0)