[Python](PAT)1021 Deepest Root（25 分）

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

原创最新推荐文章于 2024-05-05 16:57:35 发布 · 493 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#python #PAT #图的遍历

Python 同时被 2 个专栏收录

49 篇文章

订阅专栏

PAT

43 篇文章

订阅专栏

该博客讨论了如何在给定的无环连接图（树）中找到导致最高树高度的根节点，即最深根。介绍了输入和输出规格，并提供了样例输入和输出。文章通过广度优先搜索来解决此问题，当图的连通分量不为1时，输出错误信息及连通组件数量。Python实现代码也进行了展示。

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

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 (≤104) 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

题目大意

给定一张图，如果这张图的连通分量为1，则输出最深的根。最深的根即为从它开始遍历，能够遍历最多的层数的根。

如果连通分量不为1，则输出“Error: N components”，其中N为连通分量。

分析

首先用广度优先遍历判断它的节点是否只有1个，如果是直接输出1.

然后获取图信息，使用字典存储，先找出没有在输入信息中给出的点的个数，每多一个，连通分量加一。（考虑以下这个测试用例，十分坑）

输出应该是Error: 6 components。第二个结点就在输出中没有给出。

如果连通分量仅为1，则返回True和当前任意点开始的广度优先遍历的最深叶子结点。然后从这些叶子节点中随意挑选一个重新进行一次广度优先遍历，将前面得到的结果和现如今得到的最深叶子节点相加然后去重再排列，得到的就是答案。

如果连通分量不为1，则继续广度优先遍历，找出连通分量有多少，最后输出。

Python实现

def bfs(graph, start):
    global n
    count = 0
    visted = [0 for x in range(n)]
    for x in range(n):
        if x+1 not in graph:
            visted[x] = 1
            count += 1
    step = [start]
    while(count == 0):
        temp = []
        for x in step:
            visted[x-1] = 1
            for j in graph[x]:
                if visted[j-1] == 0:
                    temp.append(j)
        if len(temp) == 0:
            if 0 not in visted:
                return True, step
            else:
                break
        step = temp
    while(0 in visted):
        count += 1
        start = [x for x in graph if visted[x-1] ==0][0]
        step = [start]
        while(len(step)>0):
            temp = []
            for x in step:
                visted[x-1] = 1
                for j in graph[x]:
                    if visted[j-1] == 0:
                        temp.append(j)
            if len(temp)==0:
                if 0 not in visted:
                    return False, count
            step = temp
            
if __name__ == "__main__":
    n = int(input())
    if n==1:
        print(1)
    else:
        graph = {}
        for x in range(n-1):
            line = input().split(" ")
            start, to = int(line[0]), int(line[1])
            try:
                graph[start].append(to)
            except:
                graph[start] = [to]
            try:
                graph[to].append(start)
            except:
                graph[to] = [start]
        back = bfs(graph, start)
        if back[0]:
            another = bfs(graph, back[1][0])
            result = sorted(set(back[1] + another[1]))
            for x in result:
                print(x)
        else:
            print('Error: {} components'.format(back[1]))

用python写PAT甲级，答案全在这了