pat-树部分02

最新推荐文章于 2022-03-04 19:20:09 发布
最新推荐文章于 2022-03-04 19:20:09 发布
阅读量107 收藏
点赞数 1
分类专栏： pat-复习 文章标签： 字符串 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_45359314/article/details/113764190
版权 
//1094
#include<bits/stdc++.h>
using namespace std;
vector<int> v[110];
int book[110] ;
int maxle=0;
void dfs(int root,int le){
	//end
	book[le]++;
	if(v[root].size()==0){
		if(le>maxle){
			maxle=le;
		}
		return;
	}
	for(int i=0;i<v[root].size();i++){
		dfs(v[root][i],le+1);
	}
} 
int main(){
	int n,m,_1,_2,_3;
	scanf("%d%d",&n,&m);
	for(int i=0;i<m;i++){
		scanf("%d%d",&_1,&_2);
		for(int i=0;i<_2;i++){
			scanf("%d",&_3);
			v[_1].push_back(_3);
		}
	}
	dfs(1,1);
	int maxnum=0,ansle=0;
	for(int i=1;i<=maxle;i++){
		if(book[i]>maxnum){
			maxnum=book[i];
			ansle=i;
		}
	}
	printf("%d %d",maxnum,ansle);
	return 0;
}

#include<bits/stdc++.h>
using namespace std;
struct node{
	int key,index;
};
vector<int>v[110];
vector<node> ans;
vector<int>in;
int cnt=0;
void dfs(int root,int index){
	//end
	if(root==-1){
		return;
	}
	dfs(v[root][0],2*index+1);
	ans.push_back(node{in[cnt++],index} ) ;
	dfs(v[root][1],2*index+2);
}
bool cmp(node&a,node&b){
	return a.index<b.index;
}
int main(){
	int n,_1,_2;
	scanf("%d",&n);
    for(int i=0;i<n;i++){
    	scanf("%d%d",&_1,&_2);
    	v[i].push_back(_1);
    	v[i].push_back(_2);
	}
	int _3;
	for(int i=0;i<n;i++){
		scanf("%d",&_3);
		in.push_back(_3);
	}
	sort(in.begin(),in.end());//中序没sort 
	dfs(0,0);
	sort(ans.begin(),ans.end(),cmp);
	printf("%d",ans[0].key);
	for(int i=1;i<ans.size();i++){
		printf(" %d",ans[i].key);
	}
	return 0;
}
//1099

#include<bits/stdc++.h>
using namespace std;
struct node{
	int l,r,key;
};
int maxle=0;
vector<int> in;
vector<node> v(100);
vector<int>ans[110];//只用来存储过程中的索引 
int cnt=0;
void dfs(int root,int le){
	if(le>maxle){
		maxle=le;
	}
	if(v[root].l!=-1){
		dfs(v[root].l,le+1); 
	}
	v[root].key=in[cnt++];
	if(v[root].r!=-1){
		dfs(v[root].r,le+1); 
	}
}
int main(){
	int n,_1,_2;
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("%d%d",&_1,&_2);
		//v.push_back({_1,_2});已经分配了空间不能在pushback 
	   v[i].l=_1;
	   v[i].r=_2;
	}
	int _3;
	for(int i=0;i<n;i++){
		scanf("%d",&_3);
		in.push_back(_3);
	}
	sort(in.begin(),in.end());
	dfs(0,0);
	ans[0].push_back(0);//第一个坐标代表层数 
	for(int i=0;i<=maxle;i++){
		for(int j=0;j<ans[i].size();j++){
			if(i!=0) printf(" ");
			printf("%d",v[ans[i][j]].key);
		
		if(v[ans[i][j]].l!=-1) ans[i+1].push_back(v[ans[i][j]].l);
		if(v[ans[i][j]].r!=-1) ans[i+1].push_back(v[ans[i][j]].r);//类似于队列 
	    }
	}
	return 0;
	
}
//1102

#include<bits/stdc++.h>
using namespace std;

