2021 RoboCom 世界机器人开发者大赛-本科组（初赛）题解

7-1 懂的都懂 (20 分)

众所周知，在互联网上有很多话是不好直接说出来的，不过一些模糊的图片仍然能让网友看懂你在说什么。然而对这种言论依然一定要出重拳，所以请你实现一个简单的匹配算法。

现在我们采集了原图的一些特征数据，由 N 个小于 255 的非负整数组成，假设对于给定的若干张由 M_i个同样小于 255 的非负整数组成的新图的特征数据，每个数据都可以由原图中任意四个不同数据的平均值计算而来，则称新图为原图的相似图片。对于给出的数据，请你判断是不是相似图片。

注意，不同数据指的并非是数据的值不同，而是不能取同一个数据多次。对于两个相同值的数据，如果给出两次，则可以取两次。

输入格式:

输入第一行是两个整数 N,K (1 ≤ N ≤ 50, 1 ≤ K ≤ 200)，表示采集的原图的特征数据个数和新图的张数。

接下来一行为 N 个小于 255 的非负整数，表示原图的特征数据。

最后的 K 行，每行第一个数是 M_i (1 ≤ M_i ≤ 200)，表示新图的特征数据个数。然后是 M_i个小于 255 的非负整数，表示新图的特征数据。

输出格式:

对于每一张新图，如果为相似图片，则在一行中输出 Yes，否则输出 No。

输入样例:

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

标签:

哈希，枚举

题意:

给定n个数，再给定k组数，要求判断每一组内的所有数，是否存在n个数内任取四个数的平均值等于它本身

思路:

四层循环去枚举取数的过程，为了避免精度问题，用哈希表存下四个数之和而不是平均值，最后判断每一组数的四倍是否在哈希表内(用数组模拟哈希表可以节省一半的时间)

时间复杂度O(n⁴)

代码:

// 7-1 懂的都懂 (20 分)
#include
#include
#include
#include
#include
#include
using namespace std;

const int N = 55, M = 255 * 4;

int n, m, k, x;
int num[N];
bool st[M];
vector<int> a;
unordered_set<int> s;

void init()
{
	for(int a = 0; a < n; a++)
	{
		for(int b = a + 1; b < n; b++)
		{
			for(int c = b + 1; c < n; c++)
			{
				for(int d = c + 1; d < n; d++)
//					s.insert(num[a] + num[b] + num[c] + num[d]);
					st[num[a] + num[b] + num[c] + num[d]] = true;
			}
		}
	}	
}

bool judge()
{
	for(int &x : a)
//		if(s.count(x * 4) == 0)
		if(!st[x * 4])
			return false;
	return true; 
}

int main()
{
	cin >> n >> m;
	for(int i = 0; i < n; i++)
		cin >> num[i];
	
	init();
	while(m--)
	{
		cin >> k;
		a.clear();
		a.resize(k);
		for(int i = 0; i < k; i++)
			cin >> a[i];
		
		judge() ? puts("Yes") : puts("No");
	}
	return 0;
} 

7-2 芬兰木棋 (25 分)

芬兰木棋（Mölkky，又称芬兰木柱）是源自芬兰的一项运动。哲哲将这个运动改造成了赛博朋克单人版，现在场上一开始有 N 根立起的小木棋（上面分别标有一个非负整数），哲哲投掷一根大木棋去击倒这些小木棋以获得分数。分数规则如下：

• 如果仅击倒 1 根木棋，则得木棋上的分数。
• 如果击倒 2 根或以上的木棋，则只得击倒根数的分数。（例如击倒 5 根，则得 5 分。）

哲哲固定站在 (0,0) 点上，四周放着若干个小木棋 (X_i,Y_i)，坐标均为整数。每次哲哲可以朝一个方向扔出大木棋，大木棋会打倒这个方向上离哲哲最近的 k 个小木棋。哲哲游戏水平很高超，所以这个 k 可以自由控制。

请问哲哲最多能拿多少分，在获得最多分数的情况下最少需要扔出多少次大木棋？

规则与真实规则有较大出入，真实游玩时请以国际莫尔基组织的规则为准

输入格式:

