【笨方法学PAT】1021 Deepest Root （25 分）

一、题目

A graph which is connected and acyclic can be considered a tree. The hight 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

二、题目大意

给出n个结点（1~n）之间的n条边，问是否能构成一棵树，如果不能构成则输出它有的连通分量个数，如果能构成一棵树，输出能构成最深的树的高度时，树的根结点。如果有多个，按照从小到大输出。。

三、考点

图、DFS

四、注意

1、使用二维数组保存图的结构会有一个测试点超时！使用邻接矩阵；

2、使用visit标记访问过的节点，对每个没有访问过点的DFS，获得连通分量的个数；

3、如果只有一个连通分量，获得此时的最深节点；

4、对上述的任意最深节点，继续DFS，获得所有的最深节点。

五、代码

#include<iostream>
#include<vector>
#include<set>
#include<algorithm>
#define N 10001
using namespace std;

//int m[N][N];
vector<vector<int>> m;
bool visit[N] = { false };
int n;
int max_depth = 0;
vector<int> path;

void dfs(int root, int depth) {
	if (depth > max_depth) {
		max_depth = depth;
		path.clear();
		path.push_back(root);
	}
	else if(depth==max_depth)
		path.push_back(root);
	visit[root] = true;
	for(int i=0;i<m[root].size();++i){
		if (visit[m[root][i]] == false)
			dfs(m[root][i],depth+1);
	}
}

int main() {
	//read
	cin >> n;
	m.resize(n + 1);
	for (int i = 0; i < n - 1; ++i) {
		int a, b;
		scanf("%d %d", &a, &b);
		m[a].push_back(b), m[b].push_back(a);
	}

	//dfs
	int k = 0;
	set<int> sset;
	int root;
	for (int i = 1; i <= n; ++i) {
		if (visit[i] == false) {
			k++;
			dfs(i, 0);
			if (i == 1) {
				if (path.size() > 0) {
					root = path[0];
					for (int j = 0; j < path.size(); ++j)
						sset.insert(path[j]);
				}
			}
				
		}
	}

	//component
	if (k != 1) {
		printf("Error: %d components", k);
	}

	//deepest root
	else {
		fill(visit, visit + N, false);
		path.clear();
		dfs(root, 0);
		for (int i = 0; i < path.size(); ++i)
			sset.insert(path[i]);
		for (auto it = sset.begin(); it != sset.end(); ++it)
			//cout << *it << endl;
			printf("%d\n", *it);
	}

	system("pause");
	return 0;
}