A1021 Deepest Root （25 分）（选出使整棵树高度最大的树根节点）（图的DFS）

A graph which is connected and acyclic can be considered a tree. The height of the tree depends on the selected root. Now you are supposed to find the root that results in a highest tree. Such a root is called the deepest root.

Input Specification:

Each input file contains one test case. For each case, the first line contains a positive integer N (≤10​4​​) which is the number of nodes, and hence the nodes are numbered from 1 to N. Then N−1 lines follow, each describes an edge by given the two adjacent nodes' numbers.

Output Specification:

For each test case, print each of the deepest roots in a line. If such a root is not unique, print them in increasing order of their numbers. In case that the given graph is not a tree, print Error: K components where K is the number of connected components in the graph.

Sample Input 1:

5
1 2
1 3
1 4
2 5

Sample Output 1:

3
4
5

Sample Input 2:

5
1 3
1 4
2 5
3 4

Sample Output 2:

Error: 2 components

题意：

给出N个结点，N-1条边，问：能否形成一颗N个结点的树？如果能，则从中选出节点作为树根，使得整棵树的高度最大。输出所有满足要求的可以作为树根的结点

思路：

1. 连通？采用DFS次数
2. 难点：选择合适的根结点，使得高度最大？先任意选一个节点，开始遍历树，获取达到最大深度的节点（记为节点集合A），然后从集合A中任取一个节点，遍历整棵树，获取能够达到最深的顶点（记为集合B），这样A与B的并集即为所求使树高最高的根结点

#include <cstdio>
#include <vector>
#include <set>
#include <cstring>
using namespace std;
const int N = 10010;
vector<int> G[N];
bool vis[N];
int maxh = 1;       //递归时记录最大高度
vector<int> temp;   //存储最大路径的终点
set<int> s;         //存储结果，去重
void dfs(int v, int h){
    if(h > maxh){       //更新最大高度和temp
        temp.clear();
        temp.push_back(v);
        maxh = h;
    }
    else if(h == maxh){
        temp.push_back(v);
    }
    vis[v] = true;
    for(int i = 0; i < G[v].size(); i++){
        if(vis[G[v][i]] == false){
            dfs(G[v][i], h + 1);
        }
    }
}
int main(){
    int n;
    scanf("%d", &n);
    int a, b;
    for(int i = 1; i < n; i++){
        scanf("%d%d", &a, &b);
        G[a].push_back(b);
        G[b].push_back(a);
    }
    int count = 0;      //记录连通块数
    int u;              //记录第二次DFS的root值
    for(int i = 1; i <= n; i++){
        if(vis[i] == false){
            dfs(i, 1);      //第一次dfs
            if(i == 1){     //取出第一次从1号开始的dfs的值
                u = temp[0];        //记录第二次DFS的root值
                for(int j = 0; j < temp.size(); j++){
                    s.insert(temp[j]);    //将第一次取得的节点加入最终集合中
                }
            }
            count++;
        }
    }
    if(count >= 2){
        printf("Error: %d components", count);
    }
    else{
        temp.clear();
        memset(vis, false, sizeof(vis));
        dfs(u, 1);        //开始第二次DFS，寻找剩余节点
        for(int i = 0; i < temp.size(); i++){
            s.insert(temp[i]);
        }
        for(set<int>::iterator it = s.begin(); it != s.end(); it++){
            printf("%d\n", *it);
        }
    }
    return 0;
}