pat-复习10 11 平方映射 堆排序 归并排序 快速排序 直接插入排序的比较 二分查找

最新推荐文章于 2023-05-15 07:21:38 发布
最新推荐文章于 2023-05-15 07:21:38 发布
阅读量151 收藏
点赞数 1
分类专栏： pat-复习 文章标签： 算法 快速排序 堆排序 heap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_45359314/article/details/113854835
版权

平方映射

//1078 平方探测 
#include<bits/stdc++.h>
using namespace std;
bool isprime(int n){
	if(n<=1) return false;
	for(int i=2;i<=sqrt(n*1.0);i++){//<= 4.5 4本来可以<就漏掉了 
		if(n%i==0) return false;
	}
	return true;
}
int main(){
	int ms,n,_1;
	scanf("%d%d",&ms,&n);
	while(!isprime(ms)) ms++;
	int book[ms],book1[ms];
	fill(book1,book1+ms,0);
	map<int,int> ans;
	for(int i=0;i<n;i++){
		scanf("%d",&_1);
		ans[_1]=-1;
		for(int j=0;j<ms;j++){
			if(book1[(_1+j*j)%ms]==0){
				book[(_1+j*j)%ms]=_1;
				ans[_1]=(_1+j*j)%ms;
				book1[(_1+j*j)%ms]=1;
				break;
			}
		}
		if(i!=0) printf(" ");
		if(ans[_1]>=0)
		printf("%d",ans[_1]);
		else printf("-");
	}
	return 0;
	
} 
//平方探测法
//1145 
#include<bits/stdc++.h>
using namespace std;
bool isprime(int x){
	if(x<=1) return false;
	
	for(int i=2;i<=sqrt(x*1.0);i++){
		if(x%i==0) return false;
	}
	return true;
}
int main(){
	int ms,n,m,_1;
	scanf("%d%d%d",&ms,&n,&m);
	//if(!isprime(ms)) ms++;//本来应该用while又用成了if while才能实现循环找值 昨天也是这么错的  把while 写成if  1 
	 while(!isprime(ms)) ms++;
   int book[ms] ,book1[ms] ;
    fill(book,book+ms,0);
	fill(book1,book1+ms,0);
	
	for(int i=0;i<n;i++){
		int flag=1;
		scanf("%d",&_1);
		int j;
		for( j=0;j<ms;j++){//忘记插入后直接break 
			int _4=(_1+j*j)%ms;
			if(book1[_4]==0){
				book[_4]=_1;
				book1[_4]=1;
				flag=0;
				break;
			}
		}
		if(flag==1) printf("%d cannot be inserted.\n",_1);
	}
	int sum=0,_2;
	for(int i=0;i<m;i++){
		scanf("%d",&_2);
		for(int j=0;j<=ms;j++){
			sum++;
			int _3=(_2+j*j)%ms;
			if(book1[ _3]==0||book[ _3]==_2) break;
		}
	}
	
	printf("%.1lf\n",sum*1.0/m);
	return 0; 	
}

堆排序

//堆排序 
#include<bits/stdc++.h>
using namespace std;
//向下调整
int heap[100],n=10;
 void downadjust(int low,int high){
 	int i=low,j=2*i;
 	while(j<=high){
 		if(j+1<=high){
 			if(heap[j+1]>heap[j]){
 				j=j+1;
			 }//选左右结点中的最大值 
		 }
		 if(heap[i]<heap[j]){
		 	swap(heap[i],heap[j]);
		 	i=j;//始终令i为调整节点 
		 	j=2*i;//左节点 
		 }else{
		 	break;
		 }
	 }
 }
 void create(){
 	for(int i=n/2;i>=1;i--){ 
	 downadjust(i,n);
	 }     //n/2为树的最后一个非叶节点 
 }
 void deletetop(){//删除栈顶元素 
 	heap[1]=heap[n--];
 	downadjust(1,n);
 }
 //插入元素需要用到的向上调整
 void upadjust(int low,int high){
 	int i=high;
 	int j=i/2;//双亲 
 	while(j>=low){
 		if(heap[i]>heap[j]){
 			swap(heap[i],heap[j]);
 			i=j;
 			j=i/2;
		 }else{
		 	break;
		 }
	 }
 } 
 //插入元素 
 void insert(int x){
 	heap[++n]=x;
 	upadjust(1,n);
 }
 void heapsort(){
   create();//建堆
   for(int i=n;i>1;i--){
   	  swap(heap[1],heap[i]);
	   downadjust(1,i-1);//i-1
   } 
 }
 int main(){
 	int _1;
 	for(int i=1;i<=10;i++){
 		scanf("%d",&_1);
		 heap[i]=_1;
	 }
	 insert(101);//1 insert 无误向上调整无误 
	 heapsort();//2向下调整 3建堆无误 
	 for(int i=1;i<=n;i++){
	 	printf(" %d",heap[i]);
	 }
	 return 0;
 }
