Skip to content

Commit 6279a4b

Browse files
poltaopoltao
authored
feat: add rust solution to lc problem: No.0399 (#1646)
No.0399.Evaluate Division
1 parent a9b1719 commit 6279a4b

File tree

3 files changed

+271
-0
lines changed

3 files changed

+271
-0
lines changed

‎solution/0300-0399/0399.Evaluate Division/README.md

+92
Original file line numberDiff line numberDiff line change
@@ -305,6 +305,98 @@ func calcEquation(equations [][]string, values []float64, queries [][]string) []
305305
}
306306
```
307307

308+
### **Rust**
309+
310+
```rust
311+
use std::collections::HashMap;
312+
313+
#[derive(Debug)]
314+
pub struct DSUNode {
315+
parent: String,
316+
weight: f64,
317+
}
318+
319+
pub struct DisjointSetUnion {
320+
nodes: HashMap<String, DSUNode>,
321+
}
322+
323+
impl DisjointSetUnion {
324+
pub fn new(equations: &Vec<Vec<String>>) -> DisjointSetUnion {
325+
let mut nodes = HashMap::new();
326+
for equation in equations.iter() {
327+
for iter in equation.iter() {
328+
nodes.insert(
329+
iter.clone(),
330+
DSUNode {
331+
parent: iter.clone(),
332+
weight: 1.0,
333+
},
334+
);
335+
}
336+
}
337+
DisjointSetUnion { nodes }
338+
}
339+
340+
pub fn find(&mut self, v: &String) -> String {
341+
let origin = self.nodes[v].parent.clone();
342+
if origin == *v {
343+
return origin;
344+
}
345+
346+
let root = self.find(&origin);
347+
self.nodes.get_mut(v).unwrap().parent = root.clone();
348+
self.nodes.get_mut(v).unwrap().weight *= self.nodes[&origin].weight;
349+
root
350+
}
351+
352+
pub fn union(&mut self, a: &String, b: &String, v: f64) {
353+
let pa = self.find(a);
354+
let pb = self.find(b);
355+
if pa == pb {
356+
return;
357+
}
358+
let (wa, wb) = (self.nodes[a].weight, self.nodes[b].weight);
359+
self.nodes.get_mut(&pa).unwrap().parent = pb;
360+
self.nodes.get_mut(&pa).unwrap().weight = wb * v / wa;
361+
}
362+
363+
pub fn exist(&mut self, k: &String) -> bool {
364+
self.nodes.contains_key(k)
365+
}
366+
367+
pub fn calc_value(&mut self, a: &String, b: &String) -> f64 {
368+
if !self.exist(a) || !self.exist(b) || self.find(a) != self.find(b) {
369+
-1.0
370+
} else {
371+
let wa = self.nodes[a].weight;
372+
let wb = self.nodes[b].weight;
373+
wa / wb
374+
}
375+
}
376+
}
377+
378+
impl Solution {
379+
pub fn calc_equation(
380+
equations: Vec<Vec<String>>,
381+
values: Vec<f64>,
382+
queries: Vec<Vec<String>>,
383+
) -> Vec<f64> {
384+
let mut dsu = DisjointSetUnion::new(&equations);
385+
for (i, &v) in values.iter().enumerate() {
386+
let (a, b) = (&equations[i][0], &equations[i][1]);
387+
dsu.union(a, b, v);
388+
}
389+
390+
let mut ans = vec![];
391+
for querie in queries {
392+
let (c, d) = (&querie[0], &querie[1]);
393+
ans.push(dsu.calc_value(c, d));
394+
}
395+
ans
396+
}
397+
}
398+
```
399+
308400
### **...**
309401

310402
```

‎solution/0300-0399/0399.Evaluate Division/README_EN.md

