1004 Counting Leaves (30 分,附详细注释，逻辑分析)

写在前面

• 实现思路
  • 深度有点遍历（BFS）
  • vector容器封装树孩子节点
  • 递归更新每一层叶子节点个数、树的最大深度
  • 前提条件
    • For the sake of simplicity, let us fix the root ID to be 01.
• 知识盲点，学习ing，熟练耗时30分钟进军100分

测试用例

input:
2 1
01 1 02
output:
0 1
input:
1 0
output:
1

ac代码

#include
#include 
#include 
using namespace std;

const int N = 110;
vector<int> G[N];
int leaf[N] = {0};
int max_h = 1;

void DFS(int inx, int h)
{
    max_h = max(h, max_h);
    if(G[inx].size()==0)
    {
        leaf[h]++;
        return;
    }
    for(int i=0; i<G[inx].size(); i++) DFS(G[inx][i], h+1);
}
int main()
{
    int n, m, parent, child, k;
    scanf("%d%d", &n, &m);
    for(int i=0; i<m; i++)
    {
        scanf("%d%d", &parent, &k);
        for(int j=0; j<k; j++)
        {
            scanf("%d", &child);
            G[parent].push_back(child);
        }
    }

    DFS(1,1);
    printf("%d", leaf[1]);
    for(int i=2; i<=max_h; i++) printf(" %d", leaf[i]);

    return 0;
}

学习代码

• 思想类似，不再赘述

#include 
#include 
#include 
using namespace std;
vector<int> v[100];
int book[100], maxdepth = -1;
void dfs(int index, int depth) {
    if(v[index].size() == 0) {
        book[depth]++;
        maxdepth = max(maxdepth, depth);
        return ;
    }
    for(int i = 0; i < v[index].size(); i++)
        dfs(v[index][i], depth + 1);
}
int main() {
    int n, m, k, node, c;
    scanf("%d %d", &n, &m);
    for(int i = 0; i < m; i++) {
        scanf("%d %d",&node, &k);
        for(int j = 0; j < k; j++) {
            scanf("%d", &c);
            v[node].push_back(c);
        }
    }
    dfs(1, 0);
    printf("%d", book[0]);
    for(int i = 1; i <= maxdepth; i++)
        printf(" %d", book[i]);
    return 0;
}

广度优先搜索(BFS)实现

• 注意事项
  • queue队列中存放原元素副本
  • 将元素压入栈后，修改原元素的值，队列中元素值不会改变

#include
#include
#include

using namespace std;

const int N = 105;
vector<int> G[N];
int h[N] = {0};
int leaf[N] = {0};
int max_h = 0;

void BFS()
{
    queue<int> Q;
    Q.push(1);
    while(!Q.empty())
    {
        int id = Q.front();
        Q.pop();
        max_h = max(max_h, h[id]);
        if(G[id].size()==0)
            leaf[h[id]]++;
        for(int i=0; i<G[id].size(); i++)
        {
            h[G[id][i]] = h[id] + 1;
            Q.push(G[id][i]);
        }
    }
}

int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    for(int i=0; i<m; i++)
    {
        int parent, k, child;
        scanf("%d%d", &parent, &k);
        for(int j=0; j<k; j++)
        {
            scanf("%d", &child);
            G[parent].push_back(child);
        }
    }
    h[1] = 1;
    BFS();
    for(int i=1; i<=max_h; i++)
    {
        if(i==1) printf("%d", leaf[i]);
        else printf(" %d", leaf[i]);
    }
}