vector<int> v[15];
struct node{
	int root,index;
};
vector<node> in;
int ex[15];
void dfs(int root,int index){
	if(root==-1){//已经是v[root][1]的值了不能是-1的v吧 
		return;
	}
	dfs(v[root][1],2*index+1);
	in.push_back(node{root,index});
	dfs(v[root][0],2*index+2);
}
bool cmp(node&a,node&b){
	return a.index<b.index;
}
int main(){
	int n;
	scanf("%d",&n);//值这里在缓冲区留下一个\n导致后面%c scanf输入错误，所以遇到有char型也要getchar（） 
    getchar();
	for(int i=0;i<n;i++){
		char a,b;
		scanf("%c %c",&a,&b);//慎用char型注意回收"\n" 
		getchar();
	//	printf("\n");
	//	printf("****%c %c****",a,b);
		
		if(a=='-'){
			v[i].push_back(-1);
		}else{
			v[i].push_back(a-'0');//char型数字直接-'0'就可以转化为int 
			ex[a-'0' ]=1;//不能用to_string//将数值转化为字符串。返回对应的字符串。 
		}
		if(b=='-'){
			v[i].push_back(-1);
		}else{
			v[i].push_back(b-'0');
			ex[b-'0']=1;
		}
	}
	int i=0;
	while(ex[i]==1&&i<n) i++;
	
	dfs(i,0);
	vector<node> cg;
	cg=in;//vector 可以直接相等赋值 
	sort(cg.begin(),cg.end(),cmp);
	for(int i=0;i<cg.size();i++)
	{
	   if(i!=0) printf(" ");
	   printf("%d",cg[i]);
	}
	printf("\n");
	for(int i=0;i<in.size();i++)
	{
	   if(i!=0) printf(" ");
	   printf("%d",in[i]);
	}
	return 0;
	 
}
//pat-1103

#include<bits/stdc++.h>
using namespace std;
vector<int> ar;
int n,k,p;
void get(int n){
	for(int i=1;i<=n;i++){
		if(pow(i,p)<=n){
			ar.push_back(pow(i,p));
		}
	}
}
int flag=1;
vector<int> temp,ans;

void dfs(int index,int le){
	temp.push_back(ar[index] );
	//end
	if(le==k){
		int sum=0;
		for(int i=0;i<temp.size();i++){
			sum+=temp[i];
		}
		if(sum==n){
			ans=temp;
			flag=0;
		}
		temp.pop_back();
		return;
	}
	while(index>=0){
		int tempsum=0;
		for(int i=0;i<temp.size();i++){
			tempsum+=temp[i];
		}
	if(tempsum+ar[index] <n) 
	dfs(index,le+1);
	else{
		temp.pop_back();
		temp.push_back(ar[index-1]);
	} 
	if(flag==0) break;
	index--;
    }
    temp.pop_back();
}

int maxsumd=0;
void dfs(int index,int le,int tempsum){
		if(le==k){
		int sum=0;
		for(int i=0;i<temp.size();i++){
			sum+=temp[i];
		}
		int sumd=0;
		for(int i=0;i<temp.size();i++){
			sumd+=sqrt(temp[i]);
	    }
		if(sum==n){
			ans=temp;
			maxsumd=sumd;
			//flag=0;
		}
		//temp.pop_back();
		return;
	}
	while(index>=0){
		if(tempsum+ar[index]<=n){
		temp.push_back(ar[index]);
		dfs(index,le+1,tempsum+ar[index]);
	    temp.pop_back();//dfs后面紧跟pop 不要每次每入值就pop 
		}
	//	if(flag==0) break;//双等写成等于 
		//temp.pop_back();//过度pop在for换岔道口内是不需要pop的 
		index--;
	}
	//temp.pop_back();
}
int main(){
	scanf("%d%d%d",&n,&k,&p);
	get(n);
	dfs(ar.size()-1,0,0);//从0klui 
	if(ans.size()==0){
		printf("Impossible");
	}else{
		printf("%d = ",n);
		int _1=sqrt(ans[0]) ;
		printf("%d^%d",_1 ,p);//sqrt若输出只能为lf 
		for(int i=1;i<ans.size();i++){
		_1=sqrt(ans[i]) ;
		printf(" + %d^%d",_1,p);
		//printf("*%d",ans[i]);
		}
		
	}
	return 0;
}
//1106

#include<bits/stdc++.h>
using namespace std;
vector<int> v[100009];
double minn=1000000000;int num=0; //min初始值能设多大就设多大 
double p,r;
void dfs(int root,int le){
	//end
	if(v[root].size()==0){
		double temp=0;
		temp=p*pow(1+r/100,le);
		 
		if(temp<minn){
			minn=temp;
			num=1;
		}else if(temp==minn){
			num++;
		}
		return ;
	}
	for(int i=0;i<v[root].size();i++){
		dfs(v[root][i],le+1);
	}
}
int main(){
	int n,_1,_2;
	scanf("%d%lf%lf",&n,&p,&r);
	for(int i=0;i<n;i++){//for循环重名 
		scanf("%d",&_1);
		for(int j=0;j<_1;j++){//for 循环重名导致存储错误 
		scanf("%d",&_2);
		v[i].push_back(_2);
		}
		
	}
	dfs(0,0);
	printf("%.4lf %d",minn,num);
	return 0;
}
//1110

