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 = -;
 vector<vector<int> >G;
 int Dist[];
 int Collected[];
 int N;
 int Components = ;
 vector<int> V;
 void dfs(int v)
 {
     Collected[v] = ;
     for (int i = ; i < G[v].size(); i++)
     {
         if (!Collected[G[v][i]])
         {
             Dist[G[v][i]] = Dist[v] + ;
             dfs(G[v][i]);
         }
     }
 }
 int main()
 {
     cin >> N;
     G.resize(N + );
     for (int i = ; i < N; i++)
     {
         int v1, v2;
         cin >> v1 >> v2;
         G[v1].push_back(v2);
         G[v2].push_back(v1);
     }
     int i = ;
     for (; i <= N; i++)
     {
         fill(Dist, Dist + N + , );
         fill(Collected, Collected + N + , );
         dfs(i);
         for (int j = ; j <= N; j++)
         {
             if (!Collected[j])
             {
                 dfs(j);
                 Components++;
             }
         }
         if (Components != )
             break;
         int Max = -;
         for (int i = ; 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 == )
     {
         for (int i = ; i < V.size() - ; i++)
             printf("%d\n", V[i]);
         printf("%d", V[V.size() - ]);
     }
     else
         printf("Error: %d components", Components);
     return ;
 }