2021 RoboCom 世界机器人开发者大赛-本科组（初赛）已完结

已于 2024-08-01 12:32:04 修改
阅读量477 收藏 3
点赞数 5
分类专栏： 算法 文章标签： 算法 c++ 图论
于 2024-06-29 15:42:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68536532/article/details/140065232
版权

目录

7-1 懂得都懂

 具体代码实现：

7-2 芬兰木棋

具体实现代码:

7-3 打怪升级

​编辑​编辑

具体实现代码：

1.采用dijkstra实现

2. 采用floyed实现 

7-4 疫情防控

具体代码实现：

题目链接：PTA | 程序设计类实验辅助教学平台 (pintia.cn)

7-1 懂得都懂

    输入样例：

5 3
4 8 12 20 40
3 11 16 19
3 12 16 19
10 11 11 11 11 11 11 11 11 11 11

输出样例：

Yes
No
Yes

 具体代码实现：

//思路：每个数据都可以由原图任意4个不同数据的平均值计算而来
//1. 如果我们用一个数组来存储4个数据的和->数组大小为50*49*48*47(int足够）
//但是在查询的时候，需要每次进行一个遍历(高达200*200) ->不使用 
//2. 原图四个值的和最大为 255*4,如果该值存在则标记为1，
//在查询值的时候只需查询该值是否为1即可。 
#include<bits/stdc++.h>
using namespace std;
int f[1100],a[60],news[210]; //记录原图四个数据和、原图特征数据、新图特征数据 
int m;
bool judge(){
	for(int i=0;i<m;i++){
		int t=news[i]*4;
		if(!f[t])
			return false; 
	}
	return true;
}  
int main(void){
	int n,k; //原图的特征数据个数、新图的张数
    cin>>n>>k;
	for(int i=0;i<n;i++){ 
		cin>>a[i];   //a存储原图特征数据 
	}
	//1.记录原图任意四个数据的和(不用平均导致小数)
	for(int i=0;i<n;i++){
		for(int j=i+1;j<n;j++){
			for(int k=j+1;k<n;k++){
				for(int l=k+1;l<n;l++){
					int t=a[i]+a[j]+a[k]+a[l];
					f[t]=1;
				}
			}
		}
	}
	for(int i=0;i<k;i++){
		cin>>m;
		for(int j=0;j<m;j++){
			cin>>news[j];
		}
		if(i!=0)
			cout<<endl;
		if(judge())
			cout<<"Yes";
		else
			cout<<"No";	 
	} 
	 
}

7-2 芬兰木棋

输入样例：

11
1 2 2
2 4 3
3 6 4
-1 2 2
-2 4 3
-3 6 4
-1 -2 1
-2 -4 1
-3 -6 1
-4 -8 2
2 -1 999

输出样例：

1022 9

具体实现代码:

//思路：贪心
//1. 怎么获得的分数最多,次数最少 
//木棋分数>1,+木棋上的分数（一次一根） 
//木棋分数<=1,判断连续<=1的个数，一次击倒
//显而易见：最多分为木棋上的值的和 
//2. 怎么确认方向
//1)最开始我想的是k,但是在k相等的条件下有两个方向—>不使用
//2）找到x,y两个位置的最大公约数(正)，除以公约数之后相同则表示同一方向（因为正负不会发生改变）
//3. 怎么在同一方向下距离由小到大排序
//存储距离--》x平方+y平方，还需要存储木棋值
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
map<pair<ll,ll>,vector<pair<ll,ll> > >mp;
int main(void){
	int n;
	ll x,y,p;
	cin>>n;
	ll smax=0,nmax=0;  //最大得分、最少次数 
	for(int i=0;i<n;i++){
		cin>>x>>y>>p;
		int t=abs(__gcd(x,y));  //得到最大公约数
		mp[{x/t,y/t}].push_back({x*x+y*y,p}); 
		smax+=p; 
	}
	for(auto it:mp){  //使用for循环，则访问用. 
		vector<pair<ll,ll> >t=it.second;
		sort(t.begin(),t.end());
		for(int i=0;i<t.size();i++){
			if(t[i].second!=1)
				nmax++;
			else{
				if(t[i+1].second!=1||i+1==t.size())
					nmax++;
			}
		}
	}
	cout<<smax<<" "<<nmax;
	return 0;
}

tips:

遍历 map：可以使用迭代器或者范围 for 循环。

  • 迭代器：for (auto it = map.begin(); it != map.end(); ++it)

  • 范围 for 循环：for (const auto& pair : map)