//堆排序复盘 
#include<bits/stdc++.h>
using namespace std;
int heap[100],n=10;
void downadjust(int low,int high){
	int i=low,j=2*i;
	while(j<=high){ 
		if(j+1<=high&&heap[j+1]>heap[j]){//3 j+1也要验证是否在范围内是否存在
			j=j+1;
		}
		if(heap[j]>heap[i]){
			swap(heap[j],heap[i]);
			i=j;
			j=2*i;
		}else{
			break;
		}
	}
}
void deletetop(){
	swap(heap[1],heap[n--]);
	downadjust(1,n);
} 
void create(){
	for(int i=n/2;i>=1;i--){
		downadjust(i,n);
	}
}
void upadjust(int low,int high){
	int i=high,j=i/2;
	while(j>=low){
		if(heap[i]>heap[j]){
			swap(heap[i],heap[j]);
			i=j;
			j=i/2;
		}else{
			break;
		}
	}
}
void insert(int x){
	heap[++n]=x;
	upadjust(1,n);
}
void heapsort(){
	create();
	for(int i=n;i>1;i--){
		swap(heap[i],heap[1]);
		downadjust(1,i-1);
	}
}
int main(){
	int _1;
	for(int i=1;i<=n;i++){
		scanf("%d",&_1);
		heap[i]=_1;
	}
	insert(101);
	deletetop();
	heapsort();
	for(int i=1;i<=n;i++){
		printf(" %d",heap[i]);
	}
	printf("\n");

	
	return 0;
}
/*  4 5 68 4 2 1 7 6 3 7
//直接插入排序不是最终位置 需要相对检查  堆排序是最终位置可以和直接最终位置比对
//1098 
#include<bits/stdc++.h>
using namespace std;
int heap[110],insert[110],n;
void downadjust(int low,int high){
	int i=low,j=2*i;
	while(j<=high){
		if(j+1<=high&&insert[j+1]>insert[j]){
			j=j+1;
		}
		if(insert[j]>insert[i]){
			swap(insert[j],insert[i]);
			i=j;
			j=2*i;
		}else {
		break; 
	}
} 
}
int main(){
	scanf("%d",&n);
	
	for(int i=1;i<=n;i++){
		scanf("%d",&heap[i]);
	}
	for(int i=1;i<=n;i++){
		scanf("%d",&insert[i]);
	}
	int pre= insert[1],nt;
	for(int i=2;i<=n;i++){
	    if(insert[i]>=pre){
		pre=insert[i];	
		}else{
			nt=i;
			break;
		}
	}
	int flag=1;
	for(int i=nt;i<=n;i++){
		if(heap[i]!=insert[i]){
			flag=0;
		}
	}
	if(flag==1){
		printf("Insertion Sort\n");
		sort(heap+1,heap+nt+1);
		for(int i=1;i<=n;i++){
			if(i!=1) printf(" ");
			printf("%d",heap[i]);
		}
	}else{
		printf("Heap Sort\n");
		sort(heap+1,heap+n+1);
		int cnt;
		for(int i=n;i>=1;i--){
			if(insert[i]!=heap[i]){
			    cnt=i;
				break;
			}
		}
		swap(insert[1],insert[cnt]);
		downadjust(1,cnt-1);
		for(int i=1;i<=n;i++){
			if(i!=1) printf(" ");
			printf("%d",insert[i]);
		}
	}
	return 0;
	
}

归并排序

//归并排序 
#include<bits/stdc++.h>
using namespace std;
const int maxn=100;
int n;
void merge(int a[],int l1,int r1,int l2 ,int r2){
	int i=l1,j=l2;
	int temp[maxn],index=0;
	while(i<=r1&&j<=r2){
		if(a[i]<=a[j]){
			temp[index++]=a[i];
			i++;
		}else{
			temp[index++]=a[j];
		    j++;
		}
	}
	while(i<=r1) temp[index++]=a[i++];
	while(j<=r2) temp[index++]=a[j++];
	for(int i=0;i<index;i++){
		a[l1+i]=temp[i];
	}
}
void mergesort(int a[]){
	for(int step=2;step/2<=n;step*=2){
	for(int i=1;i<=n;i+=step){
		int mid=i+step/2-1;//左半区间的最后一个 
		if(mid+1<=n)//有可能不存在右子区间 
		merge(a,i,mid,mid+1,min(i+step-1,n));
	}
    }
}
void mergesortfz(int a[]){
	for(int step=2;step/2<=n;step*=2){
		for(int i=1;i<=n;i+=step){
			sort(a+i,a+min(n+1,i+step));//sort，reverse左闭右开 
		}
	}
}
int main(){
	int a[maxn];n=10;
	for(int i=1;i<=n;i++){
		scanf("%d",&a[i]);
	}
	mergesort(a);//使用merge 
	//mergesortfz(a);//sort模拟 
	for(int i=1;i<=n;i++){
		printf(" %d",a[i]);
	}
	printf("\n");
	
}
//1089  差点被这题坑死  测试点4 5有问题，把编译器从clang 编程g++ 就完美通过了 
#include<bits/stdc++.h>
using namespace std;
int init[100],then[100],n;
void mergesort(int a[]){
	for(int step=2;step/2<=n;step*=2){
	int flag=0;
	for(int i=1;i<=n;i++){
		if(then[i]!=a[i])//这里出现问题应该是过程中的a 而不是直接带入init 
		flag=1;
	}
	for(int i=1;i<=n;i+=step){
		sort(a+i,a+min(i+step,n+1));
	}
	if(flag==0){
		for(int i=1;i<=n;i++){
			if(i!=1) printf(" ");
			printf("%d",a[i]);
		}
		break;//忘记 
	}
    }
    	
	}


int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		scanf("%d",&init[i]);
	}
	for(int i=1;i<=n;i++){
		scanf("%d",&then[i]);
	}
	int pre=then[1],nt;
	for(int i=2;i<=n;i++){
		if(pre<=then[i]){
			pre=then[i];
		}else{
			nt=i;
			break;
		}
	}
	int flag=0;
	for(int i=nt;i<=n;i++){
		if(init[i]!=then[i]){
		//	break;//break跑到标志前出错 
			flag=1;
			break;
		}
	}
	
	if(flag==0){
		printf("Insertion Sort\n");
		sort(then+1,then+nt+1);
		for(int i=1;i<=n;i++){
			if(i!=1) printf(" ");
			printf("%d",then[i]);
		}
	}else{
		printf("Merge Sort\n");
		/*int step;
		int pre1=then[1];
		for(int i=2;i<=n;i++){
			if(pre1<=then[i]){
				pre1=then[i];
			}else{
				step=i-1;//各个组之间未必有这样的大小关系 
				break;
			}
		}
		mergesort(then,step);
		for(int i=1;i<=n;i++){
			if(i!=1) printf(" ");
			printf("%d",then[i]);
		}*/
		mergesort(init);
	}
	return 0;
}

