PAT 1004 Counting Leaves

1004 Counting Leaves (30分)#

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

Input Specification:#

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.

The input ends with N being 0. That case must NOT be processed.

Output Specification:#

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

时间限制: 400 ms

内存限制: 64 MB

代码长度限制: 16 KB

思路#

使用邻接表存储孩子节点，使用BFS层序遍历判断是否叶子节点，如果该节点邻接表为空，说明是该节点是叶子节点；否则，将其所有孩子节点入队。

 

 

 

#include <iostream>
#include <stdio.h>
#include <vector>
#include <queue>
#include <string.h>

using namespace std;

struct Node
{
    int val;
    int level = 0;
};

int cnt[110];    //cnt[i]表示第i层的叶子节点数 
int totalLevel;

int main()
{
    int n, m, k;
    while(scanf("%d", &n) != EOF)
    {
        if(n == 0)
            break;
        
        vector<Node> adjList[110];  //邻接表
        queue<Node> Q;
        memset(cnt, 0, sizeof(cnt));
        
        scanf("%d", &m);
        
        if(n == 1)
        {
            //只有1个节点，直接输出1 
            cout << 1;
            continue;
        }
        for(int i = 0; i < m; ++i)
        {
            Node id;
            int k;
            scanf("%d%d", &id.val, &k);
            if(id.val == 01)
                Q.push(id);    //根节点入队 
            for(int i = 1; i <= k; ++i)
            {
                Node child;
                scanf("%d", &child.val);
                //建立邻接表 
                adjList[id.val].push_back(child);
            }
        } 
        
        //层序遍历，BFS 
        while(!Q.empty())
        {
            Node p = Q.front();
            Q.pop();
            
            //存储最后的总层数，方便最后输出结果 
            totalLevel = p.level;
            
            if(adjList[p.val].empty())
            {
                cnt[p.level]++; //当前层的叶子节点数加一 
            }
            else
            {
                //遍历孩子节点 
                for(int i = 0; i < adjList[p.val].size(); ++i)
                {
                    adjList[p.val][i].level = p.level + 1;
                    Q.push(adjList[p.val][i]); 
                }
            } 
        } 
        
        for(int i = 0; i <= totalLevel; ++i)
        {
            if(i == totalLevel)
                cout <<  cnt[i];
            else
                cout <<  cnt[i] << ' ';
        }
        
    }    

    return 0;
}