時間限制: 2000 ms    記憶體限制: 64 MB    程式碼長度限制: 16 KB

A graph which is connected and acyclic can be considered a tree. The hight 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

 題目大意：

acyclic 無環的；非迴圈的。

非迴圈的圖可以看做樹，樹的高度取決於所選擇的根節點。現給你一棵樹，找出有最高高度的根節點。

輸入樣例第一行給出節點個數N，隨後N-1行給出邊（因為是非迴圈）。（N<=10000）

輸出樣例，輸出具有最深高度的根節點，如果不唯一按數字從小到大輸出；如果給出圖不是單一連通集，輸出“Error: K components”，其中K是連通集個數。

題目分析：

求深度，想到深度優先搜尋。把把每一個點當做起點遍歷一遍，找到最大的那個點和他的高度。

最大點的表示：用vector<Node>的形式表示出來，一個一個新增，最後排序並輸出。

如果遍歷結束所涉及節點個數小於總個數，則找出有幾個連通集。

重要部分：

注意事項：

完整程式碼：

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>

using namespace std;

struct Node{
    int data;
    int height;
};

const int maxn = 10010;
vector<int> Adj[maxn];   //圖的鄰接表
vector<Node> H;         //表示樹高的陣列
bool vis[maxn]={false};
int N;//節點個數
int depth, numConnect, deepest=0;//每次計算的高度和連通集內節點個數

void DFS(int u, int d){//節點，深度
    numConnect++;//記錄連線點個數增加
    vis[u]=true;
    for(int i=0; i<Adj[u].size(); i++){//第一維從1開始，第二維從0開始
        int v = Adj[u][i];
        if(vis[v]==false){
            DFS(v,d+1);
        }
        deepest = deepest>d?deepest:d;
    }
}
//傳統遍歷求連通集個數，返回負值
int DFSReal(){
    memset(vis,false,sizeof(vis));
    int numCircle=0;
    for(int i=1; i<N; i++){
        if(vis[i]==false){
            DFS(i,1);
            numCircle++;
        }
    }
    return -numCircle;
}
//以u為起點，輸出以u為根的高度，如果不連通輸出負值表示連通集個數
int DFSTraversal(int u){
    //初始化
    numConnect=0;
    deepest=0;
    memset(vis, false, sizeof(vis));
    //求樹高
    DFS(u,1);
    if(numConnect<N){
        return DFSReal();
    }
    return deepest;
}

bool comp(Node a, Node b){
    if(a.height!=b.height) return a.height>b.height;
    else return a.data<b.data;
}

int main()
{
    int e1,e2;
    cin>>N;
    for(int i=1; i<N; i++){
        Node tmp1,tmp2;
        cin>>e1>>e2;
        Adj[e1].push_back(e2);
        Adj[e2].push_back(e1);
    }
    //processing
    Node c;
    for(int i=1; i<=N; i++){
        c.data=i;
        c.height=DFSTraversal(i);
        if(c.height<0){//不連通，結束，輸出
            cout<<"Error: "<<-c.height<<" components"<<endl;
            return 0;
        }
        H.push_back(c);
    }
    //sorting
    sort(H.begin(), H.end(), comp);
    //outputing
    for(int i=0; i<N && H[i].height==H[0].height; i++){
        cout<<H[i].data<<endl;
    }
    return 0;
}