快速排序

//快速排序 
#include<bits/stdc++.h>
using namespace std;
int partition(int a[],int left,int right){
	int temp=a[left];
	while(left<right){
	while(left<right&&temp<a[right]) right--;//指针是不断移动的 
		a[left]=a[right];
	while(left<right&&temp>=a[left]) left++;
		a[right]=a[left];
	
    }
    a[left]=temp;
    return left;
} 
void kysu(int a[],int left,int right){
	if(left<right){
	int mid=partition(a,left,right);
	kysu(a,left,mid-1);
	kysu(a,mid+1,right);
    }
}
int main(){
	int a[10];
	for(int i=0;i<10;i++){
		scanf("%d",&a[i]);
	}
	kysu(a,0,9);
	for(int i=0;i<10;i++){
		printf(" %d",a[i]);
	}
	return 0;
}
//除了在最终位置上还有保证左小右大 
//1101
#include<bits/stdc++.h>
using namespace std;
vector<long long > init,ccopy;
set<long long> ans;
//const int inf=100000000;//10^9最大值少一个0都不行 
const int inf=1000000000;
int main(){
	int n;
	long long _1;
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("%lld",&_1);
		init.push_back(_1);
	}
	ccopy=init;
	int bookmin[n],bookmax[n],mx=0,mn=inf;
	fill(bookmin,bookmin+n,inf);
	//fill(bookmax,bookmax+n,0);
	for(int i=n-1;i>=0;i--){
		if(ccopy[i]<mn){
			mn=ccopy[i];
			bookmin[i]=mn;
		}
	}
	sort(init.begin(),init.end());
	for(int i=0;i<n;i++){
		if(ccopy[i]>mx) mx=ccopy[i];
		if(init[i]==ccopy[i]&&ccopy[i]>=mx&&ccopy[i]<=bookmin[i]){//不是init  init已经排过序了应该是原序列的情况 
			ans.insert(ccopy[i]);
		}
	}
	printf("%d\n",ans.size());
    for(auto it=ans.begin();it!=ans.end();it++){
    	 if(it!=ans.begin()) printf(" ");
    	 printf("%lld",*it);
	}
	printf("\n");
	return 0;
}

