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 (≤) 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

题目分析：最开始我理解错题意了 我认为给的连通图会有回路 但实际上是没有的 

有回路的应该是不连通的 

还要注意 用数组存会使空间过大 用vector<vector<int> >比较好

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<vector>
#include<queue>
#include<stack>
#include<algorithm>
using namespace std;
int Highest = -1;
vector<vector<int> >G;
int Dist[10001];
int Collected[10001];
int N;
int Components = 1;
vector<int> V;
void dfs(int v)
{
    Collected[v] = 1;
    for (int i = 0; i < G[v].size(); i++)
    {
        if (!Collected[G[v][i]])
        {
            Dist[G[v][i]] = Dist[v] + 1;
            dfs(G[v][i]);
        }
    }
}
int main()
{
    cin >> N;
    G.resize(N + 1);
    for (int i = 1; i < N; i++)
    {
        int v1, v2;
        cin >> v1 >> v2;
        G[v1].push_back(v2);
        G[v2].push_back(v1);
    }
    int i = 1;
    for (; i <= N; i++)
    {
        fill(Dist, Dist + N + 1, 0);
        fill(Collected, Collected + N + 1, 0);
        dfs(i);
        for (int j = 1; j <= N; j++)
        {
            if (!Collected[j])
            {
                dfs(j);
                Components++;
            }
        }
        if (Components != 1)
            break;
        int Max = -65535;
        for (int i = 1; i <= N; i++)
            if (Max < Dist[i])
                Max = Dist[i];
        if (Max > Highest)
        {
            Highest = Max;
            V.clear();
            V.push_back(i);
        }
        else if (Max == Highest)
            V.push_back(i);
    }
    if (Components == 1)
    {
        for (int i = 0; i < V.size() - 1; i++)
            printf("%d
", V[i]);
        printf("%d", V[V.size() - 1]);
    }
    else
        printf("Error: %d components", Components);
    return 0;
}