Added AdjacencyGraph and Minimum Height Trees

Author: ryanoneill

src/adjacency_graph.rs

@@ -0,0 +1,96 @@
+use std::collections::HashMap;
+use std::collections::HashSet;
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct AdjacencyGraph {
+    neighbors: HashMap<i32, HashSet<i32>>,
+}
+
+impl AdjacencyGraph {
+
+    pub fn new() -> Self {
+        Self { neighbors: HashMap::new() }
+    }
+
+    pub fn from_neighbors(neighbors: &HashMap<i32, HashSet<i32>>) -> Self {
+        Self { neighbors: neighbors.clone() }
+    }
+
+    pub fn from_vec(edges: &Vec<Vec<i32>>) -> Self {
+        let mut result = Self::new();
+        for edge in edges {
+            result.add_edge(edge[0], edge[1]);
+        }
+        result
+    }
+
+    pub fn add_edge(&mut self, x: i32, y: i32) {
+        self.neighbors
+            .entry(x)
+            .or_insert(HashSet::new())
+            .insert(y);
+        self.neighbors
+            .entry(y)
+            .or_insert(HashSet::new())
+            .insert(x);
+    }
+
+    pub fn remove_edge(&mut self, x: i32, y: i32) {
+        self.neighbors
+            .entry(x)
+            .and_modify(|s| { s.remove(&y); });
+        self.neighbors
+            .entry(y)
+            .and_modify(|s| { s.remove(&x); });
+    }
+
+    pub fn is_leaf(&self, x: i32) -> bool {
+        self.neighbors
+            .get(&x)
+            .map(|s| s.len() == 1)
+            .unwrap_or_default()
+    }
+
+    pub fn find_leaves(&self) -> Vec<i32> {
+        self.neighbors
+            .iter()
+            .filter(|(_, v)| v.len() == 1)
+            .map(|(k, _)| k)
+            .copied()
+            .collect()
+    }
+
+    pub fn find_leaf_neighbor(&self, x: i32) -> i32 {
+        self.neighbors
+            .get(&x)
+            .and_then(|s| s.iter().next())
+            .copied()
+            .unwrap_or(-1)
+    }
+
+    pub fn find_centroids(&self) -> Vec<i32> {
+        if self.neighbors.len() <= 2 {
+            self.neighbors.keys().copied().collect()
+        } else {
+            let mut cloned = self.clone();
+
+            let mut leaves = cloned.find_leaves();
+            let mut left = cloned.neighbors.len();
+            while left > 2 {
+                let mut next_leaves = Vec::new();
+                left -= leaves.len();
+                for &leaf in &leaves {
+                    let neighbor = cloned.find_leaf_neighbor(leaf);
+                    cloned.remove_edge(leaf, neighbor);
+                    if cloned.is_leaf(neighbor) {
+                        next_leaves.push(neighbor);
+                    }
+                }
+                leaves = next_leaves;
+            }
+
+            leaves
+        }
+    }
+
+}

src/lib.rs

@@ -12,6 +12,7 @@ pub mod stack;
 pub mod tree_node;
 pub mod tree_node_additions;
 pub mod vec_additions;
+pub mod adjacency_graph;
 
 pub mod two_sum; // 1
 pub mod add_two_numbers; // 2
@@ -116,6 +117,8 @@ pub mod serialize_and_deserialize_binary_tree; // 297
 
 pub mod longest_increasing_subsequence; // 300
 
+pub mod minimum_height_trees; // 310
+
 pub mod shortest_distance_from_all_buildings; // 317
 
 pub mod bulb_switcher; // 319

src/minimum_height_trees.rs

@@ -0,0 +1,55 @@
+use crate::adjacency_graph::AdjacencyGraph;
+use std::collections::HashMap;
+use std::collections::HashSet;
+use std::collections::VecDeque;
+
+/// A tree is an undirected graph in which any two vertices are connected by
+/// exactly one path. In other words, any connected graph without simple cycles
+/// is a tree.
+///
+/// Given a tree of `n` nodes labelled from `0` to `n - 1`, and an array of
+/// `n - 1` `edges` where `edges[i] = [ai, bi]` indicates that there is an
+/// undirected edge between the two nodes `ai` and `bi` in the tree, you can
+/// choose any node of the tree as the root. When you select a node `x` as the
+/// root, the result tree has height `h`. Among all possible rooted trees,
+/// those with minimum height (i.e. `min(h)`) are called minimum height trees
+/// (MHTs).
+///
+/// Return a list of all MHT's root labels. You can return the answer in any
+/// order.
+///
+/// The height of a rooted tree is the number of edges on the longest downward
+/// path between the root and a leaf.
+struct Solution;
+
+impl Solution {
+
+    pub fn find_min_height_tree(_n: i32, edges: Vec<Vec<i32>>) -> Vec<i32> {
+        let graph = AdjacencyGraph::from_vec(&edges);
+        graph.find_centroids()
+    }
+
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    fn example_1() {
+        let n = 4;
+        let edges = vec![vec![1,0], vec![1,2], vec![1,3]];
+        let result = Solution::find_min_height_tree(n, edges);
+        assert_eq!(result, vec![1]);
+    }
+
+    #[test]
+    fn example_2() {
+        let n = 6;
+        let edges = vec![vec![3,0], vec![3,1], vec![3,2], vec![3,4], vec![5,4]];
+        let mut result = Solution::find_min_height_tree(n, edges);
+        result.sort();
+        assert_eq!(result, vec![3,4]);
+    }
+
+}