310. 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]

Show Hint 

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.

思路：又遇上了最痛苦的topological sort，赶紧补一下，http://blog.csdn.net/dm_vincent/article/details/7714519

其实还是比较简单的，就想着　“学某门课要先修某门课”　这个实际的例子，把indegree为0的先拿出来，也就是不需要任何先修课的课程可以先学，然后更新其他节点的indegree，因为已经修了一门了嘛，说不定可以修其他以此为基础的课程呢！

拓扑排序有2中实现方式：

（1）ＢＦＳ（就是上面描述的）

（2）DFS （就是Coursera上algorithm课程老师描述的）

类似的题目：

https://leetcode.com/problems/course-schedule/?tab=Description

https://leetcode.com/problems/course-schedule-ii/?tab=Description（只记录degree计数即可）

这里当做无向图来对待：

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;

/*
 * 找到最长的那条path，中间的1个或者2个就是要找的
 * 参考拓扑排序的BFS实现
 * 如果有1条最长的path，那不断减掉degree为1的，最后剩下的就是
 * 如果有2条最长的path，那他们必然相交于中点，如果不是，就必然可以找到更长的path，相交于中点的话，不断减掉degree为1的仍然是可行的
 */
public class Solution {
    public List<Integer> findMinHeightTrees(int n, int[][] edges) {
    	
    	if(n == 1)	return Collections.singletonList(0);
    	
    	// 构建degree集合，因为要最后的结果，所以不能简单用一个数组对degree计数
    	List<HashSet<Integer>> degree = new ArrayList<HashSet<Integer>>();
    	for(int i=0; i<n; i++)	degree.add(new HashSet<Integer>());
    	
    	for(int[] edge : edges) {
    		degree.get(edge[0]).add(edge[1]);
    		degree.get(edge[1]).add(edge[0]);
    	}
    	
    	
    	// 不断删除degree为0的节点，再更新剩下的节点的degree，所以用一个数组保存当前degree为0的节点
    	List<Integer> leaves = new ArrayList<Integer>();
    	for(int i=0; i<n; i++) 
    		if(degree.get(i).size() == 1)
    			leaves.add(i);
    	
    	// 一直往中点收缩，剩下个1就是1个，剩下2个就是2个
    	while(n > 2) {
    		
    		n = n - leaves.size();
    		List<Integer> newLeaves = new ArrayList<Integer>();
    		
    		// 更新degree
    		for(int leaf : leaves) {
    			for(int j : degree.get(leaf)) {
    				degree.get(j).remove(leaf);
    				
    				// 不可能出现degree为0,
    				if(degree.get(j).size() == 1)
    					newLeaves.add(j);
    			}
    		}
    		
    		leaves = newLeaves;
    	}
    	
    	return leaves;
    }
}

二刷：

看了一下第一次刷写的博客，感觉完全不一样，还是要多刷，不然都找不到题目的感觉

这次刷因为有一刷的概念，直接想到了从两边收索找中点的思路，写了以下：

package l310;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/*
 * last case TLE
 */
public class ArrayBFS {
    public List<Integer> findMinHeightTrees(int n, int[][] edges) {
    	int[] degree = new int[n];
    	boolean[][] adj = new boolean[n][n];
    	for(int[] edge : edges) {
    		degree[edge[0]] ++;
    		degree[edge[1]] ++;
    		adj[edge[0]][edge[1]] = true;
    		adj[edge[1]][edge[0]] = true;
    	}
    	
    	int cnt = 0;
    	while(cnt < n-2) {
    		Set<Integer> s = new HashSet<Integer>();
    		for(int i=0; i<n; i++)
        		if(degree[i] == 1) {
        			degree[i] = -1;
        			s.add(i);
        		}
    		
    		for(int i : s)
    			for(int j=0; j<n; j++)	
    				if(adj[i][j])	degree[j] --;
    		
    		cnt += s.size();
    	}
    	
    	List<Integer> ret = new ArrayList<Integer>();
    	for(int i=0; i<n; i++)
    		if(degree[i] >= 0)	ret.add(i);
    	return ret;
    }
}

猜想可能是因为是稀疏矩阵，用连接表可能会快一点

package l310;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/*
 * last case TLE
 * so we use Map or List, notice we will always have 0 .. n-1, so we just use List
 * 还可以优化，求degree为1的节点的时候不需要遍历，只要每当有degree为1就加到一个Set里面(这好像也是拓扑排序的优化技巧)
 */
