csp-201903

已于 2022-09-04 15:48:35 修改
阅读量319 收藏
点赞数
分类专栏： 算法竞赛 文章标签： 算法
于 2022-02-25 10:49:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58642116/article/details/123127389
版权

201903

题目一：小中大【100分】

  1. 时间，内存限制小，数据范围小，简单排序获得最大最小，中位数（处于序列中间位置的数）
  2. 认真读题，注意题目输出要求，中位数是小数保留一位小数，中位数是整数直接输出，并且最大值，最小值一定是整型，直接输出，
    cout<<fixed<<setprecision(1)<<mid <<min，这种控制精度连续输出会导致min也受保留小数位的影响，要分开输出
  3. 整型中位数和小数中位数要分开，
    不能统一定义为int类型中位数-------------无法保留一位小数
    不能统一定义为double类型中位数-------------有精度误差，输出会出错
    问题：
    在C++中，我们会将double、float类型转换成int型，准确的说，将double、float类型取整，会出现以下问题：
    double dTemp1=1.0000;
 
	double dTemp2=5.0000;
 
	int iTemp1=(int)dTemp1; 
 
	int iTemp2=(int)dTemp2;

结果

        iTemp1=0;      //dTemp1是1.00000,但是实际很可能是0.999999,当然截取整数部分,就成了0
 
        iTemp2=4;      //dTemp1是5.00000,但是实际很可能是4.999999,当然截取整数部分,就成了4

如果统一声明double类型中位数，当中位数为整数时cout输出会先将double类型转换为int类型，此时输出就会因为精度误差导致答案错误
AC代码

#include<bits/stdc++.h>
using namespace std;
#define MAXSIZE 10000000
int n;
int num[MAXSIZE];
int main()
{
	cin>>n;
	for(int i=0;i<n;i++)
	{
		cin>>num[i];
	}
	int max,min;     //整型数组，最大最小值一定为整数 
	double mid_d=0;  //分数型中位数
	int mid_i=0;     //整数型中位数
	sort(num,num+n);
	max=num[n-1];
	min=num[0];
	int t=0;
	if(n%2)  //奇数个 
	 mid_i=num[(n-1)/2];
	else 
	{
		int a=num[(n-1)/2];
		int b=num[(n+1)/2];
		t=a+b;
		if(t%2)	mid_d=t/2.0;    //计算过程中有一个为double类型，结果就为double类型
		else mid_i=t/2;
	}
	if(t%2)
	{
		cout<<max<<" "<<fixed<<setprecision(1)<<mid_d<<" ";	
	}
	else
	{
		cout<<max<<" "<<mid_i<<" ";
	}
	cout<<min;
	return 0;
}

其实我们也观察到了，中位数要么是整数，要么就小数位为.5，所以也可以抓住这点，直接对中位数输出进行处理

#include<bits/stdc++.h>
using namespace std;
#define MAXSIZE 10000000
int n;
int num[MAXSIZE];
int main()
{
	cin>>n;
	for(int i=0;i<n;i++)
	{
		cin>>num[i];
	}
	int max,min;
	int mid=0;
	sort(num,num+n);
	max=num[n-1];
	min=num[0];
	int t=0;
	if(n%2)  //奇数个 
	 mid=num[(n-1)/2];
	else 
	{
		int a=num[(n-1)/2];
		int b=num[(n+1)/2];
		t=a+b;
		mid=t/2;
	}
	if(t%2)
	{
		cout<<max<<" "<<mid<<".5 ";	
	}
	else
	{
		cout<<max<<" "<<mid<<" ";
	}
	cout<<min;
	return 0;
}

心得体会

  1. 做题前先读题，看清题目要求，分析数据范围，输入输出要求，时间限制，内存限制
  2. 尽量不要double、int混用，不必要情况不进行他俩的转换，很容易出错，cout输出会默认将小数转化为整数输出

题目五：317号子任务【100分】

这个题我自己挣扎了很久，最多只能95分，实在拿不了100分，
最后参考别人的博客，使用SPFA算法，拿了100
在这里插入图片描述
在这里插入图片描述
真就是一步一步探索了很久，后面我也分析了两篇拿100分的博主的代码，学习了一下，确实很佩服他们

