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

#include<bits/stdc++.h>
using namespace std;

const int maxn = 1e4+10;
int n;
int depth[maxn];
vector<int> s[maxn];
bool vis[maxn];
int maxd = -1;
void DFS(int v, int d){
    vis[v] = true;
    //更新v的高度和最大高度
    depth[v] = max(d,depth[v]);
    maxd = max(d,maxd);

    for(int i=0;i<s[v].size();i++){
        int next = s[v][i];
        if(vis[next]==false){
          DFS(s[v][i],d+1);
        }

    }
}

int main()
{
    fill(vis,vis+maxn,false);
    cin>>n;
    int a,b;
    for(int i=1; i<n; i++)
    {
        cin>>a>>b;
        s[a].push_back(b);
        s[b].push_back(a);
    }
    int cnt = 0;
    for(int i=1; i<=n; i++)
    {

        if(vis[i]==false)
        {
            DFS(i,1);
            cnt++;
        }
    }
    if(cnt>1){
        cout<<"Error: "<<cnt<<" components";
        cout<<endl;
        return 0;
    }

    for(int i=1;i<=n;i++){
        fill(vis,vis+maxn,false);
        vis[i] = true;
        DFS(i,1);
    }

    for(int i=1;i<=n;i++){
        if(depth[i]==maxd){
            cout<<i<<endl;
        }
    }

    return 0;
}

 思路：

先通过DFS遍历求得连通分量数（因为输入的边数为n-1，所以在输入n个结点，n-1条边时，如果有环不可能只有一个连通分量），如果>1，则不是树；如果是树，则遍历每个结点，求得最大高度，并求得以每个结点为根的最大高度；最后循环如果高度==最大高度，则输出；