1021. Deepest Root

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 (<=10000) 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.

本来想暴力解决，暴力半天也没找着头绪，然后看到了大神的逻辑

从任意节点出发进行遍历，得到的最深的节点一定是所求的根节点集合的一部分；两次遍历结果的并集为所求的根节点集合。

#include <stdio.h>
#include <stdlib.h>
#include <vector>
#include <set>
using namespace std;
#define N 10001

vector<int> G[N];
int father[N];
set<int> root;
int maxH=0;
set<int> temp,result;

void DFS (int now,int height,int pre);
int Block(int n);
int Find (int a);
void Union (int a,int b);
void Init (int n);

int main ()
{
    int n,i;
    scanf("%d",&n);
    Init(n);
    int start,end;
    for( i=0;i<n-1;i++)
    {
         scanf("%d %d",&start,&end);
         G[start].push_back(end);
         G[end].push_back(start);
         Union(start,end);
         }
    //
    int num=Block(n);
    if( num>1)
    {
        printf("Error: %d components\n",num);
        return 0;
        }
    DFS(1,1,-1);
    result=temp;
    set<int>::iterator it=result.begin();
    set<int>::iterator its=temp.begin();
    DFS(*it,1,-1);
    for( ;its!=temp.end();its++) result.insert(*its);
    for( it=result.begin();it!=result.end();it++) printf("%d\n",*it);
    system("pause");
    return 0;
    }
void DFS (int now,int height,int pre)
{
     if( height>maxH)
     {
         temp.clear();
         temp.insert(now);
         maxH=height;
         }
     else if( height==maxH) temp.insert(now);
     
     for(int i=0;i<G[now].size();i++)
         if(G[now][i]!=pre) DFS(G[now][i],height+1,now);
     }

int Block(int n)
{
    int i;
    for( i=1;i<=n;i++) root.insert(Find(i));
    return root.size();
    }
int Find (int a)
{
    while( a!=father[a]) a=father[a];
    return a;
    }
void Union (int a,int b)
{
     int fa=Find(a);
     int fb=Find(b);
     if( fa!=fb) father[fa]=fb;
     }
void Init (int n)
{
     int i;
     for( i=1;i<=n;i++)
          father[i]=i;
     }