[PAT-甲级]1004.Counting Leaves

最新推荐文章于 2022-09-20 20:36:50 发布

caicaiatnbu

最新推荐文章于 2022-09-20 20:36:50 发布

阅读量1.8k

点赞数

本文链接：https://blog.csdn.net/caicaiatnbu/article/details/74910474

版权

PAT甲集专栏收录该内容

25 篇文章 0 订阅

订阅专栏

1004. Counting Leaves (30)

时间限制

400 ms

内存限制

65536 kB

代码长度限制

16000 B

判题程序

Standard

作者

CHEN, Yue

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, 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.

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. 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

解题思路：题意让我们求一颗树，每一层的叶子节点个数。主要在于计算每一个节点所处在层次，并且要计算处整颗树的最大深度maxDepth，毕竟要打印每一层的叶子节点个数。下面提供了三种解法，分别是递归，DFS，BFS。具体见代码，都附上了详细的解释。

如果写得太详细，分析每一个细节需要时间开销太大了，所以以后我尽量用多种方法来解决某个具体问题。详细解释都留给LeetCode解题报告，欢迎大家提出宝贵的建议。

递归解法：

#include<stdio.h>

struct Node
{
	int parent;
	int level;
	bool has_child;	
}node[110];

// maxDepth保存树的最大深度 
int maxDepth;
// leaf数组保存每一层叶子节点的个数 
int leaf[110];

// 递归找到第i个节点所在层次 
int findLevel(int i)
{
	if(node[node[i].parent].level == 0)
		return node[i].level = findLevel(node[i].parent) + 1;
	else
		return node[i].level = node[node[i].parent].level + 1;
}

int main()
{
	int n, m;
	scanf("%d%d", &n, &m);
	// 初始化node结构数组 
	for(int i = 1; i <= n; i ++)
	{
		node[i].parent = 0;
		node[i].level = 0;
		node[i].has_child = false;
		leaf[i] = 0;
	}
	
	// 读入数据 
	for(int i = 1; i <= m; i ++)
	{
		int k, parent, child;
		scanf("%d%d", &parent, &k);
		node[parent].has_child = true;
		for(int j = 1; j <= k; j ++)
		{
			scanf("%d", &child);
			node[child].parent = parent;
		}
	}
	
	// 计算每一个节点所在的层次 
	node[1].level = 1;
	for(int i = 2; i <= n; i ++)
		findLevel(i);
	
	// 计算整棵树的最大深度	
	for(int i = 1; i <= n; i ++)
	{
		if(maxDepth < node[i].level)
			maxDepth = node[i].level;
	}
	
	// 计算每一层没有孩子节点的节点个数 
	for(int i = 1; i <= n; i ++)
	{
		if(node[i].has_child == false)
			leaf[node[i].level] ++;
	}
	
	// 格式化输出结果 
	for(int i = 1; i <= maxDepth; i ++)
	{
		if(i == maxDepth)
			printf("%d", leaf[i]);
		else
			printf("%d ", leaf[i]);
	}
	
	return 0;
}

DFS代码如下：

#include<stdio.h>
#include<vector>
#include<algorithm>
using namespace std;

// node保存节点信息，node[i]中保存的是节点i的孩子节点 
vector<int> node[110];
// leaf保存的是每一层叶子节点的个数 
int leaf[110] = {0};
// 保存最大深度 
int maxDepth = 0;

// index 为当前遍历到的节点编号
// depth 为当期的深度 
void DFS(int index, int depth)
{
	maxDepth = max(maxDepth, depth);
	
	// 如果改节点是叶子节点 
	if(node[index].size() == 0)
	{
		leaf[depth] ++;
		return ;
  	}
	
	// 枚举节点i所有的孩子节点 
  	for(int i = 0; i < node[index].size(); i ++)
    	DFS(node[index][i], depth+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);
      		node[parent].push_back(child);
    	}
  	}

  	DFS(1, 1);
  	for(int i = 1; i <= maxDepth; i ++)
  	{
    	if(i == maxDepth)
      		printf("%d", leaf[i]);
    	else
      		printf("%d ", leaf[i]);
    }
  	return 0;
}

BFS代码如下：

#include<stdio.h>
#include<vector>
#include<queue> 
#include<algorithm>
using namespace std;

// node保存节点信息，node[i]中保存的是节点i的孩子节点 
vector<int> node[110];
// height保存各节点所处的层号，从1开始计数 
int height[110] = {0}; 
// leaf保存的是每一层叶子节点的个数 
int leaf[110] = {0};
// 保存最大深度 
int maxDepth = 0;

void BFS()
{
	queue<int> que;
	// 根节点压入队列 
	que.push(1);
	
	while(!que.empty())
	{
		int index = que.front();
		que.pop();
		// 更新最大深度 
		maxDepth = max(maxDepth, height[index]);
		
		// 如果改节点是叶子节点 
		if(node[index].size() == 0)
			leaf[height[index]] ++;
		
		// 将index所有的孩子节点层号+1 
		// 将index所有的孩子节点压人队列 
		for(int i = 0; i < node[index].size(); i ++)
		{
			height[node[index][i]] = height[index] + 1;
			que.push(node[index][i]);
		}
	}
}

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);
      		node[parent].push_back(child);
    	}
	}
	
	//初始化根节点 
  	height[1] = 1;
  	BFS();
  	
  	for(int i = 1; i <= maxDepth; i ++)
  	{
    	if(i == maxDepth)
      		printf("%d", leaf[i]);
    	else
      		printf("%d ", leaf[i]);
    }
  	return 0;
}