30分： Floyd和基础dijistra、邻接矩阵表示图
60分： 最短的k个排序得到不优化
80分：cin cout
95分：搞不清楚 scanf printf 优化dijistra 优化找最小k个
思路分析

  1. 求取最短路径时只求行星发动机据点到所有点的最短距离；行星发动机据点->普通点距离 =普通点->行星发动机据点距离
  2. 使用邻接链表存图，vector数组
  3. 使用迪杰斯特拉算法，并且使用堆优化，priority
  4. 求前k个的算法需要优化：具体思路是使用一个大根堆，这个堆的最大大小是k个。在堆的size比k小的时候，向堆中push元素；在堆size>=k的时候，比较堆顶值和到当前行星据点距离，如果堆顶值大于到当前行星据点的距离，就将堆顶pop出，push新的到当前行星据点的距离。这样寻找前k个的复杂度是nklogk。

时间复杂度分析

  1. Floyd算法和Dijistra算法求所有顶点相互间的最短距离：n^3
  2. 使用堆优化的Dijistra：n* n *logn
  3. 普通排序查找前k个元素，一般直接用sort：nlogn * k
  4. 堆优化查找前k个元素：nklogk
    这些都是粗略的估计值，具体见另外一篇博客
    四种最短路径算法详细分析

AC代码实现
85分代码，注释、函数都不敢写，写了分数就会变动

#include<bits/stdc++.h>
using namespace std;
#define MAXSIZE 10005
#define INFI 100000000
int n,m,k;
typedef struct Node
{
	int id;
	int W;
}AdjNode,*Adj;
struct cmp{
    bool operator()(const Adj a,const Adj b){
        return a->W > b->W;
    }
};
vector<Adj>List[MAXSIZE];
int sign[MAXSIZE];
int dist[MAXSIZE];
bool visited[MAXSIZE];
priority_queue<int,vector<int>>path[MAXSIZE];
priority_queue<Adj,vector<Adj>,cmp>que;   //按边权值从小到大排序队列 

int main()
{
	//cin>>n>>m>>k;
	scanf("%d %d %d",&n,&m,&k);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&sign[i]);
	}
	for(int i=0;i<m;i++)
	{
		int u,v,w;
		//cin>>u>>v>>w;
		scanf("%d %d %d",&u,&v,&w);
		if(u==v) continue;
		Adj a=new AdjNode;
		a->id=v;
		a->W=w;
		List[u].push_back(a);
		Adj b=new AdjNode;
		b->id=u;
		b->W=w;
		List[v].push_back(b);
	}
	
	for(int i=1;i<=n;i++)
	{
		if(sign[i])
		{
			for(int j=1;j<=n;j++) 
			{
				dist[j]=INFI;
				visited[j]=false;
			}
			dist[i]=0;
			Adj t=new AdjNode;
			t->id=i;
			t->W=0;
			que.push(t);      
			while(!que.empty())
			{
				Adj t_adj=que.top();
				que.pop();   
				if(visited[t_adj->id]) continue; 
				
				int min_i=t_adj->id;
				visited[min_i]=true;
				int len=List[min_i].size();
				for(int j=0;j<len;j++)
				{
					int t=List[min_i][j]->id;
					if(!visited[t]&&dist[min_i]+List[min_i][j]->W<dist[t])
					{
						dist[t]=dist[min_i]+List[min_i][j]->W;
						Adj p=new AdjNode;
						p->id=t;
						p->W=dist[t];
						que.push(p);
					}
				}
			} 
			
			for(int j=1;j<=n;j++)
			{
				if(dist[j]!=INFI) 
				{
					if(path[j].size()<k)	
					path[j].push(dist[j]);
					else
					{
						int t_adj=path[j].top();
						if(t_adj>dist[j]) 
						{
							path[j].pop();
							path[j].push(dist[j]);
						}
 					}
				}
			}
			
		}
	}
	
	for(int i=1;i<=n;i++)
	{
		int sum=0;
		int j=0;
		while(!path[i].empty())
		{
			sum+=path[i].top();
			path[i].pop();
		}
		printf("%d\n",sum);
	}
	return 0;
}

下面这个是相应的解释，代码都是一样的，只不过加了一些注释，交上去分数就不一样

