PAT 甲级 1021. Deepest Root（dfs:无向图的最远路径、连通分量个数）

原题传送门

//  一次dfs可以得到从指定结点到它的最远结点的路径；可以用一个数组存储下这批最远结点
//  任取上一批中的一结点开始，第二次dfs可以得到无向图的最远路径；用另一个数组存储下这批最远结点
//  两个数组的并集就是deepest root
#include <iostream>
#include <vector>
#include <set>
using namespace std;

int max_height = 0;
vector<vector<int>> v; // = vector<int> v[100]
bool visit[10010] = {false};
set<int> s; // set和multiset会根据特定的排序准则自动将元素排序，set中元素不允许重复，multiset可以重复。因为是排序的，所以set中的元素不能被修改，只能删除后再添加。
vector<int> temp; // 存储离根最远的结点，一个或多个

void dfs(int node, int height) {
    if(height > max_height) {
        temp.clear();
        temp.push_back(node);
        max_height = height;
    } else if(height == max_height) {
        temp.push_back(node);
    }
    visit[node] = true;
    for(int i = 0; i < v[node].size(); ++i) {
        if(visit[v[node][i]] == false)
            dfs(v[node][i], height+1);
    }
}

int main(int argc, const char * argv[]) {
    int n;
    cin >> n;
    v.resize(n+1);
    int a, b, cnt = 0;
    for(int i = 0; i <= n; ++i) {
        cin >> a >> b;
        v[a].push_back(b);
        v[b].push_back(a);
    }

    // 第一次深度优先搜索判断它有几个连通分量,并得到从根1开始的最远结点
    int s1 = 0; // 任取temp[]中得一个结点
    for(int i = 1; i <= n; ++i) {
        if(visit[i] == false) {
            dfs(i, 1);
            if(i == 1) {
                for(int j = 0; j < temp.size(); ++j) {
                    s.insert(temp[j]);
                    if(j == 0)
                        s1 = temp[j];
                }
            }
            cnt++;
        }
    }
    if(cnt >= 2) { // 如果有多个连通分量，那就输出Error: x components
        printf("Error: %d components", cnt);
    } else { // 如果只有一个连通分量，进行第二次dfs，以上次最远结点为根
        temp.clear();
        max_height = 0;
        fill(visit, visit+10010, false);
        dfs(s1, 1);
        for(int i = 0; i < temp.size(); ++i)
            s.insert(temp[i]);
        for(set<int>::iterator it = s.begin(); it != s.end(); it++)
            printf("%d\n", *it);
    }

    return 0;
}

附原题

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