访问 map 的元素：

  • 使用迭代器：it->first, it->second

  • 使用范围 for 循环：pair.first, pair.second

访问 pair 的元素：pair.first, pair.second

7-3 打怪升级

 

输入样例：

6 12
1 2 10 5
2 3 16 20
3 1 4 2
2 4 20 22
4 5 2 2
5 3 12 6
4 6 8 5
6 5 10 5
6 1 20 25
1 5 8 5
2 5 2 1
2 6 8 5
4
2 3 6 5

  输出样例： 

5
5->2
2 1
5->1->3
12 7
5->4->6
10 7
5
0 0

具体实现代码：

1.采用dijkstra实现

//思路：采用迪杰斯特拉算法
//1.首先进行n次迪杰斯特拉算法得到空降堡垒编号，也就是需要我们存储每一个的最大值
//2. 求path,使用while即可
#include<bits/stdc++.h>
#define maxInt 0x3f3f3f
#define N  1010
using namespace std;
int w[N][N],v[N][N];  //能量、价值
int path[N],d[N],f[N];  //前驱点、最小能量,最大价值 
bool vis[N];  //是否被访问过 
int n,m,k; 
vector<int> p; //存储具体路径 
int  dijkstra(int s){
	memset(d,maxInt,sizeof(d));
	memset(f,0,sizeof(f));
	memset(path,-1,sizeof(path));
	memset(vis,0,sizeof(vis));
	d[s]=0;
	f[s]=0;
	for(int k=1;k<=n;k++){   //n次选点 
		//1. 寻找未被访问的点距离最小的 
		int t=-1;  //最小能量下标
		for(int i=1;i<=n;i++){
			if(!vis[i]&&(t==-1||d[t]>d[i]))
				t=i;
		}
		vis[t]=true;
		//2.更新
		for(int i=1;i<=n;i++){
			if(d[i]>d[t]+w[t][i]){
				d[i]=d[t]+w[t][i];
				f[i]=f[t]+v[t][i]; 
				path[i]=t; 
			}else if(d[i]==d[t]+w[t][i]){
				//选择价值最大的 
				if(f[i]<f[t]+v[t][i]){
					f[i]=f[t]+v[t][i];
					path[i]=t;
				}
			}
		} 
	}
	//3. 存储最大d[]值
	int ans=0;
	for(int i=1;i<=n;i++){
		if(ans<d[i])
			ans=d[i];
	} 
	return ans;
}
void findPath(int s,int d){
	p.clear(); 
	while(d!=s){  //倒叙存储，并且不包含源点 
		p.push_back(d);
		d=path[d];
	}
	p.push_back(s);
	reverse(p.begin(),p.end()); 
} 
int main(void){
	cin>>n>>m;
	//初始化
	memset(w,maxInt,sizeof(w));
	memset(v,maxInt,sizeof(v));
	memset(v,maxInt,sizeof(f));
	memset(d,maxInt,sizeof(d)); 
	memset(path,-1,sizeof(path)); 
	for(int i=0;i<m;i++){
		int b1,b2,c1,c2;
		cin>>b1>>b2>>c1>>c2;
		w[b1][b2]=w[b2][b1]=c1;
		v[b1][b2]=v[b2][b1]=c2;
	}
	for(int i=1;i<n;i++){
		v[i][i]=w[i][i]=0; //自己到自己等于0 
	}
	int x=1;
	int ans=dijkstra(1);  
	for(int i=2;i<=n;i++){
		if(ans>dijkstra(i)){
			ans=dijkstra(i);
			x=i;	
		}	
	}
	cout<<x<<endl;  //得到最佳空降位置
	dijkstra(x);
	cin>>k;
	for(int i=0;i<k;i++){
		int t;
		cin>>t;
		findPath(x,t);
		for(int j=0;j<p.size();j++){
			if(j>0)
				cout<<"->";
			cout<<p[j];
		}
		cout<<endl;
		cout<<d[t]<<" "<<f[t]<<endl;
	} 
	return 0;
}

2. 采用floyed实现 

