LeetCode 310. Minimum Height Trees（最小高度树）

原题网址：https://leetcode.com/problems/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]

Hint:

1. 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 {
    private int maxNode, maxDepth;
    private void dfs(int from, int depth, List<Integer>[] graph, boolean[] visited, int[] dist, int[] prev) {
        if (depth > maxDepth) {
            maxDepth = depth;
            maxNode = from;
        }
        for(int next: graph[from]) {
            if (visited[next]) continue;
            visited[next] = true;
            prev[next] = from;
            dist[next] = depth+1;
            dfs(next, depth+1, graph, visited, dist, prev);
        }
    }
    private List<Integer> roots = new ArrayList<>();
    public List<Integer> findMinHeightTrees(int n, int[][] edges) {
        List<Integer>[] graph = new ArrayList[n];
        for(int i=0; i<n; i++) graph[i] = new ArrayList<>();
        for(int i=0; i<edges.length; i++) {
            graph[edges[i][0]].add(edges[i][1]);
            graph[edges[i][1]].add(edges[i][0]);
        }
        
        boolean[] visited = new boolean[n];
 
        int[] dist1 = new int[n];
        int[] prev1 = new int[n];
        maxNode = 0;
        maxDepth = 0;
        visited[0] = true;
        dfs(0, 0, graph, visited, dist1, prev1);
        int node1 = maxNode;

        int[] dist2 = new int[n];
        int[] prev2 = new int[n];
        Arrays.fill(visited, false);
        maxNode = node1;
        maxDepth = 0;
        visited[node1] = true;
        dfs(node1, 0, graph, visited, dist2, prev2);
        int node2 = maxNode;

        int node = node2;
        for(int i=0; i<maxDepth/2; i++) node = prev2[node];
        if ((maxDepth & 1) == 0) {
            roots.add(node);
        } else {
            roots.add(node);
            roots.add(prev2[node]);
        }
        return roots;
    }
}

优化，利用prev特性避免使用visit数组：

public class Solution {
    private void find(int curr, int dist, int[] prev, List<Integer>[] graph, Node max) {
        if (dist >= max.dist) {
            max.dist = dist;
            max.id = curr;
        }
        for(int i=0; i<graph[curr].size(); i++) {
            int next = graph[curr].get(i);
            if (next == prev[curr]) continue;
            prev[next] = curr;
            find(next, dist+1, prev, graph, max);
        }
    }
    public List<Integer> findMinHeightTrees(int n, int[][] edges) {
        List<Integer>[] graph = new List[n];
        for(int i=0; i<n; i++) graph[i] = new ArrayList<>();
        for(int[] edge: edges) {
            graph[edge[0]].add(edge[1]);
            graph[edge[1]].add(edge[0]);
        }
        int[] prev = new int[n];
        Arrays.fill(prev, -1);
        Node node1 = new Node();
        find(0, 0, prev, graph, node1);
        Arrays.fill(prev, -1);
        Node node2 = new Node();
        find(node1.id, 0, prev, graph, node2);
        List<Integer> roots = new ArrayList<>();
        int id = node2.id;
        for(int i=0; i<node2.dist/2; i++) id = prev[id];
        roots.add(id);
        if (node2.dist % 2 == 1) roots.add(prev[id]);
        return roots;
    }
}
class Node {
    int id = -1;
    int dist = Integer.MIN_VALUE;
}

方法二：动态规划。

public class Solution {
    private int[] length;
    private int[][] height;
    private List<Integer>[] graph;
    private void dfs(int parent, int current) {
        for(int next: graph[current]) {
            if (next == parent) continue;
            dfs(current, next);
            int h = height[next][0] + 1;
            if (h > height[current][0]) {
                height[current][1] = height[current][0];
                height[current][0] = h;
            } else if (h > height[current][1]) {
                height[current][1] = h;
            }
        }
    }
    private int min;
    private void dfs(int parent, int current, int longest) {
        length[current] = Math.max(longest, height[current][0]);
        if (length[current] < min) min = length[current];
        for(int next: graph[current]) {
            if (next == parent) continue;
            int nl = Math.max(longest+1, height[next][0]+1==height[current][0]? height[current][1]+1 : height[current][0]+1);
            dfs(current, next, nl);
        }
    }
    public List<Integer> findMinHeightTrees(int n, int[][] edges) {
        List<Integer> roots = new ArrayList<>();
        if (n==0) return roots;
        if (n<=2) {
            for(int i=0; i<n; i++) roots.add(i);
            return roots;
        }
        min = n;
        length = new int[n];
        height = new int[n][2];
        graph = new List[n];
        for(int i=0; i<n; i++) graph[i] = new ArrayList<>();
        for(int i=0; i<edges.length; i++) {
            graph[edges[i][0]].add(edges[i][1]);
            graph[edges[i][1]].add(edges[i][0]);
        }
        dfs(-1, 0);
        dfs(-1, 0, 0);
        for(int i=0; i<n; i++) {
            if (length[i] == min) roots.add(i);
        }
        return roots;
    }
}

