强化阶段 Day 19 算法笔记 9.3 树的遍历

最新推荐文章于 2024-10-03 23:25:47 发布
最新推荐文章于 2024-10-03 23:25:47 发布
阅读量149 收藏
点赞数
文章标签： 算法 蓝桥杯 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aixiaoxiao13/article/details/122176330
版权
本文介绍了树的先根遍历和层序遍历两种算法，并展示了如何找到等权重路径、供应链的总销售额、最高价格、最大代数、最低价格以及叶子节点计数。同时，提供了在给定成本和增长率下计算供应链总销售的解决方案以及求最长和最短供应链的方法。
摘要由CSDN通过智能技术生成

目录

1.先根遍历

2.层序遍历

3.Path of Equal Weight

4.Total Sales of Supply Chain

5.Highest Price in Supply Chain

6.The Largest Generation

7.Lowest Price in Supply Chain

8.Counting Leaves

1.先根遍历

void preorder(int root){
	printf("%d ",martix[root].data);
	for(int i=0;i<martix[root].child.size();i++){
		preorder(martix[root].child[i]);
	}
}

2.层序遍历

void layer(int root){
	queue<int> q;
	martix[root].layer=0;
	q.push(root);
	while(!q.empty()){
		int now=q.front();
		q.pop();
		printf("%d ",martix[now].data);
		for(int i=0;i<martix[now].child.size();i++){
			int child=martix[now].child[i];
			martix[child].layer=martix[now].layer+1;
			q.push(child);
		}
	}
}

3.Path of Equal Weight

#include<cstdio>
#include<vector>
#include<cstring>
#include<string>
#include<stack>
#include<set>
#include<map>
#include<ctime>
#include<queue>
#include<math.h>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long ll;

const int maxn=105;
int n,m,s;
struct{
	int data;
	vector<int> child;
}martix[maxn];

bool cmp(int a,int b){
	return martix[a].data>martix[b].data;
}
int path[maxn]; 
void dfs(int index,int numnode,int sums){
	if(sums>s) return;
	if(sums==s){
		if(martix[index].child.size()!=0) return;
		for(int i=0;i<numnode;i++){
			printf("%d",martix[path[i]].data);
			if(i<numnode-1) printf(" ");
			else printf("\n");
		}
		return;
	}
	for(int i=0;i<martix[index].child.size();i++){
		int child=martix[index].child[i];
		path[numnode]=child;
		dfs(child,numnode+1,sums+martix[child].data);
	}
}



int main(){
	scanf("%d%d%d",&n,&m,&s);
	for(int i=0;i<n;i++){
		scanf("%d",&martix[i].data);
	}
	int father,child,num;
	for(int i=0;i<m;i++){
		scanf("%d %d",&father,&num);
		for(int j=0;j<num;j++){
			scanf("%d",&child);
			martix[father].child.push_back(child);
		}
		sort(martix[father].child.begin(),martix[father].child.end(),cmp);
	}
	path[0]=0;
	dfs(0,1,martix[0].data);
	
	return 0;
}

4.Total Sales of Supply Chain

#include<cstdio>
#include<vector>
#include<cstring>
#include<string>
#include<stack>
#include<set>
#include<map>
#include<ctime>
#include<queue>
#include<math.h>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long ll;

const int maxn=100005;
struct{
	int data;
	vector<int> child;
}martix[maxn];
double p,r;
double ans=0;
void dfs(int index,int depth){
	if(martix[index].child.size()==0){
		ans+=martix[index].data*pow(1+r,depth);
		return;
	}
	for(int i=0;i<martix[index].child.size();i++){
		dfs(martix[index].child[i],depth+1);
	}
}



int main(){
	
	int n;
	
	scanf("%d %lf %lf",&n,&p,&r);
	r/=100;
	int num,child;
	for(int i=0;i<n;i++){
		scanf("%d",&num);
		if(num!=0){
			for(int j=0;j<num;j++){
				scanf("%d",&child);
				martix[i].child.push_back(child);
			}
		}else{
			scanf("%d",&martix[i].data);
		}
	}
	
	dfs(0,0);
	printf("%.1f",ans*p);
	
	return 0;
}

5.Highest Price in Supply Chain

#include<cstdio>
#include<vector>
#include<cstring>
#include<string>
#include<stack>
#include<set>
#include<map>
#include<ctime>
#include<queue>
#include<math.h>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long ll;

