【Leetcode】310. Minimum Height Trees

题目地址：

https://leetcode.com/problems/minimum-height-trees/

给定一个$n$阶简单无向图，其有树性质。若取其中某个顶点为根，其就成为一棵有根树，从而有树高。求使得树高最小的顶点编号。答案也许不唯一。

思路是BFS。如果图平凡（意思是图只有一个顶点）则直接返回$0$。如果图的顶点数大于$1$，直观的想法是，可以先将度为$1$的点入队，然后向树的“内部”分层遍历，然后将这些点删掉，再将剩余的点中度为$1$的点入队遍历，直到整个图被遍历完，这样最后一层遍历到的顶点即为所求（整个过程有点像拓扑排序，只不过这里的图是无向图，所以要不停地将度为$1$的点入队）。

算法正确性证明：
数学归纳法。对图的顶点数目进行归纳。如果图的顶点数为$2$，那么两个顶点的度都是$1$，那么这两个顶点既是最外层的顶点，也是最后一层被遍历的顶点，而算法返回的正是这两个顶点，所以算法正确（如果图顶点数为$1$的话类似）。
对于图的顶点数$V>2$的情况，我们知道图的所有顶点的度的总和等于$2E=2(V-1)=2V-2$，首先，度为$1$的顶点一定是存在的，否则度数和就会大于等于$2V$，矛盾；其次，由于$2V-2>V$，所以图中存在度不是$1$的顶点，也就是说，删掉度为$1$的顶点之后图仍然非空（也就是仍然有顶点）；以上结论是为做数学归纳法做准备。
接着我们只需要证明“最外层”的顶点不可能成为最矮树的树根就行。任取其中一个顶点$v$，设离$v$最远的顶点是$u$，那么树的高就是两者的距离，设为$h$。设$v$的邻接点是$w$（按照度的定义，$w$是$v$的唯一的邻接点），若以$w$为树根，则高度为$h-1$，更小。所以$v$不可能是最矮树的树根。把“最外层”的顶点删除后，图的顶点数减少，但仍然不空（上面的结论），由数学归纳法知道，算法对其正确。综上，算法正确。

由这个算法也能知道，最终的答案数目最多是$2$。不然的话，由上面的证明，仍然存在度为$1$的最外层的顶点还没删掉，这就矛盾了。所以最终的答案数目不大于$2$。

代码如下：

import java.util.*;

public class Solution {
    public List<Integer> findMinHeightTrees(int n, int[][] edges) {
        List<Integer> res = new ArrayList<>();
        
        // 特判是平凡图的情形
        if (n == 1) {
            res.add(0);
            return res;
        }
        
        // 邻接表建图，并算出每个顶点的度
        Map<Integer, List<Integer>> graph = buildGraph(edges);
        int[] degrees = getDegrees(n, edges);
        
        // 将度为1的点全部入队
        Queue<Integer> queue = new LinkedList<>();
        for (int i = 0; i < degrees.length; i++) {
            if (degrees[i] == 1) {
                queue.offer(i);
            }
        }
        
        while (!queue.isEmpty()) {
        	// 先把这一层的顶点全加入答案中
            res.clear();
            res.addAll(queue);
            
            // 开始分层遍历，由于要分层，所以要记录一下队列的大小
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                int cur = queue.poll();

                // 得到cur的邻接点
                for (int next : graph.get(cur)) {   		
              		// 将next的度减少1，然后将度为1的顶点入队      
                    degrees[next]--;
                    if (degrees[next] == 1) {
                        queue.offer(next);
                    }
                }
            }
        }
        
        // 队列为空的时候，最后访问的那一层顶点即为所求
        return res;
    }
    
    private int[] getDegrees(int n, int[][] edges) {
        int[] degrees = new int[n];
        for (int[] edge : edges) {
            int x = edge[0], y = edge[1];
            degrees[x]++;
            degrees[y]++;
        }
        
        return degrees;
    }
    
    private Map<Integer, List<Integer>> buildGraph(int[][] edges) {
        Map<Integer, List<Integer>> graph = new HashMap<>();
        for (int[] edge : edges) {
            int x = edge[0], y = edge[1];
            graph.computeIfAbsent(x, k -> new ArrayList<>()).add(y);
            graph.computeIfAbsent(y, k -> new ArrayList<>()).add(x);
        }
        
        return graph;
    }
}

时空复杂度$O(n)$。

注解：
1、这里的BFS是不用开visited数组记录是否访问过的，因为当前层遍历完了之后，下一层顶点的度都会减去$1$，只有下一层度减成$1$的顶点才会入队（这句话其实并不严谨。但是即使不严谨，也不影响算法的正确性。如果最终答案的顶点是唯一的，那么那个顶点即使在外层顶点全删掉之后度其实是$0$，但其仍然会安全入队。所以不会漏解），本层别的顶点度本来就是$1$，不可能重复入队的。
2、但是分层遍历存size仍然是必要的，因为res每次要将本层的顶点加进去。不分层则会得到错误答案。