共计 1575 个字符，预计需要花费 4 分钟才能阅读完成。

题目地址：https://leetcode-cn.com/probl… 题目描述：
对于一个具有树特征的无向图，我们可选择任何一个节点作为根。图因此可以成为树，在所有可能的树中，具有最小高度的树被称为最小高度树。给出这样的一个图，写出一个函数找到所有的最小高度树并返回他们的根节点。

格式

该图包含 n 个节点，标记为 0 到 n – 1。给定数字 n 和一个无向边 edges 列表（每一个边都是一对标签）。

你可以假设没有重复的边会出现在 edges 中。由于所有的边都是无向边，[0, 1]和 [1, 0] 是相同的，因此不会同时出现在 edges 里。

示例 1:

输入: n = 4, edges = [[1, 0], [1, 2], [1, 3]]

0
|
1
/ \
2 3

输出: [1]
示例 2:

输入: n = 6, edges = [[0, 3], [1, 3], [2, 3], [4, 3], [5, 4]]

0 1 2
\ | /
3
|
4
|
5

输出: [3, 4]

解答：这一题比较有技巧，如果求任意一点到任意一点的距离，那么会时间复杂度会很大。比较高效的做法是，每次把叶子节点从图 (把树转换为图结构) 删掉。直到只剩下 1 个或者 2 个点的时候输出。
算法思想很简单。但是实现起来有写麻烦。如果每次都判断叶子节点，那么效率会很低。因此使用一个数组 inDegree[]代表每个节点的入度，若入度为 1 就是叶子节点。并且用一个队列 (栈也可以，只要是那种能弹出的容器即可) 装叶子节点。然后宽度优先搜索队列中叶子节点，删除节点和它们对应的边，并加入新的叶子节点(有可能删除叶子节点的边之后，它的邻接点 p 的入度变为 1, 也就是 inDegree[p] = 1，此时可以把 p 加入队列中)。直到只剩下 1 个或者 2 个点停止。返回结果。
java ac 代码：
class Solution {
public List<Integer> findMinHeightTrees(int n, int[][] edges) {

List<Integer>ans = null;
if(n <= 2)
{
ans = new ArrayList(2);
for(int i = 0;i < n;i++)
ans.add(i);
return ans;
}

// 去掉叶子节点，直到只剩下一个或者两个节点。
int[]inDegree = new int[n];

// 用邻接表存储图。
List<Integer>[] map = new List[n];
for(int i = 0;i < n;i++)
map[i] = new ArrayList();
for(int i = 0;i < edges.length;i++)
{
map[edges[i][0]].add(edges[i][1]);
map[edges[i][1]].add(edges[i][0]);
inDegree[edges[i][0]]++;
inDegree[edges[i][1]]++;
}

int count = n;
Queue<Integer>queue = new ArrayDeque();
for(int i = 0;i < n;i++)
if(inDegree[i] == 1)
queue.offer(i);
while(count > 2)
{
int size = queue.size();
for(int loc = 0;loc < size;loc++)
{
int ii = queue.poll();
int jj = map[ii].get(0);

inDegree[jj]–;
if(inDegree[jj] == 1)
queue.offer(jj);

map[jj].remove(new Integer(ii));
map[ii].remove(new Integer(jj));
inDegree[ii] = -1;

count–;
}
}

ans = new ArrayList(queue);

return ans;
}

}

这个和力扣(LeetCode)207 很像，虽然不是拓扑排序，但都是利用一个可弹出容器装节点，然后宽度搜索容器中的节点。

共计 1327 个字符，预计需要花费 4 分钟才能阅读完成。

题目地址：https://leetcode-cn.com/probl… 题目描述：对于一个具有树特征的无向图，我们可选择任何一个节点作为根。图因此可以成为树，在所有可能的树中，具有最小高度的树被称为最小高度树。给出这样的一个图，写出一个函数找到所有的最小高度树并返回他们的根节点。
格式
该图包含 n 个节点，标记为 0 到 n – 1。给定数字 n 和一个无向边 edges 列表（每一个边都是一对标签）。
你可以假设没有重复的边会出现在 edges 中。由于所有的边都是无向边，[0, 1] 和 [1, 0] 是相同的，因此不会同时出现在 edges 里。
解答：这一题就是求最短路径，不过求的是每一个点到任意一点的最短路径。我们可以使用弗洛伊德算法来求解。可惜的是该算法的复杂度是 O(N 三次方)。不过还有别的方法来求最短路径，宽度优先搜索，对于权值相同的图，可以用宽度优先搜索来求解某一点到任意一点的最短路径。宽度优先是 O(N) 的复杂度。求解 N 个点的，于是就可以把复杂度变为 O(N 二次方)。注意：下面的代码是隐含使用宽度优先搜索，没有使用队列。java ac 代码：
class Solution {
public List<Integer> findMinHeightTrees(int n, int[][] edges) {

int[][] matrix = new int[n][n];
int max = Integer.MAX_VALUE;
for(int i = 0;i < n;i++)
for(int j = 0;j < n;j++)
matrix[i][j] = max;

for(int i = 0;i < edges.length;i++){
int begin = edges[i][0];
int end = edges[i][1];
matrix[begin][end] = 1;
matrix[end][begin] = 1;
for(int j = 0;j < n;j++)
if(matrix[begin][j] == max&&matrix[end][j] != max)
matrix[begin][j] = matrix[j][begin] = 1+matrix[end][j];
else if(matrix[end][j] == max&&matrix[begin][j] != max)
matrix[end][j] = matrix[j][end] = 1+matrix[begin][j];

}

for(int i = 0;i < n;i++)
matrix[i][i] = 0;

HashMap<Integer,Integer>map = new HashMap(1<<10);
int min = max;
for(int i = 0;i < n;i++){
int temp = -1;
for(int j = 0;j < n;j++)
temp = Math.max(temp,matrix[i][j]);
map.put(i,temp);
min = Math.min(temp,min);
}
List<Integer> ans = new ArrayList(n);
for(Map.Entry<Integer,Integer> entry:map.entrySet())
if(entry.getValue() == min)ans.add(entry.getKey());

return ans;
}

}