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,0,sizeof(unionSet));
        memset(map,0,sizeof(map));
        k = 0;
        for(i=1;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 - 1){
            printf("Error: %d components
",N-k);
            destroyMap(N);
            continue;
        }
        memset(deepestRoot,0,sizeof(deepestRoot));
        int maxLevel = bfs(1);
        int maxLevel_i;
        for(i=1;i<=N;++i){
            if(level[i] == maxLevel){
                deepestRoot[i] = 1;
                maxLevel_i = i;
            }
        }
        maxLevel = bfs(maxLevel_i);
        for(i=1;i<=N;++i){
            if(level[i] == maxLevel)
                deepestRoot[i] = 1;
        }
        for(i=1;i<=N;++i){
            if(deepestRoot[i])
                printf("%d
",i);
        }
        destroyMap(N);
    }
    return 0;
}

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


int bfs(int s)
{
    memset(level,-1,sizeof(level));
    int base = 0,top = 0;
    int levelNum = 1,endLevel = 1;
    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] == -1){
                queue[top++] = p->a;
            }
            p = p->next;
        }
        if(endLevel == base){
            endLevel = top;
            ++levelNum;
        }
    }
    return levelNum - 1;
}

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