PAT1094 多叉树

1094 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.

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  

Sample Output:

9 4

题目大意：

家谱图一般都是树状结构，从上到下都是祖先到孩子的结构，现在给我一个家谱数，问我们哪一代的人最多，最多是多少。输入的第一行是 整个家族有多少人 、多少人有孩子（这里的孩子指的是直系下一代） 后面的每一行数据表示的是；父亲节点ID 孩子个数 n 孩子id1 孩子id2 … 孩子idn

思路分析：

同样是，我们用对象Node数组进行数的结构的存储，以 数组的下标表示节点的ID ，每一个Node 节点存储一个List列表，用户存放孩子的ID ，然后对这棵树进行 广度优先遍历。遍历的方式和 题号1090中的BFS 几乎是一样的。也就是我们把当前层的所有节点在一个循环中出队，同时把他们的孩子入队，这样下一次循环，队列中存储的全部都是下一层的节点。

完整代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

//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
public class Main  {
    static class Node {
        List<Integer> children = new ArrayList<>();
    }

    static Node[] nodes;
    static int maxSize = 0;
    static int maxSizeLevel = 0;

    public static void main(String[] args) throws IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        String[] info = bf.readLine().split(" ");
        int peopleNum = Integer.parseInt(info[0]);
        int hasChild = Integer.parseInt(info[1]);
        nodes = new Node[peopleNum + 1]; // 里面的对象默认初始化都是null
        for (int i = 1; i <= peopleNum; i++) // 从1 开始初始化所有节点，以为节点编号是从1--N
            nodes[i] = new Node();

		// 读取数据，进行树的创建
        for (int i = 0; i < hasChild; i++) {
            String[] dataInfo = bf.readLine().split(" ");
            int parent = Integer.parseInt(dataInfo[0]); //第一个数子表示父亲ID
            int nums = Integer.parseInt(dataInfo[1]);//第二个数子表示孩子的个数

            for (int j = 1; j <= nums; j++) { //剩下的都是孩子的ID
                nodes[parent].children.add(Integer.parseInt(dataInfo[j + 1])); // 孩子信息都是从一行数据的下标2开始的
            }
        }
        BFS(1);// 题目指明根节点的ID=1
        System.out.printf("%d %d" ,maxSize , maxSizeLevel);

    }
	// 具体的求解过程
    static void BFS(int root) {
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(root);
        int depth = 1;
        while (!queue.isEmpty()) {
            int size = queue.size();
            if (size > maxSize) { // maxSize 存储节点最多层的节点数
                maxSize = size;
                maxSizeLevel = depth;
            }
            while (size != 0) { 

                int node = queue.poll();
                int childrenNum = nodes[node].children.size();
                for (int i = 0; i < childrenNum; i++) {
                    queue.offer(nodes[node].children.get(i));// 孩子节点入队
                }
                size--;
            }

            depth++;
        }
    }
}