//思路：只需要一次floyed即可
//1. 求合适空降点：对每一行w,求最大的值最小的行
//2.求路径：path递归求解
#include<bits/stdc++.h>
#define maxInt 0x3f3f3f3f
#define N 1010
using namespace std;
int n,m,k;
int w[N][N],v[N][N],path[N][N];  //能量、价值 
void floyed(){
	for(int k=1;k<=n;k++){  //k为中转点 
		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
				if(w[i][j]>w[i][k]+w[k][j]){
					w[i][j]=w[i][k]+w[k][j];
					v[i][j]=v[i][k]+v[k][j];
					path[i][j]=k;
				}else if(w[i][j]==w[i][k]+w[k][j]){
					//找总价值最高的
					if(v[i][j]<v[i][k]+v[k][j]){
						v[i][j]=v[i][k]+v[k][j];
						path[i][j]=k;
					} 
				}
			} 
		} 
	} 
}
//寻找具体路径 
void findPath(int st,int end){
	if(st==end){
		return;
	}
	if(path[st][end]==(-1)){  //不用判断w[][],因为路径肯定存在 
		cout<<"->"<<end; 
	}else{
		int mid=path[st][end];
		findPath(st,mid);
		findPath(mid,end);
	}
}
int main(void){
	cin>>n>>m;
	//初始化
	memset(w,maxInt,sizeof(w));
	memset(v,0,sizeof(v));
	memset(path,-1,sizeof(path)); 
	for(int i=1;i<N;i++){
		w[i][i]=0;
		v[i][i]=0;
	}
	for(int i=0;i<m;i++){
		int b1,b2,c1,c2;
		cin>>b1>>b2>>c1>>c2;
		w[b1][b2]=w[b2][b1]=c1;
		v[b1][b2]=v[b2][b1]=c2;
	}
	floyed();
	//找空降位置：数值最大的最小行 
	int x=0; //目标行(空降位置) 
	int ans=maxInt; //目标行的最大值 
	for(int i=1;i<=n;i++){ //n行进行计算 
		int t=0; 
		for(int j=1;j<=n;j++){ //找到第i行的w的最大值 
			if(w[i][j]>t)
				t=w[i][j];
		}
		if(ans>t){
			x=i;
			ans=t;
		}
	}
	cout<<x<<endl;
	cin>>k;
	for(int i=0;i<k;i++){
		int d;
		cin>>d;
		cout<<x;
		findPath(x,d);
		cout<<endl;
		cout<<w[x][d]<<" "<<v[x][d]<<endl;
	}
	return 0;
}

7-4 疫情防控

输入样例：

5 5 3
1 2
1 3
1 5
2 5
3 4
4 3
1 3
1 4
2 3
5 3
3 4
2 3
3 5
1 3
2 3
2 5
3 4

输出样例：

1
2
3

具体代码实现：

//题意：n个顶点m条边的无向图，每天都有一个点不可用，问是否可达
//->首先我想到的是每天遍历将其长度设为无穷，然后dfs()
//->每一次判断都要dfs+遍历vis数组；然后去点，时间复杂度太高
//于是使用并查集->加点
//思路：逆序每次加点，故需要存储每次的值
#include<bits/stdc++.h>
using namespace std;
const int N=50010;
vector<int> f[N]; //先存储结构，因为需要逆序 
int fa[N];   //存储父节点 
bool vis[N];   //true表示无法访问 
int n,m,d; //机场数、航线数、新增防控地区的天数 
int dd[N];  //表示第i天变成防空地区的编号
int ans[N];  //存储每天的结果 
map<int,vector<pair<int,int> > > mp;  //存储每天要访问的航线 
void init(){
	for(int i=1;i<=n;i++)
		fa[i]=i;
}
int find(int i){
//	if(fa[i]==i)
//		return i;
//	else{
//		fa[i]=find(fa[i]);
//		return fa[i];
//	}
	if(i!=fa[i])
		fa[i]=find(fa[i]);
	return fa[i];
}
void join(int i,int j){
	int i_fa=find(i);
	int j_fa=find(j);
	if(i_fa!=j_fa)
		fa[i_fa]=j_fa;
}
int main(void){
	cin>>n>>m>>d;
	for(int i=0;i<m;i++){
		int a,b;
		cin>>a>>b;
		f[a].push_back(b);
		f[b].push_back(a);
	}
	for(int i=1;i<=d;i++){  //d块输入 
		int c,q;
		cin>>c>>q;
		dd[i]=c;
		vis[c]=true; //true表示成为防控地区 
		for(int j=1;j<=q;j++){  //q段行程 
			int x,y;
			cin>>x>>y;
			mp[i].push_back({x,y}); 
		} 
	}
	//逆序使用并查集
	//1.初始化父节点 
	init();
	//2. 构建最后一天的连通图 
	for(int i=1;i<=n;i++){
		for(auto x:f[i]){
			if(!vis[x]&&!vis[i]){ //两点均不是疫情点 
				join(i,x); 
			}
		}
	}
	//3.逆向处理每天的起飞请求
	for(int i=d;i>0;i--){
		int res=0;
		vector<pair<int,int> >v=mp[i];
		for(int j=0;j<v.size();j++){
			int x=v[j].first;
			int y=v[j].second;
			if(find(x)!=find(y))
				res++;
		}
		ans[i]=res; 
		//4. 恢复前一天的疫情点
		int t=dd[i];
		vis[t]=false;  
		for(auto x:f[t]){
			if(!vis[x]){
				join(t,x);
			}
		} 
	} 
	for(int i=1;i<=d;i++){
		if(i!=1) cout<<endl;
		cout<<ans[i];
	}
	return 0;
}