const int maxn=100005;
vector<int> martix[maxn];
int n;
double p,r;
int maxlength=0,num=0;
void dfs(int index,int length){
	if(martix[index].size()==0){
		if(length>maxlength){
			maxlength=length;
			num=1;
		}else if(length==maxlength){
			num++;
		}
		return;
	}
	for(int i=0;i<martix[index].size();i++){
		dfs(martix[index][i],length+1);
	}
}

int main(){
	
	scanf("%d%lf%lf",&n,&p,&r);
	r/=100;
	int father,root;
	for(int i=0;i<n;i++){
		scanf("%d",&father);
		if(father!=-1){
			martix[father].push_back(i);
		}else{
			root=i;
		}
	}
	dfs(root,0);
	printf("%.2f %d\n",p*pow(r+1,maxlength),num);
	
	
	
	return 0;
}

6.The Largest Generation

#include<cstdio>
#include<vector>
#include<cstring>
#include<string>
#include<stack>
#include<set>
#include<map>
#include<ctime>
#include<queue>
#include<math.h>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long ll;

const int maxn=110;
struct{
	int layer;
	vector<int> child;
}martix[maxn];
int level[maxn]={0};
void bfs(int root){
	queue<int> q;
	q.push(root);
	martix[root].layer=1;
	while(!q.empty()){
		int now=q.front();
		q.pop();
		level[martix[now].layer]++;
		for(int i=0;i<martix[now].child.size();i++){
			int child=martix[now].child[i];
			martix[child].layer=martix[now].layer+1;
			q.push(child);
		}
	}
}

int main(){
	
	int n,m;
	scanf("%d %d",&n,&m);
	int father,num,child;
	for(int i=0;i<m;i++){
		scanf("%d%d",&father,&num);
		for(int j=0;j<num;j++){
			scanf("%d",&child);
			martix[father].child.push_back(child);
		}
	}
	bfs(1);
	
	int maxlength=-1,maxlevel;
	for(int i=1;i<maxn;i++){
		if(level[i]>maxlength){
			maxlength=level[i];
			maxlevel=i;
		}
	}
	printf("%d %d\n",maxlength,maxlevel);
	
	return 0;
}

7.Lowest Price in Supply Chain

#include<cstdio>
#include<vector>
#include<cstring>
#include<string>
#include<stack>
#include<set>
#include<map>
#include<ctime>
#include<queue>
#include<math.h>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long ll;

const int maxn=100005;
vector<int> martix[maxn];
int minlength=maxn,num;
int n;
double p,r;
void dfs(int index,int order){
	if(martix[index].size()==0){
		if(order<minlength){
			minlength=order;
			num=1;
		}else if(order==minlength){
			num++;
		}
		return;
	}
	for(int i=0;i<martix[index].size();i++){
		dfs(martix[index][i],order+1);
	}
}

int main(){
	scanf("%d%lf%lf",&n,&p,&r);
	r/=100;
	int nums,child;
	for(int i=0;i<n;i++){
		scanf("%d",&nums);
		if(nums!=0){
			for(int j=0;j<nums;j++){
				scanf("%d",&child);
				martix[i].push_back(child);
			}
		}
	}
	dfs(0,0);
	printf("%.4f %d",p*pow(1+r,minlength),num);
	
	return 0;
}

8.Counting Leaves

#include<cstdio>
#include<vector>
#include<cstring>
#include<string>
#include<stack>
#include<set>
#include<map>
#include<ctime>
#include<queue>
#include<math.h>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long ll;

const int maxn=101;
struct{
	int layer;
	vector<int> child;
}martix[101];
int ans[maxn]={0},l=-1;

void bfs(int root){
	queue<int> q;
	q.push(root);
	martix[root].layer=0;
	while(!q.empty()){
		int now=q.front();
		q.pop();
		if(martix[now].child.size()==0){
			ans[martix[now].layer]++;
			if(martix[now].layer>l) l=martix[now].layer;
		}
		for(int i=0;i<martix[now].child.size();i++){
			int child=martix[now].child[i];
			martix[child].layer=martix[now].layer+1;
			q.push(child);
		}
	}
}

int main(){
	
	int n,m;
	scanf("%d %d",&n,&m);
	int father,num,child;
	for(int i=0;i<m;i++){
		scanf("%d%d",&father,&num);
		for(int j=0;j<num;j++){
			scanf("%d",&child);
			martix[father].child.push_back(child);
		}
	}
	bfs(1);
	for(int i=0;i<=l;i++){
		printf("%d",ans[i]);
		if(i!=l) printf(" ");
	}
	
	return 0;
}
#include<cstdio>
#include<vector>
#include<cstring>
#include<string>
#include<stack>
#include<set>
#include<map>
#include<ctime>
#include<queue>
#include<math.h>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long ll;

