PAT Advanced 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, the number of nodes in a tree, and$

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

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

这道题目，考察树的dfs

　 2 3

4 5 6 7

这题测试用例太少，我出了一个测试用例，树如上

输入：

8 4

01 2 02 03

02 2 04 05

03 2 06 07

04 1 08

输出：

0 0 3 1

翻译：读入这棵树一共多少节点，多少叶子节点（注意：树不是满二叉树）。之后每行进行读入父节点、孩子个数、孩子

思路：可以通过用unordered_map存储，父亲id，孩子。

之后找到树根，用遍历，看看哪个节点没有当儿子。

之后用dfs，进行深度遍历，如果树的当前节点没有孩子，则是树叶，进行计数+1（我这边是m_depth_coun存储）

最后进行打印

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;
unordered_map<int,vector<int>> m;
unordered_map<int,bool> m_exist;
vector<int> m_depth_coun(1000,0);
int max_depth=0;
void dfs(int root,int depth){
    if(m[root].size()==0) m_depth_coun[depth]++;
    for(auto x:m[root]) dfs(x,depth+1);
    if(depth>max_depth) max_depth=depth;
}
int main(){
    int node_num,parent_num;
    cin>>node_num>>parent_num;
    int pid,N,tmp;
    while(parent_num--){
        cin>>pid>>N;
        m_exist[pid];// 激活一下pid,默认为false,如果为true,也不会有影响
        while(N--){
            cin>>tmp;
            m_exist[tmp]=true;
            m[pid].push_back(tmp);
        }
    }
    // find parent
    int parent_node_id;
    for(auto it=m_exist.begin();it!=m_exist.end();it++)
        if(it->second==false) parent_node_id=it->first;
    // 从父亲开始dfs
    dfs(parent_node_id,0);
    // 进行计数
    for(int i=0;i<=max_depth;i++)
        if(i!=max_depth) cout<<m_depth_coun[i]<<" ";
        else cout<<m_depth_coun[i];
    system("pause");
    return 0;
}