1021 Deepest Root (25 分)

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 <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
const int N=1e4+10,M=N*2;
int n;
int h[N],e[M],ne[M],idx;//邻接表
int p[N];//并查集
int find(int x){//并查集的基本操作
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}
int dfs(int u,int father){
    //father是来源
    int depth=0;
    for(int i=h[u];~i;i=ne[i]){
        int j=e[i];
        if(j==father) continue;
        //表示要搜的节点是父节点，也就是走回头路了
        depth=max(depth,dfs(j,u)+1);
    }
    return depth;
}
void add(int a,int b){
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
int main(){
    cin>>n;int k=n;//k为连通块的数量
    memset(h,-1,sizeof h);//清空h,设为-1
    for(int i=1;i<=n;i++) p[i]=i;//初始化一下并查集的数组
    for(int i=0;i<n-1;i++){
        //读入n-1条边
        int a,b;cin>>a>>b;
        if(find(a)!=find(b)){
            //若a与b不在同一个连通块当中，此时新加入的边将a与b连接到一起
            k--;//连通块的数量-1
            p[find(a)]=find(b);
        }
        add(a,b),add(b,a);//新加入两个边
    }
    if(k>1) printf("Error: %d components",k);
    else{
        vector <int> nodes;//存储可能的点
        int max_depth=-1;//-1表示还没有搜过
        for(int i=1;i<=n;i++){
            //从i往下搜，为了避免搜回来需要记住当前这个点是从哪个点搜过来的，到时候往回搜的时候判断一下是不是
            //走回头路了。若走回头路了，就直接跳过就可以了
            int depth=dfs(i,-1);
            if(depth>max_depth){
                max_depth=depth;
                nodes.clear();
                nodes.push_back(i);
            }
            else if(depth==max_depth)
                nodes.push_back(i);
        }
        for(auto v:nodes) cout<<v<<endl;
    }
    return 0;
}

PAT目录