1021. Deepest Root (25)

最新推荐文章于 2020-04-05 11:40:11 发布

原创最新推荐文章于 2020-04-05 11:40:11 发布 · 497 阅读

0 ·

CC 4.0 BY-SA版权

PAT 专栏收录该内容

79 篇文章

订阅专栏

给定一个连通且无环的图，将其视为一棵树。任务是找到使得树高度最大的根节点，这样的根节点称为最深根。输入包含一个测试案例，首先给出节点数量N（<=10000），接着N-1行描述每条边连接的节点。若图不是一棵树，输出错误信息并附上连通组件的数量。解题思路包括使用DFS计算连通子图和最深根路径，使用邻接表（vector）降低内存消耗。

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:

Sample Output 1:

3
4
5

Sample Input 2:

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;
}