PAT 1021

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

首先说说算法的思路：先用并查集判断树是否是联通；然后任选一个结点做bfs，则得到最低层的叶结点一定是Deepest Root，接下去在从已选出的Deepest Root中任选一点，在做一次dfs，然后在
将最底层的叶结点加入Deepest Root。此题在时间和空间上都有限制，如果暴力解决的话会超时，如果用邻接矩阵存树的话会超内存，所以采用链表存树。
代码

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>

 #define NUM 10001
 typedef struct linkNode{
     int a;
     linkNode *next;
 }linkNode;

 linkNode *map[NUM];
 int unionSet[NUM];
 int level[NUM];
 int queue[NUM];
 int deepestRoot[NUM];

 int findRoot(int);
 int bfs(int);
 void destroyMap(int);

 int main()
 {
     int N,i;
     int s,e;
     int k;
     linkNode *p;
     while(scanf("%d",&N) != EOF){
         memset(unionSet,,sizeof(unionSet));
         memset(map,,sizeof(map));
         k = ;
         for(i=;i<N;++i){
             scanf("%d%d",&s,&e);
             int sR = findRoot(s);
             int eR = findRoot(e);
             if(sR != eR){
                 unionSet[sR] = eR;
                 ++k;
                 p = (linkNode*) malloc(sizeof(linkNode));
                 p->a = e;
                 p->next = NULL;
                 if(map[s]){
                     p->next = map[s];
                     map[s] = p;
                 }
                 else
                     map[s] = p;
                 p = (linkNode*) malloc(sizeof(linkNode));
                 p->a = s;
                 p->next = NULL;
                 if(map[e]){
                     p->next = map[e];
                     map[e] = p;
                 }
                 else
                     map[e] = p;
             }
         }
         if(k < N - ){
             printf("Error: %d components\n",N-k);
             destroyMap(N);
             continue;
         }
         memset(deepestRoot,,sizeof(deepestRoot));
         int maxLevel = bfs();
         int maxLevel_i;
         for(i=;i<=N;++i){
             if(level[i] == maxLevel){
                 deepestRoot[i] = ;
                 maxLevel_i = i;
             }
         }
         maxLevel = bfs(maxLevel_i);
         for(i=;i<=N;++i){
             if(level[i] == maxLevel)
                 deepestRoot[i] = ;
         }
         for(i=;i<=N;++i){
             if(deepestRoot[i])
                 printf("%d\n",i);
         }
         destroyMap(N);
     }
     return ;
 }

 int findRoot(int s)
 {
     while(unionSet[s])
         s = unionSet[s];
     return s;
 }

 int bfs(int s)
 {
     memset(level,-,sizeof(level));
     int base = ,top = ;
     int levelNum = ,endLevel = ;
     int t,i;
     linkNode *p;
     queue[top++] = s;
     while(top > base){
         t = queue[base++];
         level[t] = levelNum;
         p = map[t];
         while(p){
             if(level[p->a] == -){
                 queue[top++] = p->a;
             }
             p = p->next;
         }
         if(endLevel == base){
             endLevel = top;
             ++levelNum;
         }
     }
     return levelNum - ;
 }

 void destroyMap(int n)
 {
     linkNode *p,*q;
     int i;
     for(i=;i<=n;++i){
         p = map[i];
         while(p){
             q = p->next;
             free(p);
             p = q;
         }
     }
 }