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

结尾无空行

本题，有点难度的，分析如下：
先画出草图：

可以看到，最深的路径分别是 3 4 5
3 - 1 - 2 - 5
4 - 1 - 2 - 5
5 - 2 - 1 - （3,4）

所以，此题我们可以看成一个 深度优先搜索的题目，首先，随便选一个点，这里用 1 ，然后求出与 1 相隔最远的点，也就是 5，然后任意选出与 1 相隔最远的点的一个，然后求与该点像个最远的点，答案就是两个的结果做并集。

与 1 相隔最远的是 5，
与 5 相隔最远的是 3， 4
所以答案就是 3，4，5

使用深搜，数组 vis 记录是否访问过，v 存放路径信息，temp 存放某深度的所有点。

#include<iostream>
#include<string>
#include<algorithm>
#include<bits/stdc++.h>
#include<stack>
#include<set>
#include<vector>
#include<map>
#include<queue>
#include<deque>
#include<cctype>
#include<unordered_set>
#include<unordered_map>
#include<fstream>
#include<cstring>
using namespace std;
const int maxn = 10001; 
vector<int> v[maxn];
vector<int> temp[maxn];
bool vis[maxn];
int maxDepth = 0;
void Dfs(int x, int level) {
	vis[x] = true;
	temp[level].push_back(x);
	if (level > maxDepth) {
		maxDepth = level;
	}
	for (int i = 0; i < v[x].size(); i++) {
		if (!vis[v[x][i]]) {
			Dfs(v[x][i], level + 1);
		}
	}
}
int main() {
	int n;
	cin >> n;
	for (int i = 1; i < n; i++) {
		int a, b;
		cin >> a >> b;
		v[a].push_back(b);
		v[b].push_back(a);
	}
	int count = 0;
	for (int i = 1; i <= n; i++) {
		if (!vis[i]) {
			Dfs(i, 0);
			count++;
		}
	}
	if (count != 1) {
		printf("Error: %d components", count);
	} else {
		set<int> st;
		for (int i = 0; i < temp[maxDepth].size(); i++) {
			st.insert(temp[maxDepth][i]);
		}
		int start = temp[maxDepth][0];
		memset(vis, 0, sizeof(vis));
		Dfs(start, 0);
		for (int i = 0; i < temp[maxDepth].size(); i++) {
			st.insert(temp[maxDepth][i]);
		}
		for (auto it = st.begin(); it != st.end(); it++) {
			printf("%d\n", *it);
		}
	}
	return 0;
}