Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit c4a3da0

Browse files
authored
feat: add rust solution to lc problem: No.1697 (doocs#1132)
1 parent e15b28b commit c4a3da0

File tree

3 files changed

+214
-0
lines changed

3 files changed

+214
-0
lines changed

‎solution/1600-1699/1697.Checking Existence of Edge Length Limited Paths/README.md‎

Lines changed: 73 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -276,6 +276,79 @@ public:
276276
};
277277
```
278278
279+
### **Rust**
280+
281+
```rust
282+
impl Solution {
283+
#[allow(dead_code)]
284+
pub fn distance_limited_paths_exist(n: i32, edge_list: Vec<Vec<i32>>, queries: Vec<Vec<i32>>) -> Vec<bool> {
285+
let mut disjoint_set: Vec<usize> = vec![0; n as usize];
286+
let mut ans_vec: Vec<bool> = vec![false; queries.len()];
287+
let mut q_vec: Vec<usize> = vec![0; queries.len()];
288+
289+
// Initialize the set
290+
for i in 0..n {
291+
disjoint_set[i as usize] = i as usize;
292+
}
293+
294+
// Initialize the q_vec
295+
for i in 0..queries.len() {
296+
q_vec[i] = i;
297+
}
298+
299+
// Sort the q_vec based on the query limit, from the lowest to highest
300+
q_vec.sort_by(|i, j| queries[*i][2].cmp(&queries[*j][2]));
301+
302+
// Sort the edge_list based on the edge weight, from the lowest to highest
303+
let mut edge_list = edge_list.clone();
304+
edge_list.sort_by(|i, j| i[2].cmp(&j[2]));
305+
306+
let mut edge_idx: usize = 0;
307+
for q_idx in &q_vec {
308+
let s = queries[*q_idx][0] as usize;
309+
let d = queries[*q_idx][1] as usize;
310+
let limit = queries[*q_idx][2];
311+
// Construct the disjoint set
312+
while edge_idx < edge_list.len() && edge_list[edge_idx][2] < limit {
313+
Solution::union(
314+
edge_list[edge_idx][0] as usize,
315+
edge_list[edge_idx][1] as usize,
316+
&mut disjoint_set
317+
);
318+
edge_idx += 1;
319+
}
320+
// If the parents of s & d are the same, this query should be `true`
321+
// Otherwise, the current query is `false`
322+
ans_vec[*q_idx] = Solution::check_valid(s, d, &mut disjoint_set);
323+
}
324+
325+
ans_vec
326+
}
327+
328+
#[allow(dead_code)]
329+
pub fn find(x: usize, d_set: &mut Vec<usize>) -> usize {
330+
if d_set[x] != x {
331+
d_set[x] = Solution::find(d_set[x], d_set);
332+
}
333+
return d_set[x];
334+
}
335+
336+
#[allow(dead_code)]
337+
pub fn union(s: usize, d: usize, d_set: &mut Vec<usize>) {
338+
let p_s = Solution::find(s, d_set);
339+
let p_d = Solution::find(d, d_set);
340+
d_set[p_s] = p_d;
341+
}
342+
343+
#[allow(dead_code)]
344+
pub fn check_valid(s: usize, d: usize, d_set: &mut Vec<usize>) -> bool {
345+
let p_s = Solution::find(s, d_set);
346+
let p_d = Solution::find(d, d_set);
347+
p_s == p_d
348+
}
349+
}
350+
```
351+
279352
### **Go**
280353

281354
```go

‎solution/1600-1699/1697.Checking Existence of Edge Length Limited Paths/README_EN.md‎

