PAT-A 1021.Deepest Root(25分）

最新推荐文章于 2024-05-05 16:57:35 发布

 小鹰

最新推荐文章于 2024-05-05 16:57:35 发布

阅读量208

点赞数

CC 4.0 BY-SA版权

分类专栏： PAT-A 文章标签： PAT-A PAT甲级

本文链接：https://blog.youkuaiyun.com/x_ying_/article/details/88598450

PAT-A 专栏收录该内容

2 篇文章

订阅专栏

本文介绍了一种算法，用于在给定的无环连通图（树）中找到导致最高树形结构的根节点，即最深根。通过广度优先搜索（BFS）策略，算法遍历每个可能的根节点，计算其最大深度，并找出所有达到最大深度的根节点。若输入图不是树（存在多个连通组件），则返回错误信息。代码实现包括节点结构定义、输入处理、BFS遍历和连通组件计数。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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 (≤10000) 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 <vector>
#include <algorithm>
#include <queue>
using namespace std;
class EdgeNode
{
	public:
	int adjvex;
	EdgeNode* next;
	int weight;

	EdgeNode() :adjvex(-1), next(nullptr), weight(1) {}
	EdgeNode(int adj) :adjvex(adj), next(nullptr), weight(1) {}
	EdgeNode(int adj, EdgeNode* e, int weight,) : adjvex(adj), next(e), 	weight(weight){}
};

class VertexNode
{
public:
	EdgeNode* firstarc;
};
class DeepestRoot
{
private:
	int nodes;
	vector<VertexNode> matrix;
	vector<int> visited;
	vector<int> deep_root;
	bool isTree;
	int max_deep;

public:
	DeepestRoot()
	{
		input();
		isTree = true;
		max_deep = 0;
		for (int i = 1; i <= nodes; ++i)
		{
			visited.clear();
			visited.resize(nodes + 1, 0);
			visited[0] = -1;
			int depth = 0;
			BFS(i, depth);
			if (depth > max_deep)
				max_deep = depth;
			if (find(visited.begin(), visited.end(), 0) != visited.end())
			{
				//说明此图不连通，转去执行计算连通分量代码
				isTree = false;
				countcon();
				return;
			}
			deep_root.push_back(depth);
		}
		print();
	}

	void input()
	{
		scanf("%d", &nodes);
		matrix.resize(nodes + 1);
		for (int i = 0; i < nodes - 1; ++i)
		{
			int row, line;
			scanf("%d %d", &row, &line);
			EdgeNode* e1 = new EdgeNode(line, matrix[row].firstarc, 1, 0);
			matrix[row].firstarc = e1;
			EdgeNode* e2 = new EdgeNode(row, matrix[line].firstarc, 1, 0);
			matrix[line].firstarc = e2;
		}
	}

	void BFS(int v, int& depth)
	{
		queue<int> que;
		que.push(v);
		visited[v] = 1;
		while (!que.empty())
		{
			int k = que.front();
			que.pop();
			depth = visited[k];
			EdgeNode* e = matrix[k].firstarc;
			while (e)
			{
				if (!visited[e->adjvex])
				{
					que.push(e->adjvex);
					visited[e->adjvex] = depth + 1;
				}
				e = e->next;
			}
		}
	}

	void countcon()
	{
		visited.clear();
		visited.resize(nodes + 1, 0);
		visited[0] = -1;
		int count = 0;
		for (int i = 1; i < nodes + 1; ++i)
		{
			if (!visited[i])
			{
				bfs(i);
				++count;
			}
		}
		if (1 == count) printf("Error: %d component", count);
		else printf("Error: %d components", count);
	}
	
	void bfs(int v)
	{
		queue<int> que;
		que.push(v);
		visited[v] = 1;
		while (!que.empty())
		{
			int k = que.front();
			que.pop();
			EdgeNode* e = matrix[k].firstarc;
			while (e)
			{
				if (!visited[e->adjvex])
				{
					que.push(e->adjvex);
					visited[e->adjvex] = 1;
				}
				e = e->next;
			}
		}
	}

	void print()
	{
		int max = 0;
		for (size_t i = 0; i < deep_root.size(); ++i)
		{
			if (deep_root[i] == max_deep)
				printf("%d\n", i + 1);
		}
	}
};

int main()
{
  DeepestRoot dp;
  return 0;
}