#include<bits/stdc++.h>
using namespace std;
#define MAXSIZE 10005
#define INFI 100000000
int n,m,k;
typedef struct Node
{
	int id;
	int W;
}AdjNode,*Adj;
struct cmp{   //自定义优先级，返回true表示前者优先级更低（与排序刚好相反） 
    bool operator()(const Adj a,const Adj b){
        return a->W > b->W;
    }
};
vector<Adj>List[MAXSIZE];  //vector数组实现邻接表 
int sign[MAXSIZE];
int dist[MAXSIZE];
bool visited[MAXSIZE];
priority_queue<int,vector<int>>path[MAXSIZE];   //最大堆存每个点所能到达的行星据点的距离 
priority_queue<Adj,vector<Adj>,cmp>que;   //按边权值从小到大排序队列 
void Dijistra()   
{
	for(int i=1;i<=n;i++)
	{
		if(sign[i])   //只判断行星据点到其他点的最短距离 
		{
			for(int j=1;j<=n;j++) //初始化 
			{
				dist[j]=INFI;
				visited[j]=false;
			}
			dist[i]=0;
			Adj t=new AdjNode;
			t->id=i;
			t->W=0;
			que.push(t);      //将起点纳入最小堆中，堆顶元素为到当前到起点最近的点 
			while(!que.empty())  
			{
				Adj t_adj=que.top();  //获得堆顶元素（未收纳的顶点距离起点最近的点） 
				que.pop();   
				if(visited[t_adj->id]) continue;  //该点已经收纳到结果集合了，获取下一个 
				
				int min_i=t_adj->id;
				visited[min_i]=true;  //纳入集合 
				int len=List[min_i].size();
				for(int j=0;j<len;j++)   //判断该点受影响的邻接点 
				{
					int t=List[min_i][j]->id;
					if(!visited[t]&&dist[min_i]+List[min_i][j]->W<dist[t])
					{
						dist[t]=dist[min_i]+List[min_i][j]->W;
						Adj p=new AdjNode;
						p->id=t;
						p->W=dist[t];
						que.push(p);   //将离起点距离变短的点纳入最小堆 
					}
				}
			} 
			
			for(int j=1;j<=n;j++)   //求出每个行星据点到其他所有点的最小距离时就将该距离添加到每个行星据点队列后面 
			{                        //并且只存储前k个，多于k个就将最大堆的堆顶元素拿出来 
				if(dist[j]!=INFI) 
				{
					if(path[j].size()<k)	
					path[j].push(dist[j]);
					else
					{
						int t_adj=path[j].top();
						if(t_adj>dist[j]) 
						{
							path[j].pop();
							path[j].push(dist[j]);
						}
 					}
				}
			}
			
		}
	}
}
void Solve()    //输出每个据点队列的行星据点距离并求和 
{
	for(int i=1;i<=n;i++)
	{
		int sum=0;
		int j=0;
		while(!path[i].empty())
		{
			sum+=path[i].top();
		//	cout<<path[i].top()<<" ";
			path[i].pop();
		}
	//	cout<<endl;
	//	cout<<sum<<endl;
		printf("%d\n",sum);
	}
}
int main()
{
	//cin>>n>>m>>k;
	scanf("%d %d %d",&n,&m,&k);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&sign[i]);   //读入据点类型 
	}
	for(int i=0;i<m;i++)
	{
		int u,v,w;
		//cin>>u>>v>>w;
		scanf("%d %d %d",&u,&v,&w);
		if(u==v) continue;
		Adj a=new AdjNode;  //无向图，两个顶点都要进行操作 
		a->id=v;
		a->W=w;
		List[u].push_back(a);
		Adj b=new AdjNode;
		b->id=u;
		b->W=w;
		List[v].push_back(b);
	}
	Dijistra();
	Solve();
	return 0;
}

满分代码
自己最终写的：

