1021. Deepest Root (25)

最新推荐文章于 2020-11-02 12:36:26 发布

原创最新推荐文章于 2020-11-02 12:36:26 发布 · 477 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#PAT #dfs #连通性 #动态链表

PAT 专栏收录该内容

24 篇文章

订阅专栏

本文介绍了一种算法，用于在给定的无环连通图中找到能够生成最高树的根节点，即所谓的最深根节点。通过深度优先搜索（DFS）遍历每个节点作为根节点时树的高度，并处理图可能不连通的情况。

摘要生成于 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:

Sample Output 1:

3
4
5

Sample Input 2:

Sample Output 2:

Error: 2 components

分析：

这一题考虑的是图的连通性和最大深度搜索生成树。连通性可以用并查集验证，不过并查集我一时半会没想起来，又看着这个图是非带权图，所以就有DFS去求其连通分支了。最深生成树的话当然是用DFS来生成了，每次对不同结点进行深度搜索并且生成深度生成树，比较深度得到最深的那个或那几个。

不过要注意的是如果使用的是邻接矩阵来存储图的话，这样会有一个case通不过并且报错内存溢出，这是因为矩阵的阶数到达10000了之后，那么就需要10K×10K×4B = 400MB的空间来存储N-1条路径，这明显是不可行的。所以要用动态链表来存储路径。

代码如下：

#include <stdio.h>
#include <stdlib.h>

typedef struct link_list
{
	int value;
	struct link_list *next;
}ll;

int max_deep,count,n;
ll path[10001];
int droot[10001],visit[10001];

void init(int *v);
int dfs(int root,int deep);

int main(int argc,char* argv[])
{
	int i,j,x,y,components;
	ll *list,*last;

	//freopen("input","r",stdin);
	scanf("%d",&n);

	//init path link list
	for(i=1;i<=n;i++)
	{
		path[i].value = i;
		path[i].next = NULL;
	}

	//scanf path matrix
	for(i=0;i<n-1;i++)
	{
		scanf("%d%d",&x,&y);
		list = (ll *)malloc(sizeof(ll));
		list->value = y;
		list->next = NULL;
		last = &path[x];
		while(last->next != NULL)
			last = last->next;
		last->next = list;
		
		list = (ll *)malloc(sizeof(ll));
		list->value = x;
		list->next = NULL;
		last = &path[y];
		while(last->next != NULL)
			last = last->next;
		last->next = list;
	}

	//dfs from each node
	for(i=1;i<=n;i++)
	{
		max_deep = count = 0;
		init(visit);
		visit[i] = 1;
		count += 1;
		dfs(i,0);
		if(count < n)
			break;
		droot[i] = max_deep;
	}

	//not connected
	if(count < n)
	{
		init(visit);
		components = 0;
		for(i=1;i<=n;i++)
		{
			if(!visit[i])
			{
				components += 1;
				dfs(i,0);
			}
		}
		printf("Error: %d components\n",components);
		return 0;
	}

	//print the deepest root
	max_deep = 0;
	for(i=1;i<=n;i++)
	{
		if(max_deep < droot[i])
			max_deep = droot[i];
	}

	for(i=1;i<=n;i++)
	{
		if(droot[i] == max_deep)
			printf("%d\n",i);
	}

	return 0;
}

void init(int *v)
{
	int i;
	for(i=1;i<=n;i++)
		visit[i] = 0;
}

int dfs(int root,int deep)
{
	int i,value;
	ll *node = &path[root];
	int this_deep = deep;

	if(node->next == NULL)
		return 0;

	while(node->next != NULL)
	{
		value = node->next->value;
		if(!visit[value])
		{
			visit[value] = 1;
			count += 1;
			this_deep += 1;
			if(max_deep < this_deep)
				max_deep = this_deep;
			dfs(value,this_deep);
			this_deep -= 1;
			node = node->next;
		}
		else
			node = node->next;
	}

	return 0;
}