const int maxn=101;
vector<int> martix[maxn];
int ans[maxn],l=-1;
void dfs(int index,int layer){
	if(martix[index].size()==0){
		ans[layer]++;
		if(layer>l) l=layer;
		return;
	}
	for(int i=0;i<martix[index].size();i++){
		dfs(martix[index][i],layer+1);
	}
}

int main(){
	int n,m;
	scanf("%d%d",&n,&m);
	int father,num,child;
	for(int i=0;i<m;i++){
		scanf("%d %d",&father,&num);
		for(int j=0;j<num;j++){
			scanf("%d",&child);
			martix[father].push_back(child);
		}
	}
	dfs(1,0);
	for(int i=0;i<=l;i++){
		printf("%d",ans[i]);
		if(i!=l) printf(" ");
	} 
	
	
	return 0;
}

是小肖啊！
关注
4万字c++讲解+区分c和c++，不来可惜了（含代码+解析）
阿玥的小博客
02-22 1万+
变量声明向编译器保证变量以给定的类型和名称存在，这样编译器在不需要知道变量完整细节的情况下也能继续进一步的编译。可以在 C++ 程序中多次声明一个变量，但变量只能在某个文件、函数或代码块中被定义一次。多个变量赋同一个值时，需要分别赋值。//错误x = y = z;extern 数据类型 变量名;数据类型 变量名1,变量名2,...变量名n;// 变量声明// 变量定义int a, b;// 初始化a = 23;b = 25;return 0;函数类型-函数的返回值类型。
JAVA学习笔记
lizzzza的博客
01-18 1050
JAVA学习笔记
javaSE笔记(宝典大全）
m0_63272315的博客
06-06 909
计算机的最基本的用途之一就是执行数学运算int a = 10;int b = 20;a + b;a < b;Java中运算符可分为以下：算术运算符(+ - * /)、关系运算符(< > ==)、逻辑运算符、位运算符、移位运算符以及条件运算符等方法语法格式// 方法定义修饰符 返回值类型 方法名称([参数类型 形参 ...]){方法体代码;[return 返回值];【注意事项】1. 修饰符：现阶段直接使用public static 固定搭配。
C 语言概述
学生一枚。
02-28 1723
主要是通过看C Primer Plus书本，看郝斌老师的C语言课程，再参考其它博主的博客编写而成，仅供参考使用，欢迎大佬们批评指正！
Java核心技术 读书笔记
qq_45651829的博客
09-06 1056
面向对象编程OOP是现在的主流，Java是完全面向对象的。OOP由对象构成，每个对象中有对用户公开的特定功能部分，也有隐藏的实现部分。结构化编程是先考虑算法的设计，再去考虑数据的存储方式。OOP则是先考虑数据的存储方式，再考虑操作数据的算法。使用Java中预先定义的Data类来介绍类的使用方法。现在介绍如何设计复杂应用程序所需要的各种主力类。这些类没有main方法，但是有自己的数据域和实例方法（实例方法不是静态方法）。这些类自己不能运行，通过设计的目的是被调用。
JavaScript - 基础+WebAPI（笔记）
qq_48937489的博客
05-10 4291
输入输出语法、数据类型、运算符、流程控制（分支语句、循环语句）、数组、对象、函数、DOM、事件监听、常用事件、事件对象、事件流、事件委托、日期对象、节点操作、window对象、正则表达式、本地存储
Python极简讲义一本书入门机器学习和数据分析--自学笔记
weixin_55688821的博客
04-18 2455
Python极简讲义机器学习数据分析--自学讲义。
谷粒商城 - 个人笔记(基础篇一)
热门推荐
知行
09-26 5万+
电商后台管理系统+电商系统，掌握微服务的全套方案。该系统有商品服务、仓储服务、订单服务、购物车服务、检索服务、认证中心服务、网关服务、用户服务、秒杀服务、第三方服务。使用SpringBoot+SpringCloud并配套SpringCloud Alibaba系列，引入全套微服务治理方案：Nacos注册中心/配置中心、Feign远程调用、Gateway网关、Redisson缓存、基于ElasticSearch7全文检索、异步编排与线程池、RabbitMQ柔性事务方案、Redisson分布式锁、分布式信号量等。
Hive笔记
weixin_57597001的博客
08-13 224
第 1 章 Hive 基本概念 1.1 什么是 Hive 1） hive 简介 Hive：由 Facebook 开源用于解决海量结构化日志的数据统计工具。 Hive 是基于 Hadoop 的一个数据仓库工具，可以将结构化的数据文件映射为一张表，并 提供类 SQL 查询功能。 2） Hive 本质：将 HQL 转化成 MapReduce 程序 （1）Hive 处理的数据存储在 HDFS （2）Hive 分析数据底层的实现是 MapReduce （3）执行程序运行在 Yarn
Python基础语法笔记
熙光的博客
03-21 1431
本文章是为了Python入门笔记，方便后续学习中建议查看相应的知识点算术运算符比较运算符逻辑运算符位运算符其他运算符注意：即：运算符的优先级类型信息获取类型信息注：类型转换 将对象以字符串表示的方式格式化输出到流文件对象file里。其中所有非关键字参数都按 str() 方式进行转换为字符 串输出； 关键字参数 sep 是实现分隔符，比如多个参数输出时想要输出中间的分隔字符； 关键字参数 end 是输出结束时的字符，默认是换行符 \n ； 关键字参数 file 是定义流输出的文件，可以是标准的系统输出 sy
一、Hive简明笔记
Norni的博客
10-06 530
目录1、Hive基本概念1.1 什么是Hive1.2 Hive的优缺点1.3 Hive架构原理2、Hive安装2.1 Hive安装部署2.2 Hive元数据配置到MySQL2.2.1 拷贝JDBC驱动2.2.2 配置 Metastore 到 MySQL2.3 使用元数据服务的方式访问Hive2.4 使用JDBC方式访问Hive2.5 hive 服务启动脚本2.6 Hive常见属性配置2.6.1 ...
javase学习笔记，学习时间一个月，发布笔记进度1/3
m0_60726300的博客
04-10 1882
1. Java基本语法 1.1 语言概述 1.1.1 整体语言概述 1.1.2 Java语言概述 1.1.2.1 基础常识 软件：即一系列按照特定顺序组织的计算机数据和指令集合。分为系统软件和应用软件 系统软件：Windows，mac os，linux，unix，android，ios，… 应用软件：word，ppt，画图板 人机交互方式：图形化界面vs命令行方式 应用程序=算法+数据结构 1.1.2.2 计算机语言的发展迭代史 第一代：机器语言 第二代：汇编语言 第三代：高级语言 面向过程：C，P
JavaSE笔记 [全文字数7.1W]
weixin_46820463的博客
02-20 1521
JavaSE笔记 文章目录JavaSE笔记第一章 初识Java1.1 java发展史1.2 特点1.3 语言特性1.4 JDK、JRE、JVM三者关系1.5 Java加载与执行1.6 DOS基本命令1.7 常用快捷键1.8 Java环境搭建1.9 注释第二章 数据相关2.1 标识符与关键字2.2 变量2.2.1 字面量2.2.2 变量2.3 数据类型2.3.1 定义2.3.2 8种基本数据类型区别2.3.3 数据类型注意事项2.3.4 字符编码2.3.5 转义字符2.4 运算符2.4.1 算数运算符2.4.
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1286
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
二叉树最小深度
2301_80161204的博客
09-27 475
25[0, 105]
904. 水果成篮
YQ20210216的博客
09-27 371
转化，找出一个最长的子数组长度，子数组中不超过两种类型的水果，要记录水果类型和水果数量，所以要使用unord_map，key来记录水果中类，valuse记录水果数量，当right开始增加的时候，将水果种类加入到哈希表中，当水果中类超过两种时，控制left使得水果种类回到两种。你想要尽可能多地收集水果。你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组。，返回你可以收集的水果的。
数据结构—排序
最新发布
2302_81258662的博客
10-03 582
在数据结构中，排序是一种将数据元素重新排列的过程，通常是为了使它们按照特定的顺序（如升序或降序）组织起来。排序在计算机科学中非常重要，下面是一些常见的数据结构排序方法和它们的特点。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1102
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
NOIP2019模拟竞赛：高效算法解决Day1树与排列问题
1. **暴力枚举**：遍历所有可能的根节点，使用动态规划计算子树中包含不同颜色的情况，时间复杂度为O(n^2*m)，期望得分20分。 2. **优化方法**：未在描述中详细说明，可能是通过更高效的数据结构或策略来降低时间...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值