#include<bits/stdc++.h>
using namespace std;
#define MAXSIZE 10005
#define INFI 100000000
int n,m,k;
typedef struct Node
{
	int id;
	int W;
}AdjNode,*Adj;
vector<Adj>List[MAXSIZE];  //vector数组实现邻接表 
int sign[MAXSIZE];
int dist[MAXSIZE];
bool inq[MAXSIZE];
priority_queue<int,vector<int>>path[MAXSIZE];   //最大堆存每个点所能到达的行星据点的距离 
queue<int>node;    
void Spfa()   
{
	for(int i=1;i<=n;i++)
	{
		if(sign[i])   //只判断行星据点到其他点的最短距离 
		{
			for(int j=1;j<=n;j++) //初始化 
			{
				dist[j]=INFI;
				inq[j]=false;
			}
			dist[i]=0;
			node.push(i);      //将起点纳入队列中 
			inq[i]=true;
			while(!node.empty())  
			{
				int min_i=node.front();  //得到队列元素并出队 
				node.pop();   
				
				inq[min_i]=false;  //元素出队 
				int len=List[min_i].size();
				for(int j=0;j<len;j++)   //对该点有影响的邻接点都进行松弛 
				{
					int t=List[min_i][j]->id;
					if(dist[t]>dist[min_i]+List[min_i][j]->W)
					{
						dist[t]=dist[min_i]+List[min_i][j]->W;
						if(!inq[t])    //把不在队列里的元素入队 
						{
							node.push(t);
							inq[t]=true;
						}
					}
						
				}
			} 
			
			for(int j=1;j<=n;j++)   //求出每个行星据点到其他所有点的最小距离时就将该距离添加到每个行星据点队列后面 
			{                        //并且只存储前k个，多于k个就将最大堆的堆顶元素拿出来 
				if(dist[j]!=INFI) 
				{
					if(path[j].size()<k)	
					path[j].push(dist[j]);
					else
					{
						int t_adj=path[j].top();
						if(t_adj>dist[j]) 
						{
							path[j].pop();
							path[j].push(dist[j]);
						}
 					}
				}
			}
			
		}
	}
}
void Solve()    //输出每个据点队列的行星据点距离并求和 
{
	for(int i=1;i<=n;i++)
	{
		int sum=0;
		int j=0;
		while(!path[i].empty())
		{
			sum+=path[i].top();
		//	cout<<path[i].top()<<" ";
			path[i].pop();
		}
	//	cout<<endl;
	//	cout<<sum<<endl;
		printf("%d\n",sum);
	}
}
int main()
{
	//cin>>n>>m>>k;
	scanf("%d %d %d",&n,&m,&k);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&sign[i]);   //读入据点类型 
	}
	for(int i=0;i<m;i++)
	{
		int u,v,w;
		//cin>>u>>v>>w;
		scanf("%d %d %d",&u,&v,&w);
		if(u==v) continue;
		Adj a=new AdjNode;  //无向图，两个顶点都要进行操作 
		a->id=v;
		a->W=w;
		List[u].push_back(a);
		Adj b=new AdjNode;
		b->id=u;
		b->W=w;
		List[v].push_back(b);
	}
	Spfa();
	Solve();
	return 0;
}
  1. 参考这篇100分的文章，我的思路跟他的几乎一样
    317任务100分
  2. SPFA算法100分，参考这篇博文
    https://blog.csdn.net/weixin_41297324/article/details/110733559