输入第一行是一个正整数 N (1 ≤ N ≤ 10⁵)，表示场上一开始有 N 个木棋。

接下来 N 行，每行 3 个整数 X_i,Y_i,P_i*，分别表示木棋放置在 (X_i,*Y_i)，木棋上的分数是 P_i。坐标在 32 位整数范围内，分数为小于等于 1000 的正整数。

保证 (0,0) 点没有木棋，也没有木棋重叠放置。

输出格式:

输出一行两个数，表示最多分数以及获得最多分数最少需要投掷大木棋多少次。

输入样例:

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

标签:

思维，贪心

题意:

玩家在原点，给出n个木棋的坐标和得分，每次击打能把任意方向距离玩家最近的连续的任意个数的木棋击倒。规定如果只击倒一个，则获得木棋上的得分，如果击倒两个或两个以上，则获得的得分为击倒木棋的个数。问能够获得的最大得分是多少，在获得最大得分的情况下，最小击打次数是多少

思路:

如果要获得最大分数，那可以把所有木棋都击倒，最大分数就是所有木棋得分之和

为了尽量减少击打次数，那么我们考虑，把同一方向的得分为1的连续的木棋一次性击倒，其余的木棋都是一个木棋击打一次(为了获得最大分数)

首先，斜率如何表示，如果直接用k=y/x那么会带来精度问题，我们可以考虑用一个pair去表示一个斜率，注意这里需要对y和x进行约分

我们用map去映射每一个方向上的所有点，同一个方向上的点根据与原点的位置进行排序，每次取出一个方向上的所有点，对于连续的得分为1的点进行一次击打，其余的点每个都击打一次

时间复杂度O(nlogn)

代码:

//7-2 芬兰木棋 (25 分)
#include
#include
#include
#include
#include
#include

using namespace std;
typedef pair<int, int> PLL;
typedef long long LL;

int n, s;
LL x, y;
map<PLL, vector<pair<LL, int>>> mp;

int main()
{
	scanf("%d", &n);
	int sum = 0, cnt = 0;
	
	for(int i = 0; i < n; i++)
	{
		scanf("%lld %lld %d", &x, &y, &s);
		sum += s;
		
		LL d = x * x + y * y;
		LL c = abs(__gcd(x, y));
		
		x /= c, y /= c;
		mp[{x, y}].push_back({d, s});
	}
	
	for(auto x : mp)
	{
		vector<pair<LL, int>> v = x.second;
		sort(v.begin(), v.end());
        
		for(int i = 0; i < v.size(); i++)
		{
			if(v[i].second != 1)
				cnt++;
			else
			{
				if((i + 1 < v.size() && v[i + 1].second != 1) || i + 1 == v.size())
					cnt++;
			}
		}
	}
	
	printf("%d %d\n", sum , cnt);
	return 0;
}

7-3 打怪升级 (25 分)

很多游戏都有打怪升级的环节，玩家需要打败一系列怪兽去赢取成就和徽章。这里我们考虑一种简单的打怪升级游戏，游戏规则是，给定有 N 个堡垒的地图，堡垒之间有道路相连，每条道路上有一只怪兽把守。怪兽本身有能量，手里的武器有价值。打败怪兽需要的能量等于怪兽本身的能量，而怪兽一旦被打败，武器就归玩家所有 —— 当然缴获的武器价值越高，玩家就越开心。

你的任务有两件：

• 1. 帮助玩家确定一个最合算的空降位置，即空降到地图中的某个堡垒，使得玩家从这个空降点出发，到攻下最难攻克（即耗费能量最多）的那个堡垒所需要的能量最小；
• 1. 从这个空降点出发，帮助玩家找到攻克任意一个其想要攻克的堡垒的最省能量的路径。如果这种路径不唯一，则选择沿途缴获武器总价值最高的解，题目保证这种解是唯一的。

输入格式:

输入第一行给出两个正整数 N (≤1000) 和 M，其中 N 是堡垒总数，M 是怪兽总数。为简单起见，我们将堡垒从 1 到 N 编号。随后 M 行，第 i 行给出了第 i 只怪兽的信息，格式如下：

B1 B2 怪兽能量 武器价值

