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 (≤) 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深搜找出连通分量的个数，第一次深搜找出以一号结点作为根节点的深度最大的那个结点，然后再一次结点进行第二次深搜，找出深度最深的结点。

Code：

#include <bits/stdc++.h>

using namespace std;

int n;
vector<int> ans;
vector<bool> visited;
vector<vector<int> > grap;
int max_deep = 0;

void DFS(int node, int level) {
    if (max_deep < level) {
        ans.clear();
        ans.push_back(node);
        max_deep = level;
    } else if (max_deep == level) {
        ans.push_back(node);
    }
    visited[node] = true;
    for (int it : grap[node]) {
        if (visited[it] == false) {
            DFS(it, level + 1);
        }
    }
}

int main() {
    int v1, v2;
    cin >> n;
    grap.resize(n + 1);
    visited.resize(n + 1, false);
    for (int i = 1; i < n; ++i) {
        cin >> v1 >> v2;
        grap[v1].push_back(v2);
        grap[v2].push_back(v1);
    }
    int count = 0, s1 = 0;
    set<int> s;
    for (int i = 1; i <= n; ++i) {
        if (visited[i] == false) {
            DFS(i, 1);
            if (i == 1) {
                if (ans.size() != 0) s1 = ans[0];
                for (int it : ans) s.insert(it);
            }
            count++;
        }
    }

    if (count > 1) {
        cout << "Error: " << count << " components" << endl;
    } else {
        ans.clear();
        max_deep = 0;
        visited.clear();
        visited.resize(n + 1, false);
        DFS(s1, 1);
        for (int it : ans) s.insert(it);
        for (int it : s) cout << it << endl;
    }
    return 0;
}

 

参考：

　　https://www.liuchuo.net/archives/2348