1021. Deepest Root (25) DFS & （a little idea ）

最新推荐文章于 2022-07-26 16:07:35 发布

Uncle_Sugar

最新推荐文章于 2022-07-26 16:07:35 发布

阅读量947

点赞数 1

分类专栏： PAT甲级文章标签： dfs 图最长路编程 PAT

本文链接：https://blog.csdn.net/sinat_29278271/article/details/47934611

版权

PAT甲级专栏收录该内容

37 篇文章 1 订阅

订阅专栏

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 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求最长路并记录，最后将所有最长路为最大值的节点输出，在PAT上也能过，但是在牛客网上是过不了的（牛客网数据略强）。

判断图是否连接用并查集解决，我觉得我不用多说的。然后图连通时，第一遍任取起点DFS用vis数组记录每个节点的在dfs搜索中的距离，与dfs能达到的最大距离Max，将所有vis[i]==Max的i插入set。第二遍从Set中任取一个元素，重复第一次遍历时的操作。然后输出set中的所有元素。

先上代码，后发证明。

# include <cstdio>
# include <iostream>
# include <cstring>
# include <algorithm>
# include <set>
# include <vector>
using namespace std;

const int size  = 10000; 
const int debug = 1;

class DisjointSet
{
private:
    int *T,size,sum;
    int FindRoot(int i){return T[i] < 0 ? i : (T[i] = FindRoot(T[i]));}
public:
    DisjointSet(int _size):size(_size)
    {
        T = new int[size];
        Init();
    }
    void Init(){sum = size;memset(T,-1,sizeof(int)*size);}
    bool Unioned(int i,int j){return FindRoot(i)==FindRoot(j);}
    void Union(int i,int j)
      {
        if ( (i = FindRoot(i) ) != ( j = FindRoot(j) ) )
        {
            T[i] = T[i] + T[j];
            T[j] = i;
            sum--;
        }
      }
    int FindSum(int i){return -T[FindRoot(i)];}
    int SumOfUnits(){return sum;}
    ~DisjointSet(){delete[] T;}
};

vector<int> v[size];
int vis[size];
void dfs(int i,int dist,int &MAX)
{
     vis[i] = dist;
     MAX = max(MAX,vis[i]);
     for (int k=0;k<v[i].size();k++)
         if (vis[v[i][k]]==-1)   
		    dfs(v[i][k],dist+1,MAX);
}
int main()
{
  int i,j,temp;
  int n;
  scanf("%d",&n);
  DisjointSet ds(n); 
  for (i=0;i<n-1;i++)
    {
      int a,b;
      scanf("%d%d",&a,&b);a--,b--;
      v[a].push_back(b);
      v[b].push_back(a);
      ds.Union(a,b);
    }
  if (ds.SumOfUnits() == 1)
    {
  	  int start,Max;
  	  set<int> s;
      for (Max=start=i=0;i<2;i++)
        {
       	  memset(vis,-1,sizeof(vis));
		  dfs(start,0,Max);
		  for (j=0;j<n;j++)
		      if (vis[j]==Max)
				  s.insert(j);
		  start = *s.begin();
		}
      for (set<int>::iterator it = s.begin();it!=s.end();it++)
	      printf("%d\n",(*it)+1);     
    }
  else 
      printf("Error: %d components\n",ds.SumOfUnits());
  return 0;
}