#include<bits/stdc++.h>//root 与index 未必相等   这种题不适合用vector 做 
using namespace std;
//vector<int>v[25];
int ex[25],maxindex=0,node=-1;
struct node{
	int id,index,ll,rr;
}a[25];
void dfs(int root,int index){
	//end
	/*if(root==-1) //已经是-1了就该结束 
	{  
	if(index>maxindex)
    maxindex=index;
   
	return;
     }*/
   if(index>maxindex){
    maxindex=index;
    node=root;
	}
    
if(a[root].ll!=-1)//防止-1时再标记 
dfs(a[root].ll,2*index);
if(a[root].rr!=-1)
dfs(a[root].rr,2*index+1);
}
int main(){
	fill(ex,ex+25,0);
	int n;//gf
	string  _1,_2;
	scanf("%d",&n);
	getchar();
	for(int i=0;i<n;i++){
		cin>>_1>>_2;
		getchar();
		if(_1=="-")
		a[i].ll=-1;
		else{
			//v[i].push_back(_1-'0');
			a[i].ll=stoi(_1);
			ex[stoi(_1)]=1;
			//cnt++;
		}
		if(_2=="-")
		//v[i].push_back(-1);
		a[i].rr=-1;//写错没改 
		else{
			//v[i].push_back(_2-'0');
			a[i].rr=stoi(_2);
			ex[stoi(_2)]=1;//复制过来没改全 
			//cnt++;
		}
	}
	int i=0;
	//debug
	/*for(int i=0;i<n;i++){
		printf(" %d",ex[i]);
	}
	printf("\n");*/
	while(ex[i]==1&&i<n)i++;
	dfs(i,1);
	if(n==maxindex){
		//printf("YES %d",cnt-1);//想当然root与index未必相同，index只是我们随便标的号，样例有可能骗你 
	printf("YES %d",node);
	}else{
		printf("NO %d",i);
	}
	return 0;
}

#include<bits/stdc++.h>
using namespace std;
struct node{
	int key;
	node*l;
	node*r;
};
void insert(node*&root,int data){
 //因为有new
if(root==NULL){
	root=new node;
	root->key=data;
	root->l=root->r=NULL;//用成双等 
	return ;//不可缺少  否则又会把它插一遍 
}
if(data<=root->key){//即使题干非常类似也要一行一行的看，这题就把细节处改了是<=在左子树 
	insert(root->l,data);
}else{
	insert(root->r,data);
}
}
int book[1009],maxle=0;
void dfs(node*root,int le){
if(le>maxle){
	maxle=le;
}
book[le]++;
if(root->l!=NULL) dfs(root->l,le+1);//加个冒防止为空影响记录 
if(root->r!=NULL) dfs(root->r,le+1);
}
int main(){
	int n,_1;
	scanf("%d",&n);
	node*root=NULL;
	for(int i=0;i<n;i++){
		scanf("%d",&_1);//忘加& 
		insert(root,_1);
	}
	dfs(root,0);
	printf("%d + %d = %d",book[maxle],book[maxle-1],book[maxle]+book[maxle-1]);
	return 0;
}
//pat-1119 
#include<bits/stdc++.h>
using namespace std;
vector<int> pre,post;
int flag=0;
vector<int> in;
void dfs(int root,int poll,int porr){
	//end
	if(poll>=porr) {//此时和原先划分情况不同，未必就是> 
//	if(poll==porr);//加了个；????? 
     if(poll==porr)
	 in.push_back(post[poll]);//当等于是也要输入最后一个元素 
	 return;
	 } 
	int i=poll;
	while(post[i]!=pre[root+1]&&i<porr) i++;//相等时 会导致本该正确的错误，题目已改变具体整么写应该根据清况带入看看 
	if(porr-i>1){
		dfs(root+1,poll,i);
		in.push_back(pre[root]);
		dfs(root+i-poll+2,i+1,porr-1);
	}else{
		flag=1;
		dfs(root+1,poll,i);
		in.push_back(pre[root]);
		dfs(root+i-poll+2,i+1,porr-1);
	}
	
}
int main(){
	int n,_1;
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("%d",&_1);
		pre.push_back(_1);
	} 
	for(int i=0;i<n;i++){
		scanf("%d",&_1);
		post.push_back(_1);
	} 
	dfs(0,0,n-1);
	if(flag==1){
		printf("No\n");
	}else{
		printf("Yes\n");
	}
	printf("%d",in[0]);
	for(int i=1;i<in.size();i++){
		printf(" %d",in[i]);
	}
	printf("\n");
	return 0;
}