其中 B1 和 B2 是怪兽把守的道路两端的堡垒编号。题目保证每对堡垒之间只有一只怪兽把守，并且 怪兽能量 和 武器价值 都是不超过 100 的正整数。

再后面是一个正整数 K（≤N）和玩家想要攻克的 K 个目标堡垒的编号。

输出格式:

首先在一行中输出玩家空降的堡垒编号 B0。如果有多种可能，则输出编号最小的那个。

随后依次为玩家想要攻克的每个堡垒 B 推荐最省能量的攻克路径，并列出需要耗费的能量值和沿途缴获武器的总价值。注意如果最省力的路径不唯一，则选择沿途缴获武器总价值最高的解。格式为：

B0->途经堡垒1->...->B
总耗费能量 武器总价值

输入样例:

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

标签:

dijkstra，枚举

题意:

给定一无向图，每条边带有两个关键字

首先要求选定一个起点，使得从这个起点出发相比于其他起点，途径到第一关键字之和最大的那个点和是最小的，如果有多个起点符合要求，则选编号最小的

并且给出k个询问，每次给出一个点的编号，要求从刚刚选定的点出发到达该点，并且使得第一关键字之和最小，在多条路径第一关键字之和相同时，使得第二关键字之和最大，并输出这条路径和第一关键字之和，第二关键字之和

思路:

**坑点：**这题并没有给出边数M的范围，所以并不能用堆优化dijkstra(O(nlogm))，可以认为M是无穷大的，所以会导致最后一个点超时

由于输入超过了10⁵，所以用cin cout会导致超时(最后两个点)

在选起点位置的时候，并没有一个很好的优化方法，直接无脑将每一个点作为起点跑一遍dijkstra即可

维护双关键字和记录pre都是老套路了

时间复杂度O(n³)

//7-3 打怪升级 (25 分)
#include
#include
#include
#include

using namespace std;
const int N = 1010;

bool vis[N];
int n, m, max_s[N];
int min_s[N], max_d[N];
int a, b, s, d, pre[N];
int S[N][N], D[N][N];

int dijkstra(int f)
{
	memset(vis, 0, sizeof vis);
	memset(min_s, 0x3f, sizeof min_s);
	memset(max_d, 0, sizeof max_d);
	
	min_s[f] = 0;
	while(true)
	{
		int t = -1;
		for(int i = 1; i <= n; i++)
			if(!vis[i] && (t == -1 || min_s[t] > min_s[i]))
				t = i;
		
		if(t == -1)
			break;
		vis[t] = true;
		
		for(int i = 1; i <= n; i++)
		{
			if(min_s[i] > min_s[t] + S[t][i])
			{
				pre[i] = t;
				min_s[i] = min_s[t] + S[t][i];
				max_d[i] = max_d[t] + D[t][i];
			}
			else if(min_s[i] == min_s[t] + S[t][i])
			{
				if(max_d[i] < max_d[t] + D[t][i])
				{
					pre[i] = t;
					max_d[i] = max_d[t] + D[t][i];
				}
			}
		}
	}
	
	int ms = 0;
	for(int i = 1; i <= n; i++)
		if(ms < min_s[i])
			ms = min_s[i];
	return ms;
}

void dfs(int x, int id)
{
	if(x == id)
		return ;
	dfs(pre[x], id);
	printf("->%d", x);
}

int main()
{
	memset(S, 0x3f, sizeof S);
	
	scanf("%d %d", &n, &m);
	while(m--)
	{
		scanf("%d %d %d %d", &a, &b, &s, &d);
		S[a][b] = S[b][a] = min(S[a][b], s);
		D[a][b] = D[b][a] = max(D[a][b], d);
	}
	
	for(int i = 1; i <= n; i++)
		max_s[i] = dijkstra(i);
	
	int id = 1;
	for(int i = 1; i <= n; i++)
		if(max_s[id] > max_s[i])
			id = i;
	
	printf("%d\n", id);
	dijkstra(id);
	
	int k, x;
	scanf("%d", &k);
	while(k--)
	{
		scanf("%d", &x);
		printf("%d", id);
		dfs(x, id);
		printf("\n");
		printf("%d %d\n", min_s[x], max_d[x]); 
	}
	return 0;
}

7-4 疫情防控 (30 分)