二分查找  while(low<high)时返回位置 while(low<=high) 返回存不存在信息

//1010  //用了long long 一些正确了 
#include<bits/stdc++.h>
using namespace std;
string n1,n2;
long long int swit(char a){
	if(isdigit(a)){
		return a-'0';
	}else{
		return a-'a'+10;
	}
}
long long int findmax(string b){
	long long int max=-1;
	for(int i=0;i<b.size();i++){
		long long int _2=swit(b[i]);
		if(_2>max){
			max=_2;
		}
	}
	return max;
}
long long int jvswit(string c,long long int radix){
	long long int sum=0,cnt=0;
	for(int i=c.size()-1;i>=0;i--){
		sum+=swit(c[i])*pow(radix,cnt);
		cnt++;
	}
	return sum;
}
long long int erff(string d,long long int low,long long int high,long long int aim){
	while(low<=high){
      long long  int mid=(low+high)/2;
      long long  int _6=jvswit(d,mid);
	   /* if(_6<aim){//溢出也可能小于如果放在上面会误判溢出点  ，if else 当不是相互独立又相互包含关系时，顺序也非常重要 
		low=mid+1;
     	}*/
		 if(_6>aim||_6<0){//位数太多可能溢出 
			high=mid-1;
		}else if(_6==aim){
			return mid;
		}else{
			low=mid+1;//将这里的判断条件顺序改了就过了 
		}
	}
	return -1;
}
int main(){
	long long int tag,radix,_1,_2,_3,_4;
	cin>>n1>>n2>>tag>>radix;
	if(tag==1){
	 _1=jvswit(n1,radix);
	 _2=findmax(n2);
	 _4=max(_2+1,_1);//测试点1考察high不一定比low大此时要特判 
	 _3=erff(n2,_2+1,_4,_1);
	 if(_3==-1){
	 	printf("Impossible");
	 	return 0;
	 }else{
	 	printf("%d",_3);
	 }
	}else{
		_1=jvswit(n2,radix);
	 _2=findmax(n1);
	  _4=max(_2+1,_1);
	 _3=erff(n1,_2+1,_4,_1);
	 if(_3==-1){
	 	printf("Impossible");
	 	return 0;
	 }else{
	 	printf("%d",_3);
	 }
	}
	return 0;
}

总结

有很多小细节 需要注意 二分查找里long long 溢出判断 if else 上下相互包含要注意顺序

归并排序 每一组之间未必有大小关系

堆排序 全局算法 向下调整

快速排序  除了位置要在最终位置上 还要满足左小右大

直接插入排序 不是全局性算法，注意他的验证方法

加油 棒棒da~

 

 

 

 