总结

8道比较难

需再刷1103  还没研究透dfs+剪枝

1119  划分的终止条件看看可不可以推广 1115bst插入序列

不熟题型   1102 1110

还有各种小错误哈哈，放平心态，很正常

问题  dfs+剪枝 

 

 

江船夜雨听笛
关注
专栏目录
PAT-树与并查集
1180610212的博客
02-19 141
参考资料：《算法笔记》，柳神csdn博客 PAT-A1020 问题：给定后序和中序序列，要求给出层序序列。 思路：根据后序和中序序列建树然后再层序遍历输出即可。 关键：在建树过程中要考虑边界条件，即后序序列为空时if(preL>preR) return NULL 退出。 PAT-A1053【hard】 问题：给定一个每个结点都有权值的树并给定一个整数S，要求求出从根到叶子的路径上所有结点权值之和为这个整数S的所有这样的路径，并按照权值降序排列输出。 思路：根据给定权值和信息建树，通过静态方式建树最.
宇宙无敌PAT-A不完全考纲
大美mixer的博客
02-07 965
    大家新年快乐！     最近一直有朋友问我“考研上机怎么准备？”、“马上找工作，想考PAT练练手”等...其实本来刚考完PAT的时候，我是想总结一下各个平台以及教程的所有题目合成一本模板教程。但是我想想吧，这样让大家太偷懒了，不利于大家的智力发展。还是建议大家自己先做一遍，然后对着答案改，然后形成自己的模板比较好（其实是我懒 /(T_T)/~~~）...
