PAT 1021 Deepest Root

最新推荐文章于 2023-07-28 14:02:44 发布

原创最新推荐文章于 2023-07-28 14:02:44 发布 · 192 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#PAT #1021 #DFS

PAT 专栏收录该内容

25 篇文章

订阅专栏

本文探讨了如何在一个无环连通图中找到使得树高度最大的根节点，即所谓的最深根。通过并查集检测输入图是否含有环，并利用两次深度优先搜索算法确定最深根。第一次DFS找到所有可能的最深节点，第二次DFS从这些节点中选取一个作为根，再次确定最深节点。如果输入图不是一棵树，则输出错误信息及连通组件数量。

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
思路：并查集检查输入的图有没有环，如果有就输出连通分支个数，结束。若无环，两遍dfs，第一遍找出dfs最深的那个节点（可以有多个），保存这些节点，然后从中任取一个节点dfs，找出最深的那些节点保存，两次下来的结果就是最终答案

#include <cstdio>
#include <vector>
#include <set>
#define maxn 10001

using namespace std;

void Union(int a, int b);
int Findf(int a);
void dfs(int v, int deepth);

vector<int> E[maxn];
int N, root[maxn]={0}, high[maxn]={0};
bool circle = false, vis[maxn] = {0};

int main()
{
    scanf("%d", &N);
    for (int i=1; i<=N-1; i++)
    {
        int v1, v2;
        scanf("%d %d",&v1, &v2);
        if (Findf(v1) == Findf(v2))
            circle = true;
        Union(v1, v2);
        E[v1].push_back(v2);
        E[v2].push_back(v1);
    }
    if (circle == true)
    {
        int cnt=0;
        for (int i=1; i<=N; i++)
        {
            if (root[i] == 0)
                cnt++;
        }
        printf("Error: %d components", cnt);
        return 0;
    }
    else
    {
        int maxhigh=0;
        set<int> s;
        dfs(1,1);
        for (int i=1; i<=N; i++)
        {
            if (high[i] > maxhigh)
                maxhigh = high[i];
        }
        for (int i=1; i<=N; i++)
        {
            if (high[i] == maxhigh)
                s.insert(i);
            high[i] = 0;
            vis[i] = false;
        }
        set<int>::iterator it;
        it = s.begin();
        dfs(*it, 1);
        maxhigh = 0;
        for (int i=1; i<=N; i++)
        {
            if (high[i] > maxhigh)
                maxhigh = high[i];
        }
        for (int i=1; i<=N; i++)
        {
            if (high[i] == maxhigh)
                s.insert(i);
        }
        for (it=s.begin(); it!=s.end(); it++)
            printf("%d\n",*it);
    }
    return 0;
}

void Union(int a, int b)
{
    a = Findf(a);
    b = Findf(b);
    if (a != b)
        root[a] = b;
}

int Findf(int a)
{
    int roota = a;
    while (root[roota] != 0)
        roota = root[roota];
    while (a != roota)
    {
        int tmp = root[a];
        root[a] = roota;
        a = tmp;
    }
    return roota;
}

void dfs(int v, int deepth)
{
    vis[v] = true;
    high[v] = deepth;
    deepth++;
    for (int i=0; i<E[v].size(); i++)
    {
        if (vis[E[v][i]] == false)
            dfs(E[v][i], deepth);
    }
}