Leetcode 310. Minimum Height Trees

310. Minimum Height Trees

For an 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 :

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

    0
    |
    1
   / \
  2   3 

Output: [1]
Example 2 :

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

 0  1  2
  \ | /
    3
    |
    4
    |
    5 

Output: [3, 4]
Note:

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.”
The height of a rooted tree is the number of edges on the longest downward path between the root and a leaf.

名词解释：树的高度，就是节点到叶子节点的最长路径的值。

本题题意： 找到树的高度最小的节点，并返回，其实就是找树的中心。

解析：我们可以用拓扑排序做，每次把叶子节点放到队列里，然后置为访问，然后将和叶子节点相邻的节点的入度减减。然后把新的叶子节点放入队列，这样循环往复，最后访问完所有的节点就结束，最后在队列里的点就是最后树的中心。

代码：

class Solution
{
public:
    vector<int> findMinHeightTrees(int n, vector<pair<int, int>>& edges)
    {
    	vector<int> ans;
    	queue<int> Q;
    	vector<int> indegree(n, 0);
    	vector<vector<int> > graphEdge;
    	graphEdge.resize(n);
    	int size = edges.size();
    	if(size == 0)
        {
            if(size==0) ans.push_back(0);
            return ans;
        }
    	for(int i = 0; i < size ; i++)
    	{
    		pair<int, int> tmp = edges[i];
    		int u = tmp.first;
    		int v = tmp.second;
    		++indegree[u];
    		++indegree[v];
    		graphEdge[u].push_back(v);
    		graphEdge[v].push_back(u);
    	}
    	vector<bool> vis(n,false);
    	int cnt = 0;
    	for(int i = 0; i < n; i++)
    	{
    		if(indegree[i] == 1 || indegree[i] == 0)
            {
                vis[i] = true;
                ++cnt;
                Q.push(i);
            }
    	}
    	//cout << Q.size() << endl;
    	bool first = true;
    	while(cnt != n)
    	{
    		first = false;
    		int size = Q.size();
    		for(int i = 0; i < size; i++)
    		{
    			int u = Q.front();
    			Q.pop();
    			for(int j = 0; j < graphEdge[u].size(); j++)
    			{
    				int v = graphEdge[u][j];
    				--indegree[v];
    				if((indegree[v] == 1 || indegree[v] == 0) && !vis[v])
                    {
                        ++cnt;
                        vis[v] = true;
                        Q.push(v);
                    }
    			}
    		}
    	}
        while(!Q.empty())
        {
        	int u = Q.front();
        	ans.push_back(u);
        	Q.pop();
        }
        return ans;
    }
};