PAT甲级刷题记录——1094 The Largest Generation (25分)_a family hierarchy is usually presented by a pedig

A family hierarchy is usually presented by a pedigree tree where all the nodes on the same level belong to the same generation. Your task is to find the generation with the largest population.

Input Specification:

Each input file contains one test case. Each case starts with two positive integers N (<100) which is the total number of family members in the tree (and hence assume that all the members are numbered from 01 to N), and M (<N) which is the number of family members who have children. Then M lines follow, each contains the information of a family member in the following format:

ID K ID[1] ID[2] ... ID[K]
1

where IDis a two-digit number representing a family member, K(>0) is the number of his/her children, followed by a sequence of two-digit ID's of his/her children. For the sake of simplicity, let us fix the root IDto be 01. All the numbers in a line are separated by a space.

Output Specification:

For each test case, print in one line the largest population number and the level of the corresponding generation. It is assumed that such a generation is unique, and the root level is defined to be 1.

Sample Input:

23 13
21 1 23
01 4 03 02 04 05
03 3 06 07 08
06 2 12 13
13 1 21
08 2 15 16
02 2 09 10
11 2 19 20
17 1 22
05 1 11
07 1 14
09 1 17
10 1 18
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Sample Output:

9 4
1

思路

这题的题目大意是让你求哪一层的结点最多（也就是所谓人数最多的那一代），结果输出的9是结点数，4是那一层的结点所在的层数（根结点是1，所在层数是1）。

这题思路很简单，直接用静态树存好以后一次BFS就能得到结果了，这里我用了int数组来存放相应层数的结点个数（下标是层数，其值是结点个数），因此，每次取队首元素的时候，就直接在当前层（top.level）++就好了，然后为了缩小最后遍历的范围（因为BFS结束之后，能得到各个层数所对应的结点个数，我们还需要找出最大值，并且输出它的下标），我还用了一个maxLevel来记录这棵树的最深层次，这样，在寻找数组最大值和其下标的时候，就只要从1遍历到maxLevel即可（不过我一开始用vector来存储对应层次的结点编号，不知道为啥出错了，一直弄不好，然后就干脆改用int型数组了……反正这题也不问每一层对应的结点编号是多少……）。

代码

#include<cstdio>
#include<stdlib.h>
#include<algorithm>
#include<vector>
#include<queue>
#include<string>
#include<string.h>
#include<iostream>
using namespace std;
const int maxn = 110;
vector<int> Node[maxn];
int PopulationOf[maxn];//对应层数的人数
int maxLevel = -1;//记录最大层数
int maxSize = -1;//记录最大的人数
int mostPeopleLevel = -1;//记录最大人数所在的层数
struct node{
    int id;
    int level;
};
void bfs(){
    queue<node> q;
    node root;
    root.id = 1;
    root.level = 1;
    q.push(root);
    while(!q.empty()){
        node top = q.front();
        q.pop();
        PopulationOf[top.level]++;
        if(top.level>maxLevel) maxLevel = top.level;
        for(int i=0;i<Node[top.id].size();i++){
            int v = Node[top.id][i];
            node child;
            child.id = v;
            child.level = top.level + 1;
            q.push(child);
        }
    }
}
int main(){
    int N, M;
    scanf("%d%d", &N, &M);
    for(int i=0;i<M;i++){
        int ID, K;
        scanf("%d%d", &ID, &K);
        for(int j=0;j<K;j++){
            int tmpid;
            scanf("%d", &tmpid);
            Node[ID].push_back(tmpid);
        }
    }
    bfs();
    for(int i=1;i<=maxLevel;i++){
        if(PopulationOf[i]>maxSize){
            maxSize = PopulationOf[i];
            mostPeopleLevel = i;
        }
    }
    printf("%d %d", maxSize, mostPeopleLevel);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61