[PAT-Advanced] A1021 Deepest Root (25)

总题解目录

[PAT- Advanced Level] 甲级题解目录（Advanced Level）

A1021 Deepest Root (25point(s))

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

Analysis

• 已知一个无环图，根据选定的根不同，得到的树的深度也不同。
• 求在给出的无环图中，以哪个结点作为root得到的树有最大深度。
• 如果有多个结点作为根得到的深度相同，则将这些结点按照升序输出。
• 如果得到的不是一个树（而是多个树），则输出Error: K components，其中K表示极大连通子图数。

C++ Code1

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
#include <algorithm>
#define INF 1000000000
using namespace std;
const int maxn = 10010;
int n, u, v, depthest[maxn], k = 0, dep = 0;
bool vis[maxn];
vector<int > adj[maxn], roots;
void DFS(int u, int depth, int root){
	vis[u] = 1;
	if (depth > depthest[root])
		depthest[root] = depth;
	for (int i = 0; i < adj[u].size(); i++)
		if (vis[adj[u][i]] == false)
			DFS(adj[u][i], depth + 1, root);
}
void DFSTravel(){		// 计算极大连通子图数
	for (int i = 1; i <= n; i++){
		if (vis[i] == false){
			DFS(i, 0, i);
			k++;
		}
	}
}
void DFSTravel2(){		// 
	for (int i = 1; i <= n; i++){
		memset(vis, 0, sizeof(vis));
		if (vis[i] == false)
			DFS(i, 0, i);
	}
}
int main(){
	scanf("%d", &n);
	for (int i = 1; i < n; i++){
		scanf("%d %d", &u, &v);
		adj[u].push_back(v);
		adj[v].push_back(u);
	}
	DFSTravel();
	if (k>1)
		printf("Error: %d components\n", k);
	else{
		DFSTravel2();
		for (int i = 1; i <= n; i++)	// 找最大深度
			if (depthest[i] > dep)
				dep = depthest[i];
		for (int i = 1; i <= n; i++)	// 将最大深度相同的结点编号输入
			if (dep == depthest[i])
				roots.push_back(i);
		//sort(roots.begin(), roots.end());	// 之前的寻找过程按递增顺序，故可以不用排序
		for (int i = 0; i < roots.size(); i++)
			printf("%d\n", roots[i]);
	}
	return 0;
}

C++ Code2

#include <bits/stdc++.h>
#define MAX_N 10001
using namespace std;

int n, u, v, depthest[MAX_N], dep = 0;
bool vis[MAX_N];
vector<int > adj[MAX_N], roots;

void DFS(int u, int depth, int root){
	vis[u] = 1;
	if (depth > depthest[root])
		depthest[root] = depth;
	for (int i = 0; i < adj[u].size(); i++)
		if (vis[adj[u][i]] == false)
			DFS(adj[u][i], depth + 1, root);
}

int get_subgraphs_num(){
    int k = 0;
    memset(vis, 0, sizeof(vis));
	for (int i = 1; i <= n; i++){
		if (vis[i] == false){
			DFS(i, 0, i);
			k++;
		}
	}
    return k;
}

void gen_all_depth(){
	for (int i = 1; i <= n; i++){
		memset(vis, 0, sizeof(vis));
		if (vis[i] == false)
			DFS(i, 0, i);
	}
}

int main(){
	scanf("%d", &n);
	for (int i = 1; i < n; i++){
		scanf("%d %d", &u, &v);
		adj[u].push_back(v);
		adj[v].push_back(u);
	}

	int k = get_subgraphs_num();

	if (k>1)
		printf("Error: %d components\n", k);
	else{
		gen_all_depth();
		for (int i = 1; i <= n; i++)
			if (depthest[i] > dep)
				dep = depthest[i];
		for (int i = 1; i <= n; i++)
			if (dep == depthest[i])
				roots.push_back(i);
		//sort(roots.begin(), roots.end());	    // 之前的寻找过程按递增顺序，故可以不用排序
		for (int i = 0; i < roots.size(); i++)
			printf("%d\n", roots[i]);
	}

	return 0;
}