310. Minimum Height Trees-Difficulty: Medium

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]

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.

解体思路：
类似剥洋葱的方法，就是一层一层的褪去叶节点，最后剩下的一个或两个节点就是我们要求的最小高度树的根节点。
下面代码中，有个特殊的地方是，linkNodes[node]并没有随着节点删除实时更新——因为维护起来比较麻烦。同时，将队列waitToBeProcessed中的节点linkNum[node] 减1后，本来应该将node最后剩下的那条边所连接的点node2的linkNum减1，但是去找这个点也很麻烦，索性直接node所连的所有点的linkNum全部减1（可能有的点早先剥洋葱时已经剥掉了）

class Solution {
public:
    vector<int> findMinHeightTrees(int n, vector<pair<int, int>>& edges) {
        int nodeNumLeft = n;
        vector<vector<int> > linkNodes(n, vector<int>());
        vector<int> linkNum(n, 0);
        pair<int, int> p;
        for(int i = 0; i < edges.size(); i ++){
            p = edges[i];
            linkNodes[p.first].push_back(p.second);
            linkNodes[p.second].push_back(p.first);
            linkNum[p.first] ++;
            linkNum[p.second] ++;
        }

        queue<int> waitToBeProcessed;
        map<int, bool> processed;
        while(nodeNumLeft > 2){
            for(int i = 0; i < linkNum.size(); i ++){
                if(linkNum[i] == 1){
                    waitToBeProcessed.push(i);
                    processed[i] = true;
                    nodeNumLeft --;
                }
            }

            while(waitToBeProcessed.empty() == false){
                int node = waitToBeProcessed.front();
                waitToBeProcessed.pop();
                linkNum[node] --;
                for(int i = 0; i < linkNodes[node].size(); i ++){   //no matter whether the node has been deleted or not
                    linkNum[linkNodes[node][i]] --;
                }
            }
        }

        vector<int> result;
        for(int i = 0; i < n; i ++){
            if(processed.count(i) == 0)
                result.push_back(i);
        }
        return result;
    }
};