public class Solution {
    public List<Integer> findMinHeightTrees(int n, int[][] edges) {
    	int[] degree = new int[n];
    	List<List<Integer>> adj = new ArrayList<List<Integer>>();
    	for(int i=0; i<n; i++)	adj.add(new ArrayList<Integer>());
    	for(int[] edge : edges) {
    		degree[edge[0]] ++;
    		degree[edge[1]] ++;
    		adj.get(edge[0]).add(edge[1]);
    		adj.get(edge[1]).add(edge[0]);
    	}
    	
    	int cnt = 0;
    	while(cnt < n-2) {
    		Set<Integer> s = new HashSet<Integer>();
    		for(int i=0; i<n; i++)
        		if(degree[i] == 1) {
        			degree[i] = -1;
        			s.add(i);
        		}
    		
    		for(int i : s)
    			for(int j : adj.get(i))	
    				degree[j] --;
    		
    		cnt += s.size();
    	}
    	
    	List<Integer> ret = new ArrayList<Integer>();
    	for(int i=0; i<n; i++)
    		if(degree[i] >= 0)	ret.add(i);
    	return ret;
    }
}

看到有人说暴力也可以AC，就试了一下遍历每个节点当root求树高，再取最小值

package l310;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/*
 * TLE
 */
public class BruteForce {
    public List<Integer> findMinHeightTrees(int n, int[][] edges) {
        Map<Integer, List<Integer>> m = new HashMap<Integer, List<Integer>>();
        for(int[] edge : edges) {
        	if(!m.containsKey(edge[0]))	m.put(edge[0], new ArrayList<Integer>());
        	m.get(edge[0]).add(edge[1]);
        	if(!m.containsKey(edge[1]))	m.put(edge[1], new ArrayList<Integer>());
        	m.get(edge[1]).add(edge[0]);
        }
        
        int min = Integer.MAX_VALUE;
        List<Integer> ret = new ArrayList<Integer>();
        ret.add(0);
        
        for(int root : m.keySet()) {
        	boolean[] marked = new boolean[n];
        	marked[root] = true;
        	int h = getHeight(m, root, marked);
        	if(h < min)	{
        		min = h;
        		ret.clear();
        		ret.add(root);
        	} else if(h == min) {
        		ret.add(root);
        	}
        }
        
        return ret;
    }

	private int getHeight(Map<Integer, List<Integer>> m, int root, boolean[] marked) {
		int ret = 0;
		for(int next : m.get(root))
			if(!marked[next]) {
				marked[next] = true;
				ret = Math.max(ret, 1 + getHeight(m, next, marked));
				marked[next] = false;
			}
		return ret;
	}
}

也试了一下Floyd算法

package l310;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/*
 * Floyd
 * 某一行最大也不超过最大的一半就是可能的root
 */
public class Floyd {
    public List<Integer> findMinHeightTrees(int n, int[][] edges) {
    	
    	// Floyd
    	int[][] adj = new int[n][n];
    	for(int[] a : adj)	Arrays.fill(a, Integer.MAX_VALUE);
        for(int[] edge : edges) {
        	adj[edge[0]][edge[1]] = 1;
        	adj[edge[1]][edge[0]] = 1;
        }
        for(int k=0; k<n; k++)
        	for(int i=0; i<n; i++)
        		for(int j=0; j<n; j++)
        			if(adj[i][k]!=Integer.MAX_VALUE && adj[k][j]!=Integer.MAX_VALUE 
        					&& i!=j && adj[i][k] + adj[k][j] < adj[i][j]) 
        				adj[i][j] = adj[i][k] + adj[k][j];
        
        // 
        int[] max = new int[n];
        for(int i=0; i<n; i++)	
        	for(int j=0; j<n; j++)
        		if(adj[i][j] != Integer.MAX_VALUE)
        			max[i] = Math.max(max[i], adj[i][j]);
        int allMax = 0;
        for(int a : max)	
        	if(a != Integer.MAX_VALUE)	allMax = Math.max(allMax, a);
        int validMax = (allMax+1)/2;
        
        List<Integer> ret = new ArrayList<Integer>();
        for(int i=0; i<n; i++)
        	if(max[i] <= validMax)	ret.add(i);
        return ret;
	}
}

但是这些暴力解答都没有AC