LeetCode-Minimum Height Trees

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]

Note:

Solution 1:

A naive solution: we choose a node as root, change the graph into a tree; we count the height of every tree node; we then calculate the minimum height taking the height of the parent tree into consideration.

public class Solution {
    public class MhtNode {
        Map<Integer, Integer> childMap;
        int firstDep;
        int secondDep;
        int treeDep;

        public MhtNode() {
            childMap = new HashMap<Integer, Integer>();
            firstDep = 0;
            secondDep = 0;
            treeDep = 0;
        }
    }

    public class Result {
        int minDep;
        List<Integer> nodeList;

        public Result() {
            minDep = Integer.MAX_VALUE;
            nodeList = new ArrayList<Integer>();
        }
    }

    public List<Integer> findMinHeightTrees(int n, int[][] edges) {
        Result res = new Result();
        if (n == 0)
            return res.nodeList;
        if (n == 1) {
            res.nodeList.add(0);
            return res.nodeList;
        }

        // Build graph.
        HashMap<Integer, MhtNode> treeMap = new HashMap<Integer, MhtNode>();
        for (int i = 0; i < edges.length; i++) {
            MhtNode node1 = treeMap.getOrDefault(edges[i][0], new MhtNode());
            node1.childMap.put(edges[i][1], -1);
            treeMap.put(edges[i][0], node1);

            MhtNode node2 = treeMap.getOrDefault(edges[i][1], new MhtNode());
            node2.childMap.put(edges[i][0], -1);
            treeMap.put(edges[i][1], node2);
        }

        int root = treeMap.keySet().iterator().next();
        buildTreeRecur(root, -1, treeMap);

        // Get MHT.
        getMHTRecur(root, 0, treeMap, res);

        return res.nodeList;
    }

    public int buildTreeRecur(int cur, int parent, HashMap<Integer, MhtNode> treeMap) {
        // Get current node, remove parent from child map.
        MhtNode curNode = treeMap.get(cur);
        curNode.childMap.remove(parent);

        // Get height of every child tree.
        for (int child : curNode.childMap.keySet()) {
            int height = buildTreeRecur(child, cur, treeMap);
            curNode.childMap.put(child, height);
            if (height > curNode.firstDep) {
                curNode.secondDep = curNode.firstDep;
                curNode.firstDep = height;
            } else if (height > curNode.secondDep) {
                curNode.secondDep = height;
            }
        }

        return curNode.firstDep + 1;
    }

    public void getMHTRecur(int cur, int parentHeight, HashMap<Integer, MhtNode> treeMap, Result res) {
        // Get current node's tree height.
        MhtNode curNode = treeMap.get(cur);
        curNode.treeDep = Math.max(parentHeight, curNode.firstDep);
        if (res.minDep == curNode.treeDep) {
            res.nodeList.add(cur);
        } else if (curNode.treeDep < res.minDep) {
            res.minDep = curNode.treeDep;
            res.nodeList.clear();
            res.nodeList.add(cur);
        }

        // Move to each of cur's child.
        for (int child : curNode.childMap.keySet()) {
            int childDep = curNode.childMap.get(child);
            if (childDep == curNode.firstDep) {
                getMHTRecur(child, Math.max(parentHeight, curNode.secondDep) + 1, treeMap, res);
            } else {
                getMHTRecur(child, curNode.treeDep + 1, treeMap, res);
            }
        }
    }
}

Solution 2:

The results actually is the 1 or 2 nodes on the center of the longest path. We remove leaves nodes (nodes with 1 neighbor) layer by layer, and the left nodes are answer.

public class Solution {
    public List<Integer> findMinHeightTrees(int n, int[][] edges) {
        List<Integer> cur = new ArrayList<Integer>();
        if (n==0) return cur;
        if (n==1){
            cur.add(0);
            return cur;
        }
        
        // build graph
        List<Set<Integer>> graph = new ArrayList<Set<Integer>>();
        for (int i=0;i<n;i++) graph.add(new HashSet<Integer>());
        for (int[] edge : edges){
            graph.get(edge[0]).add(edge[1]);
            graph.get(edge[1]).add(edge[0]);
        }
        
        // get all leaves to start with.
        for (int i=0;i<n;i++)
            if (graph.get(i).size()==1){
                cur.add(i);
            }
            
        // Remove every layer of leaves.
        while (true){
            List<Integer> next = new ArrayList<Integer>();
            for (int node : cur)
                for (int neighbor : graph.get(node)){
                    graph.get(neighbor).remove(node);
                    if (graph.get(neighbor).size()==1){
                        next.add(neighbor);
                    }
                }
            
            if (next.isEmpty()) return cur;
            cur = next;
        }
    }
}