1021 Deepest Root (25 分) 并查集+dfs邻接表

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 <cstdio>
#include <vector>
#include <algorithm>
using namespace std;

const int maxn = 100010;
vector<int> G[maxn];

bool isroot[maxn];
int father[maxn];
int findfather(int x) {
	int a = x;
	while (x != father[x]) {
		x = father[x];
	}

	while (a != father[a]) {
		int z = a;
		a = father[a];
		father[z] = x;
	}
	return x;

}

void Union(int a, int b) {//合并，Union
	int faA = findfather(a);
	int faB = findfather(b);
	if (faA != faB) {
		father[faA] = faB;
	}


}

void init(int n) {
	for (int i = 1; i <= n; i++) {
		father[i] = i;
	}
}

int calblock(int n) {
	int block = 0;
	for (int i = 1; i <= n; i++) {
		isroot[findfather(i)] = true;
	}
	for (int i = 1; i <= n; i++) {
		if (isroot[i] == true)block++;
	}
	return block;
}

int maxheight;
vector<int> temp, ans;

void dfs(int u, int height, int pre) {
	if (height > maxheight) {
		temp.clear();
		temp.push_back(u);
		maxheight = height;

	}
	else if (height == maxheight) {
		temp.push_back(u);
	}

	for (int i = 0; i < G[u].size(); i++) {
		if (G[u][i] == pre)continue;
		dfs(G[u][i], height + 1, u);
	}
}
int main() {
	int a, b, n;
	scanf("%d", &n);

	init(n);
	for (int i = 1; i < n; i++) {
		scanf("%d%d", &a, &b);
		G[a].push_back(b);
		G[b].push_back(a);
		Union(a, b);
	}

	int block = calblock(n);
	if (block != 1) {
		printf("Error: %d components\n", block);
	}
	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());
		printf("%d\n", ans[0]);
		for (int i = 1; i < ans.size(); i++) {
			if (ans[i] != ans[i - 1]) {
				printf("%d\n", ans[i]);
			}
		}
	}
	return 0;
}