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

解题基本思路：用DFS获取独立子图的个数；用DFS获取每个节点到相应的叶节点的距离，这样就可以找出deepest root path；用一个for语句找出每个的deepest root path 然后排下序就ok了

注意：开始自己用邻接矩阵的数据结构，最后的一个测试点通不过的，内存超限。只能用邻接表的数据结构来实现 用vector！！

参考代码：

#include <iostream>
#include <string.h>
#include <vector>
using namespace std;
vector<vector<int> > roads;
int visited[10001];     //定义节点是否被访问
int N;
int countL = 0;         //统计独立子图的个数
int maxDeep = 0;        //记录每个节点的每条路径的最大深度
int tempIndex[10001];   //每个节点到各个叶子节点的深度记录数组
int record[10001];      //每个节点的最大深度数组
int flag = 0;
int pre = 0;            //当前节点的前一个节点 此处用来判断是否到叶节点的标记
void DFS(int d){        //用DFS统计独立子图个数
    countL++;
    visited[d] = 1;
    for(int i=0;i<roads[d].size();i++){
        if(!visited[roads[d][i]]){
            DFS(roads[d][i]);
        }
    }
}
void deepRoot(int d){   //用DFS统计每个节点到它们的叶节点的路径长度
    maxDeep++;
    visited[d] = 1;
    if(roads[d].size()==1 && pre!=0){   //is leaf
        tempIndex[flag++] = maxDeep;
    }else{
        for(int i=0;i<roads[d].size();i++){
            if(!visited[roads[d][i]]){
                pre = d;
                deepRoot(roads[d][i]);
            }
        }
    }
    maxDeep--;
}
int main()
{
    cin>>N;
    roads.assign(N+1, vector<int>());
    for(int i=0;i<N-1;i++){
        int a,b;
        cin>>a>>b;
        roads[a].push_back(b);
        roads[b].push_back(a);
    }
    DFS(1);
    if(countL<N){   //have more than one components
        memset(visited,0,sizeof(visited));
        int components = 0;
        for(int i=1;i<=N;i++){
            if(!visited[i]){
                DFS(i);
                components++;
            }
        }
        cout<<"Error: "<<components<<" components";
    }else{
        for(int i=1;i<=N;i++){
            flag = 0;
            maxDeep = 0;
            memset(visited,0,sizeof(visited));
            memset(tempIndex,0,sizeof(tempIndex));
            pre = 0;
            deepRoot(i);
            int maxL = tempIndex[0];
            for(int j=0;j<N;j++){
                if(tempIndex[j]>=maxL){
                    maxL = tempIndex[j];
                    record[i-1] = maxL;
                }
            }
        }
        int endMax = record[0];
        for(int i=0;i<N;i++){   //find the max deep value
            if(record[i]>=endMax){
                endMax = record[i];
            }
        }
        for(int i=0;i<N;i++){
            if(record[i]==endMax){
                cout<<i+1<<endl;
            }
        }
    }
    return 0;
}