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

分析：首先深度优先搜索判断它有几个连通分量。如果有多个，那就输出Error: x components，如果只有一个，就两次深度优先搜索，先从一个结点dfs后保留最高高度拥有的结点们，然后从这些结点中的其中任意一个开始dfs得到最高高度的结点们，这两个结点集合的并集就是所求（参考柳婼大佬）

我的代码：

暴力解法

#include<cstdio>
#include<vector>
#include<set>
#include<algorithm>
using namespace std;
const int maxn = 11000;
vector<int> v[maxn];
set<int> s[maxn];
int maxd = 0;
bool flag[maxn] = {false};
void DFS(int root,int depth)
{
    flag[root] = true;
    if (maxd < depth)
        maxd = depth;
    for (int i = 0 ;i < v[root].size() ;i++)
    {
        if (flag[v[root][i]] == false)
            DFS(v[root][i],depth+1);
    }
}
int main()
{
    int n,cnt;
    scanf("%d",&n);
    for (int i = 0 ;i < n - 1 ;i++)
    {
        int v1,v2;
        scanf("%d%d",&v1,&v2);
        v[v1].push_back(v2);
        v[v2].push_back(v1);
    }
    for (int i = 1 ;i <= n ;i++)
    {
        cnt = 1,maxd = 0;
        fill(flag,flag + maxn,false);
        DFS(i,1);
        s[maxd].insert(i);
        for (int j = 1 ;j <= n ;j++)
        {
            if (flag[j] == false)
            {
                cnt++;
                DFS(j,1);
            }                
        }
        if (cnt > 1) break;
    }
    if (cnt == 1)
    {
        for (int i = n ;i > 0 ;i--)
        {
            if (s[i].size() != 0)
            {
                for (auto it = s[i].begin() ;it != s[i].end() ;it++)
                    printf("%d\n",*it);
                break;
            }
        }        
    }
    else
        printf("Error: %d components\n",cnt);
    return 0;
}

两次DFS

#include<cstdio>
#include<vector>
#include<set>
#include<algorithm>
using namespace std;
const int maxn = 11000;
vector<int> v[maxn];
set<int> s1,s2;
int maxd = 0;
bool flag[maxn] = {false};
void DFS(int root,int depth,set<int> &s)
{
    flag[root] = true;
    if (maxd < depth)
    {
        maxd = depth;
        s.clear();
        s.insert(root);
    }
    else if (maxd == depth)
        s.insert(root);
    for (int i = 0 ;i < v[root].size() ;i++)
    {
        if (flag[v[root][i]] == false)
            DFS(v[root][i],depth+1,s);
    }
}
int main()
{
    int n,cnt = 0;
    scanf("%d",&n);
    for (int i = 0 ;i < n - 1 ;i++)
    {
        int v1,v2;
        scanf("%d%d",&v1,&v2);
        v[v1].push_back(v2);
        v[v2].push_back(v1);
    }
    for (int i = 1 ;i <= n ;i++)
    {
        if (flag[i] == false)
        {
            DFS(i,1,s1);
            cnt++;
        }
    }
    if (cnt == 1)
    {
        maxd = 0;
        fill(flag,flag + maxn,false);
        DFS(*s1.begin(),1,s2);
        for (auto it = s1.begin() ;it != s1.end() ;it++)
            s2.insert(*it);
        for (auto it = s2.begin() ;it != s2.end() ;it++)
            printf("%d\n",*it);
    }
    else
        printf("Error: %d components\n",cnt);
    return 0;
}