For a undirected graph with tree characteristics, we can choose any node as the root. The result graph is then a rooted tree. Among all possible rooted trees, those with minimum height are called minimum height trees (MHTs). Given such a graph, write a function to find all the MHTs and return a list of their root labels.
Format
The graph contains n nodes which are labeled from 0 to n - 1. You will be given the number n and a list of undirected edges (each edge is a pair of labels).
You can assume that no duplicate edges will appear in edges. Since all edges are undirected, [0, 1] is the same as [1, 0] and thus will not appear together in edges.
Example 1:
Given n = 4, edges = [[1, 0], [1, 2], [1, 3]]
0
|
1
/ \
2 3
return [1]
Example 2:
Given n = 6, edges = [[0, 3], [1, 3], [2, 3], [4, 3], [5, 4]]
0 1 2
\ | /
3
|
4
|
5
return [3, 4]
Hint:
- How many MHTs can a graph have at most?
Note:
(1) According to the definition of tree on Wikipedia: “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.”
(2) The height of a rooted tree is the number of edges on the longest downward path between the root and a leaf.
public class Solution {
/** return the height of tree if let s to be the root of the tree */
public static int bfs(ArrayList<ArrayList<Integer> > g, int s) {
HashSet<Integer> upper = new HashSet<Integer> ();
HashSet<Integer> lower = new HashSet<Integer> ();
HashSet<Integer> vis = new HashSet<Integer> ();
upper.add(s);
vis.add(s);
int lv = 1;
while(!upper.isEmpty()) {
for(int u: upper) {
ArrayList<Integer> adj = g.get(u);
for(int i=0; i<adj.size(); ++i) {
int adj_node = adj.get(i);
if(!vis.contains(adj_node)) {
lower.add(adj_node);
}
}
}
if(!lower.isEmpty()) {
++lv;
}
upper.clear();
for(int c: lower) {
vis.add(c);
upper.add(c);
}
lower.clear();
}
return lv;
}
public static ArrayList<Integer> topologicalSort(int n, int[][] edges, ArrayList<ArrayList<Integer> > g) {
ArrayList<Integer> topo = new ArrayList<Integer> ();
int[] d = new int[n];
for(int i=0; i<edges.length; ++i) {
int u = edges[i][0], v = edges[i][1];
++d[u]; ++d[v];
}
LinkedList<Integer> queue = new LinkedList<Integer> ();
for(int i=0; i<n; ++i) {
if(d[i] == 1) {
queue.addLast(i);
}
}
while(!queue.isEmpty()) {
int top = queue.pollFirst();
topo.add(top);
ArrayList<Integer> adj = g.get(top);
for(int next: adj) {
d[next]--;
if(d[next] == 1) {
queue.addLast(next);
}
}
}
return topo;
}
public List<Integer> findMinHeightTrees(int n, int[][] edges) {
List<Integer> rs = new ArrayList<Integer> ();
if(n == 1) {
rs.add(0);
return rs;
}
ArrayList<ArrayList<Integer> > g = new ArrayList<ArrayList<Integer> > ();
for(int i=0; i<n; ++i) {
ArrayList<Integer> row = new ArrayList<Integer> ();
g.add(row);
}
for(int i=0; i<edges.length; ++i) {
int u = edges[i][0];
int v = edges[i][1];
g.get(u).add(v);
g.get(v).add(u);
}
HashMap<Integer, Integer> mapping = new HashMap<Integer, Integer> ();
ArrayList<Integer> topo = topologicalSort(n, edges, g);
int idx = topo.get(topo.size()-1);
int min_lv = bfs(g, idx);
rs.add(idx);
if(topo.size() >= 2) {
int indice = topo.get(topo.size()-2);
if(bfs(g, indice) == min_lv) {
rs.add(indice);
}
}
return rs;
}
}