代码自己写的，如果有啥错误欢迎指正！！！

柚131
关注
专栏目录
2022 RoboCom 世界机器人开发者大赛-本科组(国赛)
ldq18的博客
06-28 1585
题意：在5*5方格中给定终点，上下左右四个方向的怪物，在初始位置时，左右怪物顺时针移动相应行数后进行整行的激光覆盖，在移动一次位置后，上下怪物顺时针移动相应列数后进行整列的激光覆盖，您需要保证确定初始位置和移动一次后的位置，并且这两个位置不会被怪物的激光覆盖，然后可以通过指定步数到达终点。题解：模拟题，需要注意的是初始位置时是左右两侧怪物移动，上下怪物位置保持不变，而第一次移动位置后是上下两侧怪物移动，左右怪物位置保持不变。题意：给定边权为1的无向图，从起点到终点距离最短并且指定距离点权和最大。
2021 RoboCom 世界机器人开发者大赛-高职组（初赛）
superb_code的博客
07-06 493
记录一下刷题的过程，code小白，写的都是暴力。也希望这次比赛能拿个奖，加油！欢迎交流，我基出了前三题，其他都不能完全AC，也请大佬看到多多指正。-------------------------------------------------------分割线-----------------------------------------------------------------7-3：本题要求你写一个程序帮助小朋友学习用英语描述月份。已知英文的 12 个月份为：一月：January二月：Febr
2021 RoboCom 世界机器人开发者大赛-本科组（初赛）7-4 疫情防控 (30 分)
hys__handsome的博客
10-15 930
疫情尚未结束，严防疫情反复。为了做好疫情防控工作，国内设置了地区风险等级，对于中高风险地区的人员采取限制移动、居家隔离等手段。 为了研究疫情防控对于跨地区交通运输的影响，假设现在有N个机场，M条航线，每天都会新增一个防控地区，一个防控地区会导致一个机场无法正常运作，航线也自然无法正常运行，每天会有Qi​对旅客从Xi​机场前往Yi​机场，请计算有多少对旅客会受到影响无法完成行程。 旅客只要能直达或通过若干次中转，且乘坐的所有航线的出发和到达机场都正常运作，即视作可完成行程。 输入格式:...
2021 RoboCom 世界机器人开发者大赛-本科组（初赛）
xygwsgcmr的博客
01-28 335
菜鸟之玩花活玩不太明白版，不要参考！待学习知识点：vector+迭代器，哈希表。
2021 RoboCom 世界机器人开发者大赛-本科组（决赛）
Alan_Lowe
08-08 1848
s->s的话，这个题目可以拆成s->i + i -> s这两段，但是边不能重复，因此要先将s->i最短路径上面的所有边都标记一下，然后再跑一次s->i（i->s），这次跑的时候就不能用已经被标记过的边了，也是迪杰斯特拉，只不过需要特殊处理判断一下边的使用情况。嵌套map，用外层map的键表示邮箱，外层map的值也是一个map（内层map），内层map的键表示ip，值表示ip出现的次数，最后遍历一下，按照规定要求排序后输出即可。去年比赛的时候硬写了个搜索处理s->s的情况。...
2021 RoboCom 世界机器人开发者大赛-高职组（复赛）
superb_code的博客
07-06 557
随记code
2022 RoboCom 世界机器人开发者大赛-本科组（国赛）-- 第三题 RC-u3 战利品分配
limitsworld的博客
08-14 2286
2022年Robcom本科国赛第三题
2021 robocom 世界机器人开发者大赛-本科组（复赛）
03-16
2021 robocom 世界机器人开发者大赛-本科组（复赛）是一场面向全球机器人开发者的比赛，旨在促进机器人技术的发展和创新。本次比赛是本科组的复赛，参赛者需要展示他们的机器人设计和开发技能，以及解决实际问题的...
7-2拼题A打卡奖励(25分)【01背包】【2021 RoboCom 世界机器人开发者大赛-本科组（复赛）】
weixin_49320014的博客
07-09 413
7-2 拼题A打卡奖励(25分)拼题 A 的教超搞打卡活动，指定了 N 张打卡卷，第 i 张打卡卷需要 mi​ 分钟做完，完成后可获得 ci​ 枚奖励的金币。活动规定每张打卡卷最多只能做一次，并且不允许提前交卷。活动总时长为 M 分钟。请你算出最多可以赢得多少枚金币？
2021 RoboCom 世界机器人开发者大赛-本科组（初赛）【完结】
热门推荐
辉小歌的博客
10-12 1万+
看群友在水这个比赛玩玩，于是也去打了一下重现赛。 事实证明，群友轻松AK，而我只会暴力。 总的难度就是PAT甲的难度吧，数据很不错，恶心的一批。 2021RoboCom机器人开发者大赛官方题解 目录7-1 懂的都懂 (20 分)【简单 / 暴力 + 哈希表】7-2 芬兰木棋 (25 分)【中 / map 贪心】 7-1 懂的都懂 (20 分)【简单 / 暴力 + 哈希表】 方法一: 自己的傻叉做法 预处理所有的4个数的平均值。用double 注意精度 #include<bits/stdc++.h.
7-2 芬兰木棋 结构体排序
wow_awsl_qwq的博客
06-27 1418
7-2 芬兰木棋 分数 25 作者 DAI, Longao 单位 杭州百腾教育科技有限公司 WX20200212-152528.png芬兰木棋（Mölkky，又称芬兰木柱）是源自芬兰的一项运动。哲哲将这个运动改造成了赛博朋克单人版，现在场上一开始有 N 根立起的小木棋（上面分别标有一个非负整数），哲哲投掷一根大木棋去击倒这些小木棋以获得分数。分数规则如下：如果仅击倒 1 根木棋，则得木棋上的分数。 如果击倒 2 根或以上的木棋，则只得击倒根数的分数。（例如击倒 5 根，则得 5 分。） 哲哲固定站在 (0,
芬兰木棋 (25 分)
wssssYssssw的博客
03-29 815
robocom初赛B题 //32位整数-2147483628~2147483647 //绝对值后就超过int范围 #include <cstdio> #include <iostream> #include <cstring> #include <algorithm> #include <vector> #include <map> using namespace std; typedef long long LL; typedef p
2021 RoboCom 世界机器人开发者大赛-本科组（初赛）题解
qq_45830025的博客
10-16 1140
初赛7-1 懂的都懂 (20 分)7-2 芬兰木棋 (25 分)7-3 打怪升级 (25 分)7-4 疫情防控 (30 分) 7-1 懂的都懂 (20 分) 暴力 #include <iostream> #include <algorithm> #include<bits/stdc++.h> #define ll long long #define mem(a,b) memset(a,b,sizeof a) #define ull unsigned long long #
二叉树系列 10/11
最新发布
2301_78191305的博客
10-11 257
在这些路径中，只有红色和绿色的路径是伪回文路径，因为红色路径 [2,3,3] 存在回文排列 [3,2,3] ，绿色路径 [2,1,1] 存在回文排列 [1,2,1]。总共有 3 条从根到叶子的路径：红色路径 [2,3,3] ，绿色路径 [2,1,1] 和路径 [2,3,1]。（如果 A 的任何子节点之一为 B，或者 A 的任何子节点是 B 的祖先，那么我们认为 A 是 B 的祖先）（一个节点的祖父节点是指该节点的父节点的父节点。」的，当它满足：路径经过的所有节点值的排列中，存在一个回文序列。
2021robocom本科组初赛
07-15
2021 robocom 世界机器人开发者大赛-本科组（初赛）是一项面向本科生的机器人开发比赛。比赛旨在鼓励和促进机器人技术的发展和应用，提高参赛者的技术水平和创新能力。初赛是比赛的第一轮，参赛者需要提交自己的机器人设计方案和实现效果，经过评审后才能晋级到下一轮比赛。该比赛是一个很好的机会，让本科生们展示自己的才华和技能，同时也能够与其他机器人开发者交流和学习。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值