PAT1004

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,

每一个输入文件包含一个测试用例，每一个测试用例由一行开始，包含N，

the number of nodes in a tree, and M (< N), the number of non-leaf nodes.

表示数节点的数目，和一个M，表示不是叶子的节点

Then M lines follow, each in the format:

接下来M行，每一行格式是这样的：

ID K ID[1] ID[2] ... ID[K]

where ID is a two-digit number representing a given non-leaf node,

ID是一个两位数表示一个被给出的非叶子节点

K is the number of its children, followed by a sequence of two-digit ID's of its children.

K是它孩子的数量，接下来一个连续的两位数是它孩子的ID

For the sake of simplicity, let us fix the root ID to be 01.

为了让问题简单化，让我们定义跟节点ID为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.

01是根节点，02是它唯一的孩子

Hence on the root 01 level, there is 0 leaf node;

因此对于01所在的等级来说，没有叶子为0的节点。

and on the next level, there is 1 leaf node. Then we should output "0 1" in a line.

然后对于下一个等级来说，有一个叶子的节点，所以在一行中输出“0 1“

Sample Input

2 1
01 1 02

Sample Output

0 1

一开始我看到题目之后的没什么好的思路。

首先我想到的就是我们用什么去存放这棵树，结构体数组链表，肯定可以存放所有完整的关系。

但是当我建完结构体之后我就发现，其实对于这道题目的输出来说，父子的关系并没有那么重要，尤其是这个父亲有那几个孩子，这个信息基本用不到。

然后就是这个节点在这颗树的等级，其实只要知道自己的父亲是谁，自己的父亲等级是多少，那么就能知道自己的等级了。

分析完这几个点之后，下面就是要注意的地方了。

首先我们不能直接在输入的时候就确定等级，因为你输入的时候，虽然你知道你父亲是谁了，但是你不一定知道你父亲的等级是多少，有可能你父亲的等级还没有确定呢。所以我们只能先记录父亲。然后通过后面的循环去把所有的等级更新一遍。

这也导致了这是这道题时间复杂度最高的地方了。因为简单起见我用了结构体数组去存放，这样的存放相比树来说，更新值就比较麻烦了，需要循环每个值去更新。所以时间复杂度就一下到了N^2

如果用树存放的话一定会好很多。

还有可以优化的地方是，可以把最后的求每个等级最后答案的数组的循环放在这个N^2里面，这样还能再快一些。

#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<string.h>

using namespace std;

int result[205];
struct Node
{
    int level;//当前节点所在的等级
    int flag;//0没有孩子，1是有孩子
    int father;//父节点
};

int main()
{
    struct Node nodes[205];
    int n,m,i,j;
    int nowNode,nowNodeNumber,childNode;
    int maxLevel=1;
    cin>>n>>m;

    //初始化
    for (i = 0; i <= n; i++)
    {
        nodes[i].level = 0;
        nodes[i].flag = 0;
        nodes[i].father = 0;
    }
    nodes[1].level = 1;

    //输入并保存关系
    while (m--)
    {
        cin>>nowNode;
        cin>>nowNodeNumber;

        if(nowNodeNumber != 0)
        nodes[nowNode].flag = 1;

        while (nowNodeNumber--)
        {
            cin>>childNode;
            //保存自己的父亲是谁
            nodes[childNode].father = nowNode;
        }
    }
    
    for (i = 1; i <= n; i++)
    {
        for (j = 1; j <= n; j++)
        {
            //如果有一个点的父亲标识是自己，那么它就是你的儿子，那么他的等级，应该是你的等级+1
             if(nodes[j].father == i)
             {
                 nodes[j].level = nodes[i].level + 1;
             }
        }
    }

    //查询每一个等级有多少个没有孩子的点，记录在result数组中
    for (i = 1; i <= n; i++)
    {
        if(nodes[i].flag != 1 && nodes[i].level > 0)
            result[nodes[i].level]++;
        //记录最大的等级，用于最后的输出
        if(nodes[i].level > maxLevel)
            maxLevel = nodes[i].level;
    }
    for (i = 1; i < maxLevel; i++)
    {
        cout<<result[i]<<" ";
    }
    cout<<result[i];
    return 0;  
}