General thoughts

这题相对来说比较容易，因为不知道每个节点有几个孩子，采用的是next sibling的数据结构。在标记level以及顺便计算每层叶子节点的个数时，用的是list实现的BFS。

Obstacles

应该是input中的每一行输入的ID是乱序的，我尝试过在输入时直接计算level数，结果是部分正确。
另外，当输出结果出现很大的数时，应该首先检查是不是有数组忘了初始化。（而且，我第一次结果正确，后面几次出现这样的情况，使得我一开始没有检查第一次写的代码。后来想来，第一次应该是一块比较新的内存，后来是使用过了？？？）

Source code

经过实践，简书的markdown代码插入功能不理想

1. 不能使用 '''c++ '''，必须缩进4格
2. 没有代码加亮？

#include <cstdio>
#include <cstring>
#include <list>
using namespace std;

struct Node{
    int level;
    int firstChild;
    int nextSibling;
    int numOfChildren;
};
int main() 
{
    int M, N;
    struct Node allNodes[101];  
    memset(allNodes, 0, sizeof(allNodes));
    
    scanf("%d%d",&N,&M);
    
    int tempId;
    int tempFirstSibling, tempNextSibling;
    while(M--){
        scanf("%d", &tempId);
        scanf("%d", &(allNodes[tempId].numOfChildren));
        scanf("%d", &(allNodes[tempId].firstChild));
        
//      if(tempId == 1){
//          allNodes[tempId].level = 0;
//      }
        
//      allNodes[allNodes[tempId].firstChild].level = allNodes[tempId].level + 1;
        
        tempFirstSibling = allNodes[tempId].firstChild;
        for(int i = 0; i < allNodes[tempId].numOfChildren - 1; i++){
            scanf("%d", &tempNextSibling);
            allNodes[tempFirstSibling].nextSibling = tempNextSibling;
//          allNodes[tempNextSibling].level = allNodes[tempFirstSibling].level;         
            tempFirstSibling = tempNextSibling;
        }
    }
    
    allNodes[1].level = 0;
    list<int> nodesToBeLeveled = {1};

    int currentNode;
    int firstSibling, nextSibling;

    int maxLevel = 0;   
    int numOfLeavesEachLevel[101];
    memset(numOfLeavesEachLevel, 0, sizeof(numOfLeavesEachLevel));
    
    while(!nodesToBeLeveled.empty()){
        currentNode = nodesToBeLeveled.front();
        nodesToBeLeveled.pop_front();
        if(allNodes[currentNode].level > maxLevel){
            maxLevel = allNodes[currentNode].level;
        }
        
        if(allNodes[currentNode].numOfChildren == 0){
            numOfLeavesEachLevel[allNodes[currentNode].level]++;
        }
        else{
            firstSibling = allNodes[currentNode].firstChild;
            allNodes[firstSibling].level = allNodes[currentNode].level + 1;
            nodesToBeLeveled.push_back(firstSibling);
    
            for(int i = 0; i < allNodes[currentNode].numOfChildren - 1; i++){
                nextSibling = allNodes[firstSibling].nextSibling;
                allNodes[nextSibling].level = allNodes[firstSibling].level;
                nodesToBeLeveled.push_back(nextSibling);
                firstSibling = nextSibling;
            }           
        }
    }
            
    for(int i=0; i <= maxLevel; i++){
        if(i==0){
            printf("%d",numOfLeavesEachLevel[i]);
        }
        else{
            printf(" %d", numOfLeavesEachLevel[i]);
        }
    }
    
}

Original Problem

A family hierarchy is usually presented by a pedigree tree. Your job is to count those family members who have no child.
Input

Each input file contains one test case. Each case starts with a line containing 0 < N < 100, the number of nodes in a tree, and M (< N), the number of non-leaf nodes. Then M lines follow, each in the format:

ID K ID[1] ID[2] ... ID[K]
where ID is a two-digit number representing a given non-leaf node, K is the number of its children, followed by a sequence of two-digit ID's of its children. For the sake of simplicity, let us fix the root ID to be 01.
Output

For each test case, you are supposed to count those family members who have no child for every seniority level starting from the root. The numbers must be printed in a line, separated by a space, and there must be no extra space at the end of each line.

The sample case represents a tree with only 2 nodes, where 01 is the root and 02 is its only child. Hence on the root 01 level, there is 0 leaf node; and on the next level, there is 1 leaf node. Then we should output "0 1" in a line.

Sample Input
2 1
01 1 02
Sample Output
0 1
http://www.patest.cn/contests/pat-a-practise/1004