feng**
关注
专栏目录
CCF-CSP 201903-1：小中大（100分）“附踩坑之后痛的领悟”
Love_Star_的博客
11-25 742
请认真读题认真读题认真读题 重要的事情说三遍 不然容易心态爆炸哦 问题分析： 第一行先读取一个整数N，然后第二行读取N个整数（默认已经有序，所以不排序） 分别取最大值，最小值和中位数然后输出。 #include<iostream> using namespace std; int a[100005]; class Qu20190301{ private: int N; ...
CCF CSP-201903-2 二十四点（C++）
weixin_45964844的博客
12-04 365
#include <cstdio> #include <iostream> #include <stack> #include <string> using namespace std; int main(){ stack<int> st; int n; scanf("%d", &n); getchar(); while(n != 0){ string s; getline(cin,s); int i..
CSP 201903
yingzhengttt blog
11-01 206
201903-1 小中大 简单模拟，不解释 import java.util.Scanner; public class Main{ public static void main(String arg[]){ Scanner in = new Scanner(System.in); int size = in.nextInt(); b...
CSP 201903-1
fontain的专栏
06-01 759
#include <iostream> #include <iomanip> #include <cstdio> using namespace std; int main() { int N; //freopen("d:\\a.txt","r",stdin); cin>>N; float *n=new float...
CSP201903-2二十四点
hyffff的博客
12-28 225
如图所示先处理乘号和除号，再处理加减。 #include<bits/stdc++.h> using namespace std; bool res[101]; int main(){ int n; cin>>n; int i,j,op1,op2; string inp; char op[3]; int nn[4]; ...
csp 201903-3
fontain的专栏
06-04 529
#include <iostream> #include <cstdio> #include <cstring> using namespace std; struct DiskData { unsigned char * data; void analyseStr(string str) { data=new unsi...
CCF CSP-201903-1 小中大（C++）
weixin_45964844的博客
12-04 183
#include <cstdio> #include <iostream> #include <algorithm> #include <cmath> using namespace std; int main(){ int n; scanf("%d", &n); int num[n]; for(int i=0; i<n; i++){ scanf("%d", &num[i]); } sort(num, nu..
CSP - 201903-1 - 小中大 （C++）
C橘子
07-27 1136
试题编号 201903-1 试题名称 小中大 时间限制 1.0s 内存限制 512MB #include <iostream> using namespace std; int main(){ int n, mid1, mid2, temp, max, min; float mid; cin>>n; //输入n cin>>temp; //输入第...
CSP - 201903-2 - 二十四点 （C++）
C橘子
08-02 3629
解题思路 由于输入格式固定，所以比较好计算。 首先创建一个操作数栈和一个运算符栈，读入的字符分别进栈，当运算符栈读入的为+号时不动，读入减号时将后一个操作数转换为负数（-1*x），读入乘除时出栈两个操作数进行运算，将结果入栈，最后将剩余的运算符进行加法操作。 注意 几个注意点： 除法时需要注意除数与被除数的顺序。 减号转换为加负数是因为：如果有一个表达式为 a-b*c-d 时c-d的-号视为...
[CSP-J 2019]纪念品 题解
weixin_45523071的博客
12-11 2047
洛谷链接 考场上想了两个钟没想出来，自闭了。 相信是一位掌握DP的同学都看得出来这道题一定是DP，但估计没几个人可以一眼看出来。 我绝望地看了眼T4，然后完全绝望…… 进入正题 我们先从一个个点来说。 10% 这应该是最简单的了，直接输出即可…… 15%（1） 这里，我们只需用到贪心来做。 当一段连续上升的数出现后，直接在最高点套现，然后在第二天买入，即可得到最优解。 附上代码段 int i=1...
CSP201903-1 小中大 (Python)
qq_45899597的博客
02-03 642
文章目录题目程序代码 题目 试题编号： 201903-1 试题名称： 小中大 时间限制： 1.0s 内存限制： 512.0MB 题目背景 　　在数据分析中，最小值最大值以及中位数是常用的统计信息。 题目描述 　　老师给了你n个整数组成的测量数据，保证有序（可能为升序或降序），可能存在重复的数据。请统计出这组测量数据中的最大值、中位数以及最小值，并按照从大到小的顺序输出这三个数。 输入格式 　　从标准输入读入数据。 　　第一行输入一个整数n，在第二行中存在n个有序的
CSP 201903-1 小中大
佚失的诗篇
02-08 336
一、题目 二、坑点 注意一下N=0和N=1的特殊情况 四舍五入的写法 利用cmath.h中的round函数保留一位小数round(mid*10)/10.0 利用运算符性质保留一位小数(int)(x*10)/10.0 这个题实际上小数位只可能是0.5，直接输出一位精度也可以的 输出格式：注意中位数可能是整数或小数，输出必须分开写才能满足要求 如果以整数形式输出一个double数，必须强制...
CSP认证刷题【201903】
Win_Dan的博客
12-05 307
CSP认证刷题【201903】 201903-1【小中大】 思路 由题可知数据一定是有序的，递增排序下第一个数是最小值，最后一个数是最大值；递减排序下第一个数是最大值，最后一个数是最小值。 那么可以通过一个数组int[] a = new int[N]保存输入的数据，这样能够快速取得第一个数和最后一个数，方便取得最大值和最小值。 中位数可以通过N/2得到位置，如果N是奇数，那么中位数为...
CSP201903-1小中大
学习记录
09-21 287
题目要求： 要求输入有序的整数序列，最多不超过100000个，从中找出最大值、最小值、中位数。 题目分析： 既然序列是有序的，那么最值一定出现在两端，根据输入的n是奇数还是偶数来采用不同的方法求中位数，最后注意判断中位数是否为小数即可。 #include<iostream> #include<iomanip> using namespace std; int main() ...
CSP 201903-2 二十四点
欢迎光临 我的心
09-04 112
void solve() { string s;cin>>s; stack<int>num; stack<char>op; for(int i=0;i<(int)s.size();++i) { char c = s[i]; if(c>='1'&&c<='9') num.push(c-'0'); else {
csp201903-4
weixin_43874491的博客
07-23 256
csp201903-4 一、getline()数的总结 getline()函数是一个比较常见的函数，用这个函数完成读入一行数据 在C++中getline()函数的有两种，一种是在头文件中，是食istream类的成员函数，另一种在头文件中，是普通函数 第一种：在中的getline()函数有两种重载形式： istream&getline(char* s,streamsize n); istre...
CSP 201903-2
fontain的专栏
06-01 327
#include <iostream> #include <cstdio> #include <stack> using namespace std; int priority(char op){ return op=='+'||op=='-'?0:1; } int compareOp(char op1,char op2){ return pr...
csp 201903-2 二十四点
weixin_45667965的博客
02-15 153
201903-2 二十四点 理解：写一个简单的计算器程序，判断结果是否为24； 计算器程序原理： 1.中缀表达式 转为 后缀表达式 2.计算后缀表达式 3.涉及到 计算符号的 优先级 参考： 代码 //24点 #include<iostream> #include<stack> #include<string> using namespace std; in...
csp 201903-2 二十四点
qq_43209531的博客
06-20 213
解答： #include <stdio.h> #include <stdlib.h> #include <limits.h> int result(int a,int b,char ch){ int res=0; switch(ch){ case '+': res = a+b; break; case '-': res = a-b; break; case 'x': res = a*b; break; cas..
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值