优化，将参数定义为高度和半径，含义更清晰：

public class Solution {
    private int min = Integer.MAX_VALUE;
    private int[] radius;
    private int[][] height;
    private List<Integer>[] graph;
    private void calcHeight(int prev, int curr) {
        for(int i=0; i<graph[curr].size(); i++) {
            int next = graph[curr].get(i);
            if (next == prev) continue;
            calcHeight(curr, next);
            int h = height[next][0] + 1;
            if (h > height[curr][0]) {
                height[curr][1] = height[curr][0];
                height[curr][0] = h;
            } else if (h > height[curr][1]) {
                height[curr][1] = h;
            }
        }
    }
    private void calcRadius(int prev, int curr, int sum) {
        radius[curr] = Math.max(sum, height[curr][0]);
        if (radius[curr] < min) min = radius[curr];
        for(int i=0; i<graph[curr].size(); i++) {
            int next = graph[curr].get(i);
            if (next == prev) continue;
            int nextSum;
            if (height[next][0]+1 == height[curr][0]) nextSum = Math.max(sum, height[curr][1]) + 1;
            else nextSum = Math.max(sum, height[curr][0]) + 1;
            calcRadius(curr, next, nextSum);
        }
    }
    public List<Integer> findMinHeightTrees(int n, int[][] edges) {
        radius = new int[n];
        height = new int[n][2];
        graph = new List[n];
        for(int i=0; i<n; i++) graph[i] = new ArrayList<>();
        for(int[] edge: edges) {
            graph[edge[0]].add(edge[1]);
            graph[edge[1]].add(edge[0]);
        }
        calcHeight(-1, 0);
        calcRadius(-1, 0, 0);
        List<Integer> roots = new ArrayList<>();
        for(int i=0; i<n; i++) {
            if (radius[i] == min) roots.add(i);
        }
        return roots;
    }
}

啰嗦一点的方法：

public class Solution {
    private int[] radius;
    private int[][] height;
    private int[][] htnode;
    private List<Integer>[] graph;
    private void find(int prev, int node) {
        for(int next: graph[node]) {
            if (next == prev) continue;
            find(node, next);
            if (height[next][0] + 1 > height[node][0]) {
                height[node][0] = height[next][0] + 1;
                htnode[node][0] = next;
            }
        }
        for(int next: graph[node]) {
            if (next == prev) continue;
            if (next == htnode[node][0]) continue;
            if (height[next][0] + 1 > height[node][1]) {
                height[node][1] = height[next][0] + 1;
                htnode[node][1] = next;
            }
        }
    }
    
    private void find(int prev, int node, int sum) {
        radius[node] = Math.max(sum, height[node][0]);
        
        for(int next: graph[node]) {
            if (next == prev) continue;
            if (next == htnode[node][0]) {
                find(node, next, Math.max(sum+1, height[node][1]+1));
            } else {
                find(node, next, Math.max(sum+1, height[node][0]+1));
            }
        }
    }

    public List<Integer> findMinHeightTrees(int n, int[][] edges) {
        radius = new int[n];
        height = new int[n][2];
        htnode = new int[n][2];
        graph = new List[n];
        for(int i=0; i<n; i++) graph[i] = new ArrayList<>();
        for(int[] edge: edges) {
            graph[edge[0]].add(edge[1]);
            graph[edge[1]].add(edge[0]);
        }
        
        find(-1, 0);
        find(-1, 0, 0);
        
        int min = Integer.MAX_VALUE;
        for(int r: radius) min = Math.min(min, r);
        List<Integer> roots = new ArrayList<>();
        for(int i=0; i<radius.length; i++) {
            if (radius[i] == min) roots.add(i);
        }
        return roots;
    }
}

参考文章：https://leetcode.com/discuss/72739/two-o-n-solutions