PAT A1094 The Largest Generation (25 分)

• 题目
  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]

where ID is 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 ID to 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.

• 题目大意
  给出家庭树，求人数最多的树的层次，以及此层有多少人
• 代码实现

DFS
先序遍历，并将每层的节点存入对应层次的数组中，最后只用比较哪个数组中的节点个数最多即可。

#include <cstdio>
#include <vector>
using namespace std;
const int MAX = 101;
struct Node{
    vector<int> child;
}node[MAX];
vector<int> vec[MAX];
int max_depth = 0;
void DFS(int depth, int index){
    vec[depth].push_back(index);
    if(depth > max_depth)               //记录最大深度
        max_depth = depth;
    for(int i = 0; i < node[index].child.size(); i++)
        DFS(depth + 1, node[index].child[i]);
    return;
}
int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    for(int i = 0; i < m; i++){
        int father, num;
        scanf("%d%d", &father, &num);
        for(int j = 0; j < num; j++){
            int child;
            scanf("%d", &child);
            node[father].child.push_back(child);
        }
    }
    DFS(1, 1);
    int res1 = 0, res2;
    for(int i = 1; i <= max_depth; i++){
        if(vec[i].size() > res1){
            res1 = vec[i].size();
            res2 = i;
        }
    }
    printf("%d %d", res1, res2);
    return 0;
}

BFS
层次遍历，将每个节点赋予相应的层次，并将其加入相应层次的数组中，最后只用比较哪个数组中节点数目较多即可

#include <cstdio>
#include <queue>
#include <vector>
using namespace std;
const int MAX = 101;
struct Node{
    vector<int> child;
    int level;
}node[MAX];
vector<int> vec[MAX];
void BFS(int root)
{
    queue<int> qu;            //辅助队列
    qu.push(root);             //根节点入队
    node[root].level = 1;   //设置根节点的层次
    while(!qu.empty()){
        int top = qu.front();
        qu.pop();
        vec[node[top].level].push_back(top);         //每层节点压入对应的层次
        for(int i = 0; i < node[top].child.size(); i++){
            node[node[top].child[i]].level = node[top].level + 1;          //更新每层节点的层次
            qu.push(node[top].child[i]);
        }
    }
}
int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    for(int i = 0; i < m; i++){
        int father, num;
        scanf("%d%d", &father, &num);
        for(int j = 0; j < num; j++){
            int child;
            scanf("%d", &child);
            node[father].child.push_back(child);
        }
    }
    BFS(1);
    int res1 = 0, res2;
    for(int i = 1; i <MAX; i++){
        if(vec[i].size() > res1){
            res1 = vec[i].size();
            res2 = i;
        }
    }
    printf("%d %d", res1, res2);
    return 0;
}