+92
Original file line numberDiff line numberDiff line change
@@ -230,6 +230,98 @@ func calcEquation(equations [][]string, values []float64, queries [][]string) []
230230
}
231231
```
232232

233+
### **Rust**
234+
235+
```rust
236+
use std::collections::HashMap;
237+
238+
#[derive(Debug)]
239+
pub struct DSUNode {
240+
parent: String,
241+
weight: f64,
242+
}
243+
244+
pub struct DisjointSetUnion {
245+
nodes: HashMap<String, DSUNode>,
246+
}
247+
248+
impl DisjointSetUnion {
249+
pub fn new(equations: &Vec<Vec<String>>) -> DisjointSetUnion {
250+
let mut nodes = HashMap::new();
251+
for equation in equations.iter() {
252+
for iter in equation.iter() {
253+
nodes.insert(
254+
iter.clone(),
255+
DSUNode {
256+
parent: iter.clone(),
257+
weight: 1.0,
258+
},
259+
);
260+
}
261+
}
262+
DisjointSetUnion { nodes }
263+
}
264+
265+
pub fn find(&mut self, v: &String) -> String {
266+
let origin = self.nodes[v].parent.clone();
267+
if origin == *v {
268+
return origin;
269+
}
270+
271+
let root = self.find(&origin);
272+
self.nodes.get_mut(v).unwrap().parent = root.clone();
273+
self.nodes.get_mut(v).unwrap().weight *= self.nodes[&origin].weight;
274+
root
275+
}
276+
277+
pub fn union(&mut self, a: &String, b: &String, v: f64) {
278+
let pa = self.find(a);
279+
let pb = self.find(b);
280+
if pa == pb {
281+
return;
282+
}
283+
let (wa, wb) = (self.nodes[a].weight, self.nodes[b].weight);
284+
self.nodes.get_mut(&pa).unwrap().parent = pb;
285+
self.nodes.get_mut(&pa).unwrap().weight = wb * v / wa;
286+
}
287+
288+
pub fn exist(&mut self, k: &String) -> bool {
289+
self.nodes.contains_key(k)
290+
}
291+
292+
pub fn calc_value(&mut self, a: &String, b: &String) -> f64 {
293+
if !self.exist(a) || !self.exist(b) || self.find(a) != self.find(b) {
294+
-1.0
295+
} else {
296+
let wa = self.nodes[a].weight;
297+
let wb = self.nodes[b].weight;
298+
wa / wb
299+
}
300+
}
301+
}
302+
303+
impl Solution {
304+
pub fn calc_equation(
305+
equations: Vec<Vec<String>>,
306+
values: Vec<f64>,
307+
queries: Vec<Vec<String>>,
308+
) -> Vec<f64> {
309+
let mut dsu = DisjointSetUnion::new(&equations);
310+
for (i, &v) in values.iter().enumerate() {
311+
let (a, b) = (&equations[i][0], &equations[i][1]);
312+
dsu.union(a, b, v);
313+
}
314+
315+
let mut ans = vec![];
316+
for querie in queries {
317+
let (c, d) = (&querie[0], &querie[1]);
318+
ans.push(dsu.calc_value(c, d));
319+
}
320+
ans
321+
}
322+
}
323+
```
324+
233325
### **...**
234326

235327
```

‎solution/0300-0399/0399.Evaluate Division/Solution.rs

+87
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,87 @@
1+
use std::collections::HashMap;
2+
3+
#[derive(Debug)]
4+
pub struct DSUNode {
5+
parent: String,
6+
weight: f64,
7+
}
8+
9+
pub struct DisjointSetUnion {
10+
nodes: HashMap<String, DSUNode>,
11+
}
12+
13+
impl DisjointSetUnion {
14+
pub fn new(equations: &Vec<Vec<String>>) -> DisjointSetUnion {
15+
let mut nodes = HashMap::new();
16+
for equation in equations.iter() {
17+
for iter in equation.iter() {
18+
nodes.insert(
19+
iter.clone(),
20+
DSUNode {
21+
parent: iter.clone(),
22+
weight: 1.0,
23+
},
24+
);
25+
}
26+
}
27+
DisjointSetUnion { nodes }
28+
}
29+
30+
pub fn find(&mut self, v: &String) -> String {
31+
let origin = self.nodes[v].parent.clone();
32+
if origin == *v {
33+
return origin;
34+
}
35+
36+
let root = self.find(&origin);
37+
self.nodes.get_mut(v).unwrap().parent = root.clone();
38+
self.nodes.get_mut(v).unwrap().weight *= self.nodes[&origin].weight;
39+
root
40+
}
41+
42+
pub fn union(&mut self, a: &String, b: &String, v: f64) {
43+
let pa = self.find(a);
44+
let pb = self.find(b);
45+
if pa == pb {
46+
return;
47+
}
48+
let (wa, wb) = (self.nodes[a].weight, self.nodes[b].weight);
49+
self.nodes.get_mut(&pa).unwrap().parent = pb;
50+
self.nodes.get_mut(&pa).unwrap().weight = wb * v / wa;
51+
}
52+
53+
pub fn exist(&mut self, k: &String) -> bool {
54+
self.nodes.contains_key(k)
55+
}
56+
57+
pub fn calc_value(&mut self, a: &String, b: &String) -> f64 {
58+
if !self.exist(a) || !self.exist(b) || self.find(a) != self.find(b) {
59+
-1.0
60+
} else {
61+
let wa = self.nodes[a].weight;
62+
let wb = self.nodes[b].weight;
63+
wa / wb
64+
}
65+
}
66+
}
67+
68+
impl Solution {
69+
pub fn calc_equation(
70+
equations: Vec<Vec<String>>,
71+
values: Vec<f64>,
72+
queries: Vec<Vec<String>>,
73+
) -> Vec<f64> {
74+
let mut dsu = DisjointSetUnion::new(&equations);
75+
for (i, &v) in values.iter().enumerate() {
76+
let (a, b) = (&equations[i][0], &equations[i][1]);
77+
dsu.union(a, b, v);
78+
}
79+
80+
let mut ans = vec![];
81+
for querie in queries {
82+
let (c, d) = (&querie[0], &querie[1]);
83+
ans.push(dsu.calc_value(c, d));
84+
}
85+
ans
86+
}
87+
}

0 commit comments

Comments
 (0)