310 最小高度树

题目描述：
树是一个无向图，其中任何两个顶点只通过一条路径连接。 换句话说，一个任何没有简单环路的连通图都是一棵树。
给你一棵包含 n 个节点的数，标记为 0 到 n - 1 。给定数字 n 和一个有 n - 1 条无向边的 edges 列表（每一个边都是一对标签），其中 edges[i] = [ai, bi] 表示树中节点 ai 和 bi 之间存在一条无向边。
可选择树中任何一个节点作为根。当选择节点 x 作为根节点时，设结果树的高度为 h 。在所有可能的树中，具有最小高度的树（即，min(h)）被称为 最小高度树 。
请你找到所有的 最小高度树 并按 任意顺序 返回它们的根节点标签列表。
树的 高度 是指根节点和叶子节点之间最长向下路径上边的数量。

示例 1：

输入：n = 4, edges = [[1,0],[1,2],[1,3]]
输出：[1]
解释：如图所示，当根是标签为 1 的节点时，树的高度是 1 ，这是唯一的最小高度树。

示例 2：

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

示例 3：
输入：n = 1, edges = []
输出：[0]

示例 4：
输入：n = 2, edges = [[0,1]]
输出：[0,1]

提示：
1 <= n <= 2 * 104
edges.length == n - 1
0 <= ai, bi < n
ai != bi
所有 (ai, bi) 互不相同
给定的输入 保证 是一棵树，并且 不会有重复的边

方法1：
主要思路：
（1）超时算法；
（2）当时想着现建好图，然后找出结点之间的最长的路径，那么，最小的高度树的根节点，一定是在该路径的中间结点位置；
（3）既路径的长度若是奇数，则是中间结点，若是偶数，则是中间两个结点；
（4）虽然过了前面的例子，但算法最后超时；

class Solution {
public:
	//找出该节点下，最长的路径
    void dfs(vector<vector<int>>& graph,vector<bool>sign,vector<int>& cur_path,vector<int>&path,int index){
        if(sign[index]==false){
            if(cur_path.size()>path.size()){
                path=cur_path;
            }
            return;
        }
        sign[index]=false;
        cur_path.push_back(index);

        for(int i=0;i<graph[index].size();++i){
            dfs(graph,sign,cur_path,path,graph[index][i]);
        }

        cur_path.pop_back();
        sign[index]=true;
    }
    vector<int> findMinHeightTrees(int n, vector<vector<int>>& edges) {
    	//处理特殊的情形
        if(n==1){
            return {0};
        }
        if(n==2){
            return {0,1};
        }
        //建图
         vector<vector<int>> graph(n);
         vector<bool> lable(n,true);//标识访问过的结点
         for(vector<int>& edge:edges){
             graph[edge[0]].push_back(edge[1]);
             graph[edge[1]].push_back(edge[0]);
         }
         vector<int> path;//存储最长的路径
         for(int i=0;i<n;++i){
             if(graph[i].size()==1&&lable[i]){//若当前结点是路径的起始或终止点，且没有访问过，则
                 lable[i]=false;
                 vector<bool> sign(n,true);
                 vector<int> cur_path;
                 dfs(graph,sign,cur_path,path,i);
             }
         }
         if(path.size()%2==1){
             return {path[path.size()/2]};
         }
         return {path[path.size()/2-1],path[path.size()/2]};
    }
};

方法2：
主要思路：
（1）使用广度优先搜索，每次找出只有一个相邻结点的点，既度为1的结点，作为要删除的结点，同时与这些结点相连的点的度同时减1，当减一后的结点的度也变成了1，则作为新的要删除的结点，压入到队列中；

class Solution {
public:
    vector<int> findMinHeightTrees(int n, vector<vector<int>>& edges) {
    	//处理特殊的情形
        if(n==1){
            return {0};
        }
        if(n==2){
            return {0,1};
        }
        //建立图
         vector<vector<int>> graph(n);
         //统计各个结点的入度，这里是无向图，实际既相邻的结点的数量
         vector<int> in_degree(n,0);
         for(vector<int>& edge:edges){
             graph[edge[0]].push_back(edge[1]);
             graph[edge[1]].push_back(edge[0]);
             ++in_degree[edge[0]];
             ++in_degree[edge[1]];
         }
         queue<int> q;//队列实现广度优先搜索
         //将起始的度为1的结点压入到队列中
         for(int i=0;i<n;++i){
             if(in_degree[i]==1){
                 q.push(i);
                 in_degree[i]=0;//标识不再访问，变相的删除结点操作
             }
         }
		//当没有遍历的结点的数量小于等于2时，则终止循环，剩余的这1个或2个结点，即为中间结点
         while(n>2){
             int cur_size=q.size();//当前层要删除的结点数量
             n-=cur_size;//删除结点
             //逐个遍历要删除的结点，减少相邻的结点的度
             while(cur_size--){
                int cur_index=q.front();//当前结点
                q.pop();
                //遍历当前结点的相邻结点，再相邻结点没有被删除过的情形下，既度符合要求的情形下
                for(int& cur_i:graph[cur_index]){
                    if(in_degree[cur_i]>1){//度符合要求，则可以访问
                    	//该相邻结点的度减1
                         --in_degree[cur_i];
                         //若度等于1，则说明也是新的叶子结点，既可以删除的结点，压入到队列中，并将对应的度置为0进行标识
                         if(in_degree[cur_i]==1){
                            q.push(cur_i);
                            in_degree[cur_i]=0;
                        }
                    }
                }
             }
         }
         //获得结果
         vector<int> res;
         while(!q.empty()){
             res.push_back(q.front());
             q.pop();
         }
         return res;
    }
};