PAT----树----序列建树+遍历 (节点+数组)
weiwei935707936的博客
03-04 313
_________________________________________________________ 一. 两个序列建树, 更换方式输出 struct node creat 递归返回条件 新建root 得到叶子长度 递归(参数) 返回root 普通型: 节点量<30 给出叶子节点型: 前序可以得到中序, 节点量<30 数据超大型: 优化查找in根节点, 使用hash表(map), 数据量<5000 前序, 后序序列建树 看似两序列建..
PAT----树----BST+AVL
weiwei935707936的博客
03-04 116
———————————————————————————————— BST ———————————————————————————————— BST的插入建立，镜像 1043 // 1.BST的建立： 空指针开始， 插入函数：赋值函数+递归调用， // 2.树的镜像：遍历的时候对换左右孩子节点的顺序就好 // 3.两个vector可以直接比较 //核心： 单序列建BST + 树的镜像BST //1.单序列建BST： // (1)BST树的创建只需要一个插入序列即可..
PAT----树----完全二叉树(堆)
weiwei935707936的博客
03-04 191
________________________________________________________ 二.完全二叉树+堆 ________________________________________________________ 数组型树及：完全二叉树 1110 // 1.完全二叉树二层序遍历的关系： 层序遍历时，只要有以一个叶子不满， 并且之后还有有叶子的节点就不是完全二叉树 // 2.注意：只有两个节点， 并且根节点左子树为空的特殊情况 // 3.部分样例不过关不要.
pat-1135-红黑树-递归问题
laixiangwei的博客
09-15 368
红黑树 定义：红黑树本质上是一个二叉搜索树，AVL树也是一个二次搜索树，它们之前的不同点在于AVL偏向于查询数据，而红黑树偏向于做增删改查的二叉搜索树(同志们，一定要把二叉搜索树和红黑树区分开来噢)。 首先来介绍一下红黑树经典的五个特性吧 根结点一定是黑色的 "叶子结点"也就是常规意义上的叶子结点左右子树为空，我们假定也为黑色 一个结点要么为红色，要么为黑色 一个红色结点相邻部分不能为红，太红了不太好 黑高要相等——从任意一个节点到其叶子结点所有路径中的黑结点个数相等。这样注意是黑高 上面这些定义，也在
pat 二刷树部分-01
江船夜雨听笛的博客
02-07 142
//pat-143 #include<bits/stdc++.h> using namespace std; vector<int> pre; map<int,int>ex; void lca(int a,int b){ int i=0; if(ex[a]==0&&ex[b]==0){ printf("ERROR: %d and %d are not found.\n",a,b); return; } else if(ex[a]==0){.
pat-1115
江船夜雨听笛的博客
01-13 189
#include<iostream> #include<vector> using namespace std; //这样声明num（1000）与num【1000】有什么区别 vector<int> num(1000); int n,a; struct node{ int v; //前面需不需要加struct struct node*left; struct node*right; }; //传入参数要有根节点有值 //返回参数为node node* .
pat-1043
江船夜雨听笛的博客
01-16 151
值得二刷 #include<iostream> #include<vector> using namespace std; int n; vector<int> post,pre; bool mirror=false; void postorder(int root,int tail) { int i,j; if(root>tail) return; if(!mirror) { i=root+1; j=tail; //题干规定右面是>.
My-PAT-Preparations：PAT问题的一些代码
02-08
标题 "My-PAT-Preparations：PAT问题的一些代码" 暗示了这是一个与PAT...同时，良好的编程习惯，如代码注释、命名规范、错误处理等，也是PAT评估的一部分。因此，这些代码可能展示了作者在这些问题上的实践和思考。
PAT-2021年春季考试-顶级题解
qq_35577488的博客
03-13 1578
前言: 非常热乎的题解，嘿嘿。以往难度不知道(没刷过他们的题库)，感觉这次顶级难度真不高啊，，可能是题目难读的原因嘛？之前听cy姥姥吹的那么nb。没想到还是比较简单，唯一难读的就是题意，比较绕。 A.共享单车回收:Floyd,模拟 题目大意: 给你一张含(n+1)(n+1)(n+1)个点(编号0,1,2,...,n0,1,2,...,n0,1,2,...,n)mmm条边的带边权无向图。从0点出发。每次选择尚未访问过的节点中最短路径最短的点，去往那里。以此往复。直到无点可走。 第一行输出访问节点的路径. 第二
PAT-2019年冬季考试-甲级-7-4 Cartesian Tree (30分)
Eucalypt的博客
12-08 240
A Cartesian tree is a binary tree constructed from a sequence of distinct numbers. The tree is heap-ordered, and an inorder traversal returns the original sequence. For example, given the sequence { 8...
pat-复习08 大整数相加 分数运算部分
江船夜雨听笛的博客
02-16 1201
//1024 既然已经注意到是大整数相加了下面还用int 求和 to_string 这合适吗，不合适，数组也可以reverse 大整数相加千万不要在中途中再用整数赋值 否则大整数就白写了 #include<bits/stdc++.h> using namespace std; struct bign{ int d[1000]; int len; bign(){ memset(d,0,sizeof(d)); len=0; } }; /*bign ...
pat 秋 Professional Ability Test
江船夜雨听笛的博客
03-05 1083
7-4 Professional Ability Test (30分) Professional Ability Test (PAT) consists of several series of subject tests. Each test is divided into several levels. Level A is a prerequisite (前置要求) of Level B if one must pass Level A with a score no less than SSS
pat-05复习 图部分剩余
江船夜雨听笛的博客
02-12 957
//1111 //测试点二有问题 #include<bits/stdc++.h> using namespace std; vector<int> pred[510],pret[510],temp,temp1,ansd,anst; int distd[510],distt[510]; int a[510][510],t[510][510],visit1[510],visit2[510]; const int inf=1000000000; int ss,min..
pat 2020秋 第二题
江船夜雨听笛的博客
03-06 341
400 300 200 500 400 300 200 200 200 300 7-2 How Many Ways to Buy a Piece of Land (25分) The land is for sale in CyberCity, and is divided into several pieces. Here it is assumed that each piece of land has exactly two neighboring pieces, except the fir.
pat 复习 13 字符串处理剩余
江船夜雨听笛的博客
02-20 279
//1082 挺复杂的字符串处理 #include<bits/stdc++.h> using namespace std; string numw[] ={"ling","yi","er","san","si","wu","liu","qi","ba","jiu"}; string danwz[] ={"ge","Shi","Bai","Qian","Wan","Yi"}; int a[]={1,10,100,1000,10000,100000,1000000,10000000,10000.
pat 冬季第4题
江船夜雨听笛的博客
03-03 220
掏钱买的考了一下最后一个题目大半天编一点编一点的感觉总是到不了头就睡觉去了 太困了 然后又搭上了晚上 看别人的总感觉思路虽然差不多但是我们实际处理差距还是很大的 所以自己debug自己的代码 最后过了样例 感觉应该是对的 不想再花一份钱弄一下了 有钱的老哥帮我弄一下看看对不对告诉我一下呗 C:\Users\Administrator\AppData\Local\Packages\Microsoft.MicrosoftEdge_8wekyb3d8bbwe\TempState\Downloads\P...
PAT甲级算法模板第一版：并查集、最短路径与数据结构详解
7. **贪心算法**：虽然这部分没有明确的代码，但提到了`greedy`，说明该模板可能包含至少一个或多个贪心策略的实现，如霍夫曼编码、最小生成树等。 8. **其他辅助功能**：如`JointSet`，可能是用于解决特定场景的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值