Lines changed: 73 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -149,6 +149,79 @@ public:
149149
};
150150
```
151151
152+
### **Rust**
153+
154+
```rust
155+
impl Solution {
156+
#[allow(dead_code)]
157+
pub fn distance_limited_paths_exist(n: i32, edge_list: Vec<Vec<i32>>, queries: Vec<Vec<i32>>) -> Vec<bool> {
158+
let mut disjoint_set: Vec<usize> = vec![0; n as usize];
159+
let mut ans_vec: Vec<bool> = vec![false; queries.len()];
160+
let mut q_vec: Vec<usize> = vec![0; queries.len()];
161+
162+
// Initialize the set
163+
for i in 0..n {
164+
disjoint_set[i as usize] = i as usize;
165+
}
166+
167+
// Initialize the q_vec
168+
for i in 0..queries.len() {
169+
q_vec[i] = i;
170+
}
171+
172+
// Sort the q_vec based on the query limit, from the lowest to highest
173+
q_vec.sort_by(|i, j| queries[*i][2].cmp(&queries[*j][2]));
174+
175+
// Sort the edge_list based on the edge weight, from the lowest to highest
176+
let mut edge_list = edge_list.clone();
177+
edge_list.sort_by(|i, j| i[2].cmp(&j[2]));
178+
179+
let mut edge_idx: usize = 0;
180+
for q_idx in &q_vec {
181+
let s = queries[*q_idx][0] as usize;
182+
let d = queries[*q_idx][1] as usize;
183+
let limit = queries[*q_idx][2];
184+
// Construct the disjoint set
185+
while edge_idx < edge_list.len() && edge_list[edge_idx][2] < limit {
186+
Solution::union(
187+
edge_list[edge_idx][0] as usize,
188+
edge_list[edge_idx][1] as usize,
189+
&mut disjoint_set
190+
);
191+
edge_idx += 1;
192+
}
193+
// If the parents of s & d are the same, this query should be `true`
194+
// Otherwise, the current query is `false`
195+
ans_vec[*q_idx] = Solution::check_valid(s, d, &mut disjoint_set);
196+
}
197+
198+
ans_vec
199+
}
200+
201+
#[allow(dead_code)]
202+
pub fn find(x: usize, d_set: &mut Vec<usize>) -> usize {
203+
if d_set[x] != x {
204+
d_set[x] = Solution::find(d_set[x], d_set);
205+
}
206+
return d_set[x];
207+
}
208+
209+
#[allow(dead_code)]
210+
pub fn union(s: usize, d: usize, d_set: &mut Vec<usize>) {
211+
let p_s = Solution::find(s, d_set);
212+
let p_d = Solution::find(d, d_set);
213+
d_set[p_s] = p_d;
214+
}
215+
216+
#[allow(dead_code)]
217+
pub fn check_valid(s: usize, d: usize, d_set: &mut Vec<usize>) -> bool {
218+
let p_s = Solution::find(s, d_set);
219+
let p_d = Solution::find(d, d_set);
220+
p_s == p_d
221+
}
222+
}
223+
```
224+
152225
### **Go**
153226

154227
```go
Lines changed: 68 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,68 @@
1+
impl Solution {
2+
#[allow(dead_code)]
3+
pub fn distance_limited_paths_exist(n: i32, edge_list: Vec<Vec<i32>>, queries: Vec<Vec<i32>>) -> Vec<bool> {
4+
let mut disjoint_set: Vec<usize> = vec![0; n as usize];
5+
let mut ans_vec: Vec<bool> = vec![false; queries.len()];
6+
let mut q_vec: Vec<usize> = vec![0; queries.len()];
7+
8+
// Initialize the set
9+
for i in 0..n {
10+
disjoint_set[i as usize] = i as usize;
11+
}
12+
13+
// Initialize the q_vec
14+
for i in 0..queries.len() {
15+
q_vec[i] = i;
16+
}
17+
18+
// Sort the q_vec based on the query limit, from the lowest to highest
19+
q_vec.sort_by(|i, j| queries[*i][2].cmp(&queries[*j][2]));
20+
21+
// Sort the edge_list based on the edge weight, from the lowest to highest
22+
let mut edge_list = edge_list.clone();
23+
edge_list.sort_by(|i, j| i[2].cmp(&j[2]));
24+
25+
let mut edge_idx: usize = 0;
26+
for q_idx in &q_vec {
27+
let s = queries[*q_idx][0] as usize;
28+
let d = queries[*q_idx][1] as usize;
29+
let limit = queries[*q_idx][2];
30+
// Construct the disjoint set
31+
while edge_idx < edge_list.len() && edge_list[edge_idx][2] < limit {
32+
Solution::union(
33+
edge_list[edge_idx][0] as usize,
34+
edge_list[edge_idx][1] as usize,
35+
&mut disjoint_set
36+
);
37+
edge_idx += 1;
38+
}
39+
// If the parents of s & d are the same, this query should be `true`
40+
// Otherwise, the current query is `false`
41+
ans_vec[*q_idx] = Solution::check_valid(s, d, &mut disjoint_set);
42+
}
43+
44+
ans_vec
45+
}
46+
47+
#[allow(dead_code)]
48+
pub fn find(x: usize, d_set: &mut Vec<usize>) -> usize {
49+
if d_set[x] != x {
50+
d_set[x] = Solution::find(d_set[x], d_set);
51+
}
52+
return d_set[x];
53+
}
54+
55+
#[allow(dead_code)]
56+
pub fn union(s: usize, d: usize, d_set: &mut Vec<usize>) {
57+
let p_s = Solution::find(s, d_set);
58+
let p_d = Solution::find(d, d_set);
59+
d_set[p_s] = p_d;
60+
}
61+
62+
#[allow(dead_code)]
63+
pub fn check_valid(s: usize, d: usize, d_set: &mut Vec<usize>) -> bool {
64+
let p_s = Solution::find(s, d_set);
65+
let p_d = Solution::find(d, d_set);
66+
p_s == p_d
67+
}
68+
}

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /