1021 Deepest Root (25分)

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 <algorithm>
#include<vector>
#include<map>
#include<string>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<set>
#include<unordered_map>
#include<queue>
#include<climits>
#include<stack>
using namespace std;
const int maxn= 10010;


vector<int>g[maxn],ans,temp;

int f[maxn];
int find(int x){
	if(x!=f[x]) return f[x]=find(f[x]);
	else return f[x];	
}

int max_depth=-1;
void dfs(int u,int depth,int pre){
	if(max_depth<depth){
		max_depth=depth;
		temp.clear();
		temp.push_back(u);	
	}else if(max_depth==depth){
		temp.push_back(u);		
	}	
	for(int i=0;i<g[u].size();i++){
		if(g[u][i]==pre) continue;
		dfs(g[u][i],depth+1,u);	
	}
}


int main(){
	int n;
	cin>>n;
	for(int i=1;i<=n;i++) f[i]=i;
	int k=n;
	for(int i=0;i<n-1;i++){
		int a,b;
		cin>>a>>b;
		g[a].push_back(b);
		g[b].push_back(a);
	
		if(find(a)!=find(b)){
			f[find(b)]=find(a);
			k--;	
		}
	}
	if(k>1) printf("Error: %d components",k);
	else{
		dfs(1,1,-1);
		ans=temp;
		dfs(ans[0],1,-1);
		for(int i=0;i<temp.size();i++) ans.push_back(temp[i]);
		sort(ans.begin(),ans.end());
		cout<<ans[0]<<endl;
		for(int i=1;i<ans.size();i++) {
			if(ans[i]!=ans[i-1])
			cout<<ans[i]<<endl;
		
		}
	}
	
    return 0;
}