1021. Deepest Root

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.

本来想暴力解决,暴力半天也没找着头绪,然后看到了大神的逻辑

从任意节点出发进行遍历,得到的最深的节点一定是所求的根节点集合的一部分;两次遍历结果的并集为所求的根节点集合。

#include <stdio.h>
#include <stdlib.h>
#include <vector>
#include <set>
using namespace std;
#define N 10001

vector<int> G[N];
int father[N];
set<int> root;
int maxH=0;
set<int> temp,result;

void DFS (int now,int height,int pre);
int Block(int n);
int Find (int a);
void Union (int a,int b);
void Init (int n);

int main ()
{
    int n,i;
    scanf("%d",&n);
    Init(n);
    int start,end;
    for( i=0;i<n-1;i++)
    {
         scanf("%d %d",&start,&end);
         G[start].push_back(end);
         G[end].push_back(start);
         Union(start,end);
         }
    //////////////////
    int num=Block(n);
    if( num>1)
    {
        printf("Error: %d components\n",num);
        return 0;
        }
    DFS(1,1,-1);
    result=temp;
    set<int>::iterator it=result.begin();
    set<int>::iterator its=temp.begin();
    DFS(*it,1,-1);
    for( ;its!=temp.end();its++) result.insert(*its);
    for( it=result.begin();it!=result.end();it++) printf("%d\n",*it);
    system("pause");
    return 0;
    }
void DFS (int now,int height,int pre)
{
     if( height>maxH)
     {
         temp.clear();
         temp.insert(now);
         maxH=height;
         }
     else if( height==maxH) temp.insert(now);

     for(int i=0;i<G[now].size();i++)
         if(G[now][i]!=pre) DFS(G[now][i],height+1,now);
     }

int Block(int n)
{
    int i;
    for( i=1;i<=n;i++) root.insert(Find(i));
    return root.size();
    }
int Find (int a)
{
    while( a!=father[a]) a=father[a];
    return a;
    }
void Union (int a,int b)
{
     int fa=Find(a);
     int fb=Find(b);
     if( fa!=fb) father[fa]=fb;
     }
void Init (int n)
{
     int i;
     for( i=1;i<=n;i++)
          father[i]=i;
     }

时间: 2024-11-08 06:26:01

1021. Deepest Root的相关文章

1021. Deepest Root (25) 并查集&amp;&amp;DFS

1021. Deepest Root (25) 时间限制 1500 ms 内存限制 65536 kB 代码长度限制 16000 B 判题程序 Standard 作者 CHEN, Yue 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 t

PAT 1021. Deepest Root (25)

1021. Deepest Root (25) 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

1021 Deepest Root (25 分)

1021 Deepest Root (25 分) 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 roo

1021 Deepest Root (25 分)(经典搜索)

1021 Deepest Root (25 分) 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 roo

1021. Deepest Root (25)

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: E

PAT 甲级 1021 Deepest Root

https://pintia.cn/problem-sets/994805342720868352/problems/994805482919673856 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

1021 Deepest Root [DFS]

这题一开始没认真看题,直接看样例以为求叶子结点和几棵树.题目的真正的意思是给你一张无环连通图,以任意点为根节点可以把该图看成一棵树,并且如果当前树的深度最大,就称这个点是Deepest Root,也就是题目所要求的(升序输出).如果这个图有多个连通分量,求连通分量的个数.DFS可以通吃,详见代码- #include <bits/stdc++.h> #define maxn 100005 #define INF 0x3f3f3f3f using namespace std; typedef lo

PAT 1021 Deepest Root

#include <cstdio> #include <cstdlib> #include <vector> using namespace std; class Node { public: vector<int> adj; bool visited; Node() : visited(false) {} }; void reset_nodes(vector<Node>& nodes) { int len = nodes.size();

PAT (Advanced Level) 1021. Deepest Root (25)

先并查集判断连通性,然后暴力每个点作为根节点判即可. #include<iostream> #include<cstring> #include<cmath> #include<algorithm> #include<cstdio> #include<queue> #include<vector> using namespace std; struct Edge { int a,b; }e[20000]; int n,sz