江船夜雨听笛
关注
专栏目录
数据结构和算法：各种数据结构和算法的实现-链表，堆栈，队列，二进制搜索树，AVL树，红黑树，特里，图算法，排序算法，贪婪算法，动态编程，段树等等
02-05
C / C ++中的数据结构和算法 该代码由Amit Bansal在学习数据结构和算法时编写。 参考GFG，NPTEL，CLRS。 该存储库包含： 单链表。 添加两个数字表示的链表。 气泡在链接列表中排序合并在链接列表中排序合并排序链表反向使用或不使用堆栈的单链表 双链表。 循环链表。 排序插入 使用数组和链接列表进行堆栈。 使用数组和链接列表排队。 优先队列。 排序： 气泡排序堆排序插入排序合并排序快速排序选择排序 二进制搜索树 插入删除中预定遍历顺序遍历后遍历级别顺序遍历查找二叉搜索树的高度检查树是否为二叉搜索树（2种方法） 在二分搜索树中查找最大和最小元素 AVL树 插入b。删除
【算法】【排序】【JS】JS十大排序算法
进步青年
03-14 208
JS十大排序算法 1.冒泡排序： 两两比较，每次最小的元素往前冒，每轮选出一个当前最小的排在当前的最前面 function bubbleSort(arr){ let len = arr.length for(let i = 0;i < len - 1;i++){ //len个元素比较len-1轮 // var changeFlag = 0 //哨兵 判断是否已经排好序了 for(let j = len - 1;j > i; j--)
PAT甲级训练合集（1-70）
qq_51704853的博客
08-14 3279
题目链接：题目详情 - 1001 A+B Format (pintia.cn)题目大意：将两个数A和B相减，每隔3个数输出一个空格（注意，从后往前数）思路：如果是负数先把负号去掉，用一个字符串存入答案，从后往前，数到3个数存入一个逗号，并且吧cnt更新为0，用reverse函数倒过来输出实现代码： P1002 题目链接：题目详情 - 1002 A+B for Polynomials (pintia.cn)题目大意：输入两行，每行第一个为k，当前行多项式的数量，随后给出k组，N为指数，ai为项数将所有指
八大排序算法
iteye_14589的博客
04-18 115
转载处 http://blog.csdn.net/hguisu/article/details/7776068 概述 排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。 我们这里说说八大排序就是内部排序。 当n较大，则应采用时间复杂度为O(nlog2n)的排...
保研机试——1基础算法（排序、哈希、模拟（日期、图形、查找、进制、字符串）、递归与分治、贪心、前缀和与差分、双指针）
ZhengrongYue的博客
09-20 2207
保研机试——1基础算法（排序、日期、哈希、排版、查找、贪心）
PAT甲级按题型分类
TypicalSpider的博客
03-30 2867
PAT甲级按题型分类 1. 水题篇 2. 数据结构篇 2.1 线性表 结构框架 顺序结构：顺序表 链式结构：单链表、双链表、循环链表（指针）；静态链表（借助数组） 2.2 栈&队 结构框架 栈：顺序栈、链栈、共享栈 队列：循环队列、链式队列、双端队列 数组（推广）：一维数组、对维数组（压缩、稀疏矩阵） 2.3 串 结构框架 基本功概念：主串、子串、串长 存储结构：定长顺序存储、堆分配存储、块链存储 模式匹配算法：暴力匹配、KMP算法（部分匹配值表、next数组、next函数的推理）、kmp
PAT甲级以及其他算法题 - 记录
WanDerIngcc的博客
01-21 308
A+B Format：d/1000%1000写成了d%1000%1000 A+B for Polynomials：：map的使用，在map声明的第三个参数为结构cmp，用于map内部本身的排序，,map使用和数组一样map[i] =1；此处复习了迭代器的循环，直接用auto，对MAP、vector这类都是.begin，.end来循环遍历 Emergency：DFS~ Counting Leaves：计算没有孩子的节点，函数递归计算即可 Spell It Right：简单模拟 Sig..
PAT甲级考试的题解和分类
邹九的个人博客
05-15 260
1076. 和普通的节点不相同的图不相同，这里的节点可能会重复，同个follower可能存在多层的，deepth first 会存在先访问了左侧的3然后令状态=true，然后右侧节点的3之后的follower就访问不到了，所以最好用width first加status判断是否访问过，是层序遍历，所以不会出现deepth first的情况。尽量不要使用map，set遍历，速度会很慢，直接用大数组，vector推荐，不推荐vector！左子树在后序中的根结点为。
PAT甲级刷题记录
TypicalSpider的博客
03-30 1293
文章目录前言甲级题库的正确刷题顺序题目列表&分类按题号排序1001-11001101-1150按题型排序1. 水题篇2. 数据结构篇2.1 线性表2.2 栈&队2.3 串2.4 树与二叉树2.5 图2.6 查找2.7 排序3. 字符串篇4. 数学问题篇学习笔记部分题型的技巧套路编程语法小技巧备忘陌生单词语句整理标点符号和数学符号所对应的英文 前言 按往年来看，每次考试中乙级的最后两题是甲级的前两题的中文版。按姥姥的建议，如果对于乙级题目： 15分题能10分钟完成 20分题能30分钟完成 2
PAT甲级刷题分类整理
cutefery的博客
08-28 559
PAT甲级刷题继续！做题按照分类刷比较好，参考了很多博客，按照如下整理，如果后续分类上有更为细分的地方也会编辑这篇博文哒。我也会在更新各小类题型的博文后，在各个分类题型上附上超链接。 ** 一、数学问题 1、数学问题 1008、1049、1069、1104、1132、 2、逻辑题 1093、1109、1116、1117、1128、 3、科学计数法 1060 4、分数四则运算 1081、1088 （最大公约数 最小公倍数） 素数 101
pat编程语言_【转载】PAT考试大纲, 刷题方法, 模版
weixin_36249804的博客
01-14 809
考试大纲乙级(Basic Level)考生应具备以下基本能力：1· 基本的C/C++的代码设计能力，以及相关开发环境的基本调试技巧；2· 理解并掌握最基本的数据存储结构，即：数组、链表；3· 理解并熟练编程实现与基本数据结构相关的基础算法，包括递归、排序、查找等；4· 能够分析算法的时间复杂度、空间复杂度和算法稳定性；5· 具备问题抽象和建模的初步能力，并能够用所学方法解决实际问题。甲级(Adva...
PAT甲级
qq_42347617的博客
02-24 1217
编号 标题 题解 分类 备注 1001 A+B Format C++ 字符串处理 1002 A+B for Polynomials C++ 中级模拟+散列 多项式求和问题 1003 Emergency C++ 图 最短路径问题 1004 Counting Leaves C++ 树 树的遍历问题 1005 Spell It Right C++ 字符串处理 10...
夏令营复习准备
qq_32769481的博客
11-21 5507
文章目录算法学习资源数据结构交大计算机题目数学高等数学**离散数学**概率论线性代数逻辑推理题科研经历AI人工智能机器学习的现状和未来机器学习软件工程软件工程软件测试计算机基础操作系统数据库计算机网络计算机组成原理编译原理云计算英语阅读能力写作能力英文面试问题项目项目问题个人情况资料简历个人陈述学校LAMDA材料申请和lamda面试夏令营机试面试资料撰写交大计算机北大cha院北大信科资源计算机各种...
CCCC练习题的题解-给新人看的
热门推荐
qyl916的专栏
07-12 1万+
我分到的是模4余0和余1的题目 先上公共头文件 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define rep(i,n) for(int i=0;i<(n)
【数据结构】
努力再努力
02-21 2811
数据结构数据结构一、链表1.链表分类2.链表结构与实现3.插入与删除节点，节点的交换4.链表的销毁、复制、遍历、反转5.判断回文链表、链表是否相交6.链表按值排序，链表模拟加法，有序链表合并7.链表获取节点首地址，查找特点节点位置，统计节点个数8.快慢指针（1）求链表中间节点（2）找到倒数第n个节点（3）判断链表是否有环二、栈和队列1.链式栈（1）栈的定义与初始化（2）常规操作2.普通队列（1）数组实现（存在假溢出）（2）链表实现3.循环队列4.优先队列（二叉堆存储结构）三、字符串1.字符串的比较、排序、查
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..
pat7-107-10 公路村村通
最新发布
06-10
这个算法的基本思想是先将所有的边按照代价从小到大排序，然后依次加入到最小生成树的集合中，如果加入这条边不会形成环路，就将这条边加入最小生成树集合中。 具体实现时，可以使用并查集来检查是否形成环路。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值