small-lambda
Senior Member
C-like:
use std::collections::*;
#[derive(Debug)]
pub struct UnionFind {
parents: Vec<usize>,
ranks: Vec<usize>,
set_count: usize,
set_sizes: Vec<usize>
}
impl UnionFind {
pub fn new(size: usize) -> Self {
let mut parents = vec![0; size];
for i in 0..size {
parents[i] = i;
}
let ranks = vec![0; size];
let set_sizes = vec![1; size];
Self {
parents: parents,
ranks: ranks,
set_count: size,
set_sizes: set_sizes
}
}
pub fn find_set(&mut self, i: usize) -> usize {
if self.parents[i] == i {
i
} else {
self.parents[i] = self.find_set(self.parents[i]);
self.parents[i]
}
}
pub fn same_set(&mut self, i: usize, j: usize) -> bool {
self.find_set(i) == self.find_set(j)
}
pub fn union(&mut self, i: usize, j: usize) {
if self.same_set(i, j) {
return;
}
let mut set_i = self.find_set(i);
let mut set_j = self.find_set(j);
if self.ranks[set_i] > self.ranks[set_j] {
(set_i, set_j) = (set_j, set_i);
}
if self.ranks[set_i] == self.ranks[set_j] {
self.ranks[set_j] += 1;
}
self.set_sizes[set_j] += self.set_sizes[set_i];
self.parents[set_i] = set_j;
self.set_count -= 1;
}
pub fn set_count(&self) -> usize {
self.set_count
}
pub fn set_size(&mut self, i: usize) -> usize {
let set_i = self.find_set(i);
self.set_sizes[set_i]
}
}
impl Solution {
pub fn max_num_edges_to_remove(n: i32, edges: Vec<Vec<i32>>) -> i32 {
let un = n as usize;
let mut auf = UnionFind::new(un);
let mut buf = UnionFind::new(un);
let total_edge_count = edges.len();
let mut used_edge_count = 0;
for edge in edges.iter().filter(|&edge| edge[0] == 3) {
let u = edge[1] as usize - 1;
let v = edge[2] as usize - 1;
if !auf.same_set(u, v) && !buf.same_set(u, v) {
auf.union(u, v);
buf.union(u, v);
used_edge_count += 1;
}
}
for edge in edges.iter().filter(|&edge| edge[0] == 1) {
let u = edge[1] as usize - 1;
let v = edge[2] as usize - 1;
if !auf.same_set(u, v) {
auf.union(u, v);
used_edge_count += 1;
}
}
for edge in edges.iter().filter(|&edge| edge[0] == 2) {
let u = edge[1] as usize - 1;
let v = edge[2] as usize - 1;
if !buf.same_set(u, v) {
buf.union(u, v);
used_edge_count += 1;
}
}
if auf.set_count != 1 || buf.set_count != 1 {
-1
} else {
(total_edge_count - used_edge_count) as i32
}
}
}
C-like:
impl Solution {
pub fn odd_even_list(mut head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
let mut odd_head = Some(Box::new(ListNode::new(1)));
let mut odd_tail = odd_head.as_mut();
let mut even_head = Some(Box::new(ListNode::new(0)));
let mut even_tail = even_head.as_mut();
let mut i = 0;
while let Some(mut node) = head {
head = node.next.take();
if i % 2 == 0 {
even_tail =
even_tail.and_then(|mut tail| {
tail.next = Some(node);
tail.next.as_mut()
});
} else {
odd_tail =
odd_tail.and_then(|mut tail| {
tail.next = Some(node);
tail.next.as_mut()
});
}
i += 1;
}
even_tail.zip(odd_head).map(|(tail, head)| tail.next = head.next);
even_head.and_then(|mut head| head.next.take())
}
}
hứa 1 ngày nào đó trong tương lại sẽ quay lại trả món nợ này 
"
