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.

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:

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

本题最容易想到是将任何两个点之间的距离进行计算最后得到最大的距离即可。我采用了计算了所有的leaf到其他所有节点的距离，然后得到最大的距离。
后面看了想网上的算法可以采用两次的DFS得到结果

#include <iostream>
#include <list>
#include <set>
#include <queue>
#include <bitset>
#include <algorithm>

using namespace std;

list<int> graph[10001];
int main()
{
    int n;
    cin >> n;
    for (int i = 0; i < n - 1; i++)
    {
        int n1, n2;
        cin >> n1 >> n2;
        graph[n1].insert(graph[n1].begin(), n2);
        graph[n2].insert(graph[n2].begin(), n1);
    }

    set<int> leaf;
    for (int i = 1; i <= n; i++)
        if (graph[i].size() == 1)
            leaf.insert(i);
    if (leaf.size() == 0)
        leaf.insert(1);
    int maxLength = -1;
    set<int> root;
    int length[10001];
    bitset<10001> visited;
    for (set<int>::iterator it = leaf.begin(); it != leaf.end(); it++)
    {
        visited.reset();
        queue<int> que;
        int start = *it;
        length[start] = 0;
        que.push(start);
        visited.set(start);
        bool flag = false;
        int cnt = 1;
        while (!que.empty())
        {
            int node = que.front();
            que.pop();
            for (list<int>::iterator lit = graph[node].begin(); lit != graph[node].end(); lit++)
            {
                if (!visited[*lit])
                {
                    length[*lit] = length[node] + 1;
                    visited.set(*lit);
                    que.push(*lit);
                }
            }
            if (que.empty())
            {
                for (int i = 1; i <= n; i++)
                {
                    if (!visited[i])
                    {
                        que.push(i);
                        visited.set(i);
                        flag = true;
                        cnt++;
                        break;
                    }
                }
            }
        }

        if (flag)
        {
            cout << "Error: " << cnt << " components" << endl;
            return 0;
        }
        int max = -1, maxIndex;
        for (int j = 1; j <= n; j++)
        {
            if (length[j] > max)
            {
                max = length[j];
                maxIndex = j;
            }
        }
        if (maxLength < max)
        {
            maxLength = max;
            root.clear();
            root.insert(start);
            root.insert(maxIndex);
        }
        else if (maxLength == max)
        {
            root.insert(start);
            root.insert(maxIndex);
        }
    }

    for (set<int>::iterator it = root.begin(); it != root.end(); it++)
        cout << *it << endl;
}