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

C：

/*
 @Date    : 2017-11-27 11:12:35
 @Author  : 酸饺子 (changzheng300@foxmail.com)
 @Link    : https://github.com/SourDumplings
 @Version : $Id$
*/

/*
https://www.patest.cn/contests/pat-a-practise/1004
 */

#include <stdio.h>
#include <stdlib.h>

#define MAXN 100

typedef struct TREENODE *Tree;
struct TREENODE
{
    Tree children[MAXN+1];
    int isleaf;
};

int N, M;
Tree T[MAXN+1];
int leaves[MAXN];

void LevelOrderTraversal(int root, int level)
{
    int i;
    if (leaves[level] == -1)
    {
        leaves[level] = 0;
    }
    if (T[root]->isleaf)
    {
        leaves[level]++;
        return;
    }
    for (i = 1; i <= N; i++)
    {
        if (T[root]->children[i])
        {
            LevelOrderTraversal(i, level+1);
        }
    }
}

int main()
{
    scanf("%d %d", &N, &M);

    int i, K, j, id, id_c;
    char ID[3];
    for (i = 0; i <= N; i++)
    {
        T[i] = (Tree)malloc(sizeof(struct TREENODE));
        T[i]->isleaf = 1;
        for (j = 0; j <= N; j++)
        {
            T[i]->children[j] = NULL;
        }
        leaves[i] = -1;
    }

    for (i = 0; i < M; i++)
    {
        scanf("%s %d", ID, &K);
        id = atoi(ID);
        T[id]->isleaf = 0;
        for (j = 0; j < K; j++)
        {
            scanf("%s", ID);
            id_c = atoi(ID);
            T[id]->children[id_c] = T[id_c];
        }
    }

    LevelOrderTraversal(1, 0);

    int output = 0;
    for (i = 0; i < N && leaves[i] != -1; i++)
    {
        if (output++)
        {
            putchar(' ');
        }
        printf("%d", leaves[i]);
    }
    putchar('\n');

    return 0;
}

C++：

/*
 @Date    : 2018-03-17 11:09:21
 @Author  : 酸饺子 (changzheng300@foxmail.com)
 @Link    : https://github.com/SourDumplings
 @Version : $Id$
*/

/*
https://www.patest.cn/contests/pat-a-practise/1004
 */

#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>

using namespace std;

struct Node
{
    int level = 0;
    vector<int> children;
};

static const int MAXN = 100;
static Node data[MAXN];
static int N, M;

static vector<int> res;

void BFS(int r)
{
    queue<int> Q;
    data[r].level = 0;
    Q.push(r);
    int nowLevel = 0;
    int nowLevelNum = 0;
    while (!Q.empty())
    {
        int p = Q.front(); Q.pop();
        if (data[p].level > nowLevel)
        {
            res.push_back(nowLevelNum);
            nowLevelNum = 0;
            nowLevel = data[p].level;
        }
        if (data[p].children.empty())
        {
            ++nowLevelNum;
        }
        else
        {
            for (auto &c : data[p].children)
            {
                data[c].level = data[p].level + 1;
                Q.push(c);
            }
        }
    }
    res.push_back(nowLevelNum);
    return;
}

int main(int argc, char const *argv[])
{
    scanf("%d %d", &N, &M);
    for (unsigned i = 0; i < M; ++i)
    {
        int id, K;
        scanf("%d %d", &id, &K);
        for (unsigned j = 0; j < K; ++j)
        {
            int c;
            scanf("%d", &c);
            data[id].children.push_back(c);
        }
    }
    BFS(1);
    int output = 0;
    for (auto &i : res)
    {
        if (output++)
        {
            putchar(' ');
        }
        printf("%d", i);
    }
    putchar('\n');
    return 0;
}