疫情尚未结束，严防疫情反复。为了做好疫情防控工作，国内设置了地区风险等级，对于中高风险地区的人员采取限制移动、居家隔离等手段。

为了研究疫情防控对于跨地区交通运输的影响，假设现在有 N 个机场，M 条航线，每天都会新增一个防控地区，一个防控地区会导致一个机场无法正常运作，航线也自然无法正常运行，每天会有 Q_i 对旅客从 X_i 机场前往 Y_i 机场，请计算有多少对旅客会受到影响无法完成行程。

旅客只要能直达或通过若干次中转，且乘坐的所有航线的出发和到达机场都正常运作，即视作可完成行程。

输入格式:

输入第一行是三个整数 N,M,D (1≤N≤5×10⁴, 1≤M≤2×10⁵, 1≤D≤10³), 表示机场数、航线数以及新增防控地区的天数。

接下来首先有 M 行，每行给出空格分隔的两个数字 A 和 B，表示编号为 A 和 B 的机场之间有一条航线。航线是双向的，机场编号从 1 到 N。

然后是 D 块输入，每块输入内第一行为空格分隔的两个整数 C 和 Q （1≤Q≤10³)，表示新增机场编号为 C 所在的城市为防控地区，今天有 Q 段行程。数据保证新增的城市之前一定不是防控地区。

接下来的 Q 行，每行是空格分隔的两个数字 X 和 Y，表示编号为 X 和 Y 的机场的一段行程。行程有可能包括之前就已经成为防控地区的城市。

输出格式:

对于每天的询问，请在一行中输出在新增了一个防控地区后当天的行程有多少不能成行。

输入样例:

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

标签:

并查集，思维

题意:

给定一无向图，和k次询问，每次询问都会减少一个点，并有q次查询，查询a能否到b

最后输出每次询问，a无法到b的总个数

思路:

查询两个点之间是否有路径，可以使用并查集

但是并查集并不支持删点操作，如果一定要的话需要在删点后重新建立并查集，这样必然会超时的

正难则反

虽然并查集并不支持删点，但是我们可以反过来往里面添加点(与点相连的边)

所以我们可以把每个查询都存下来，反过来去处理，处理完之后再把当前查询要删除的点添加回去，即把这个点有关的所有边添加入并查集(另一个点没有被删除)

代码:

//7-4 疫情防控 (30 分)
#include
#include
#include
#include
#include
using namespace std;

const int N = 5e4 + 10;
typedef pair<int, int> PII;

int n, m, d;
int c, q, a, b, x, y;
int f[N];
bool st[N];
vector<vector<PII>> plls;
vector<int> G[N], ps, res;

void init()
{
	for(int i = 0; i < N; i++)
		f[i] = i;
}

int find(int x)
{
	return f[x] = f[x] == x ? x : find(f[x]);
}

int main()
{
	init();
	scanf("%d %d %d", &n, &m, &d);
	for(int i = 0; i < m; i++)
	{
		scanf("%d %d", &x, &y);
		G[x].push_back(y);
		G[y].push_back(x);
	}
	
	while(d--)
	{
		scanf("%d %d", &c, &q);
		st[c] = true;
		ps.push_back(c);

		vector<PII> pll;
		while(q--)
		{
			scanf("%d %d", &a, &b);
			pll.push_back({a, b});
		}
		
		plls.push_back(pll);
	}
	
	for(int i = 1; i <= n; i++)
	{
		if(st[i])
			continue;
		
		for(int j = 0; j < G[i].size(); j++)
		{
			int x = G[i][j];
			if(st[x])
				continue;
			f[find(i)] = find(x);
		}
	}
	
	for(int i = plls.size() - 1; i >= 0; i--)
	{
		int cnt = 0;
		vector<PII> pll = plls[i];
		for(PII p : pll)
			if(find(p.first) != find(p.second))
				cnt++;	
		
		res.push_back(cnt);
		
		int u = ps[i];
		for(int x : G[u])
		{
			if(st[x])
				continue;
			f[find(u)] = find(x);
		}
		st[u] = false;
	}
	
	reverse(res.begin(), res.end());
	for(int x : res)
		printf("%d\n", x);
	return 0;
}