07/01/24 融合热身赛赛后题解&总结

最新推荐文章于 2024-07-18 08:54:18 发布

NY_String

最新推荐文章于 2024-07-18 08:54:18 发布

阅读量809

点赞数 21

分类专栏：考试考试心得考试总结文章标签：算法数据结构学习方法经验分享

本文链接：https://blog.csdn.net/2401_82804478/article/details/140109356

版权

考试同时被 3 个专栏收录

6 篇文章 0 订阅

订阅专栏

考试心得

6 篇文章 0 订阅

订阅专栏

考试总结

6 篇文章 0 订阅

订阅专栏

一、总体情况

考试一共有六道题
考试时前一个半小时AC了 $A$ 、 $B$ 、 $E$ 、 $F$ 四道题
后一个半小时一直在想 $C$ 题，但没想出来

二、题解

A题

题目描述

我们有一个尺寸为
$A$ × $B$ × $C$ 的长方体，由尺寸为
1×1×1的方块构成。Snuke将会把这
$A$ × $B$ × $C$ 个方块中的每一个涂成红色或蓝色，使得：

至少有一个红色方块和至少有一个蓝色方块。
所有红色方块的并集形成一个长方体。
所有蓝色方块的并集形成一个长方体。
Snuke希望尽量减小红色方块数和蓝色方块数之间的差异。找出可能的最小差异。

思路分析

如果有任意一边的边长为偶数，则可以直接以这条边的中点为分界线涂色，直接输出0
但如果有一边长是奇数，那还是尽量一半一半的涂，而为了使差异最小，要以最长边的中点为分界线

代码

#include <iostream>
#include <algorithm>

using namespace std;

long long a[3];

int main()
{
	for (int i = 0; i < 3; i++) {
		cin >> a[i];
	}
	if (a[0] % 2 == 0 || a[1] % 2 == 0 || a[2] % 2 == 0) {
		cout << "0" << endl;
		return 0;
	}
	sort(a, a + 3);
	cout << (long long) a[0] * a[1] << endl;
	return 0;
}

B题

题目描述

给定一个 $n$ 行 $n$
列的正方形网格。每个单元格包含 0
或 1
。

在一个操作中，你可以选择网格中的一个单元格并翻转它（从 0$→ $1 到 1$ →$0
）。找到使得正方形在旋转 0∘、90∘、180∘ 和 270∘
时保持不变所需的最小操作次数。

思路分析

要使每个格子在旋转90度、180度、270度时还保持不变，其实就是让这四个旋转形成的格子都一样
只需要在知道其中一个格子的情况下，将其他三个格子的下标算出来就行了
四个格子里面那种颜色出现的次数多，就把这几个格子变成那种颜色
如果边长是偶数的话，只用枚举左上方的格子就可以了
如果边长是奇数的话，在枚举左上方的基础上，在将中间部分枚举即可

代码

#include <iostream>
#include <string>

using namespace std;

const int N = 105;

int t, n;
int ans;
string graph[N];

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	cin >> t;
	while (t-- > 0) {
		cin >> n;
		ans = 0;
		for (int i = 1; i <= n; i++) {
			cin >> graph[i];
			graph[i] = " " + graph[i];
		}
		int tmp = 0;
		for (int i = 1; i <= n / 2; i++) {
			for (int j = 1; j <= n / 2; j++) {
				tmp = 0;
				if (graph[i][j] == '1') {
					tmp++;
				}
				if (graph[n + 1 - i][n + 1 - j] == '1') {
					tmp++;
				}
				if (graph[n + 1 - j][i] == '1') {
					tmp++;
				}
				if (graph[j][n + 1 - i] == '1') {
					tmp++;
				}
				ans += min(tmp, 4 - tmp);
			}
		}
		if (n % 2 == 0) {
			cout << ans << '\n';
			continue;
		} else {
			int k = n / 2 + 1;
			for (int i = 1; i <= k - 1; i++) {
				tmp = 0;
				if (graph[i][k] == '1') {
					tmp++;
				}
				if (graph[n + 1 - i][k] == '1') {
					tmp++;
				}
				if (graph[k][i] == '1') {
					tmp++;
				}
				if (graph[k][n + 1 - i] == '1') {
					tmp++;
				}
				ans += min(tmp, 4 - tmp);
//				cout << tmp << endl;
			}
			cout << ans << '\n';
		}
	}
	return 0;
}

C题

题目描述

Tohru从异世界带回来 $n$ 种化学品，排列成一行。每一种化学品有一个效果值, 第i个效果值为 $a_{i}$ 。

Tohru想要把连续区间上的化学品混合在一起做成总效果值为 $k$ 的非负整数幂的新奇的玩具。总效果值为连续区间上的化学品效果值的总和。

帮帮她找到符合要求的区间的方案数

思路分析

这道题其实就是给定一个区间和 $k$ ，求有多少个区间的和等于 $k$ ，只不过这个 $k$ 要自己枚举
因为是求区间和，想到前缀和。例如，区间 $[L, R]$ 的和 $= s u m [R] - s u m [L - 1]$
可以使用map来动态维护每个前缀和的出现次数
只需要去枚举每个右端点，然后统计在这个端点之前的端点中，有多少个端点的前缀和 $=$ $s u m [R] - k$ ，那这个端点就可以作为前面提到的 $L - 1$
由于最终算出来是 $L - 1$ ，因为 $L$ 最先是 $1$ ，所以 $L - 1$ 可以等于 $0$

代码

#include <iostream>
#include <cmath>
#include <set>
#include <map>

#define INF 1e14

using namespace std;

const int N = 1e5 + 5;

long long n, k;
long long ans = 0;
long long a[N];
long long sum[N];
map<long long, long long> sums;

int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	cin >> n >> k;
	for (int i = 1; i <= n; i++) {
		cin >> a[i];
		sum[i] = sum[i - 1] + a[i];
	}
	long long val;
	long long expect;
	if (k > 1 || k < -1) {
		for (int t = 0; t < 50; t++) {
			sums.clear();
			val = pow(k, t);
			if (val > INF || val < -INF) {
				break;
			}
			sums[0]++;
			for (int i = 1; i <= n; i++) {
				expect = sum[i] - val;
				ans += sums[expect];
				sums[sum[i]]++;
			}
		}
	} else {
		val = 1;
		sums.clear();
		sums[0]++;
		for (int i = 1; i <= n; i++) {
			expect = sum[i] - val;
			ans += sums[expect];
			sums[sum[i]]++;
		}
		if (k == -1) {
			val = -1;
			sums.clear();
			sums[0]++;
			for (int i = 1; i <= n; i++) {
				expect = sum[i] - val;
				ans += sums[expect];
				sums[sum[i]]++;
			}
		}
	}
	cout << ans << '\n';
	return 0;
}

D题

题目描述

所谓同花顺，就是指一些扑克牌，它们花色相同，并且数字连续。
现在我手里有 $n$ 张扑克牌，但它们可能并不能凑成同花顺。我现在想知道，最少更换其中的多少张牌，我能让这 $n$ 张牌都凑成同花顺？
$\le 10^{5}$ ， $\le a_{i}, b_{i} \le 10^{9}$ ；

思路分析

这道题肯定要先排序并去重，方便后续处理
求最少换掉几张，就是求最多留下几张
同花顺的原则是：花色相同并且数字一致，可以用一个队列存同一个花色中的数字，当新的元素入队时，假设这个元素为 $X$ ，则只有在 $X - N + 1$ $<=$ 队首时，这些元素才能和别的元素一起凑成同花顺，否则，就要一直弹出队首，知道满足条件

代码

#include <iostream>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <vector>

using namespace std;

struct Card {
	int color;
	int num;
	bool operator < (const Card& c) const {
		if (color == c.color) {
			return num < c.num;
		} else {
			return color < c.color;
		}
	}
};

const int N = 1e5 + 5;

int n;
int tmp;
Card card[N];
set<pair<int, int>> s;
map<int, vector<int>> cards;

int main()
{
	ios::sync_with_stdio(false);
	cin >> n;
	for (int i = 1; i <= n; i++) {
		cin >> card[i].color >> card[i].num;
		if (s.count(make_pair(card[i].color, card[i].num))) {
			n--;
			i--;
			tmp++;
		} else {
			s.insert(make_pair(card[i].color, card[i].num));
		}
	}
	sort(card + 1, card + n + 1);
	for (int i = 1; i <= n; i++) {
		cards[card[i].color].push_back(card[i].num);
	}
	queue<int> q;
	int ans = 0;
	for (auto i : cards) {
		while (!q.empty()) {
			q.pop();
		}
		for (int j = 0; j < i.second.size(); j++) {
			while (!q.empty() && q.front() < i.second[j] - n + 1) {
				q.pop();
			}
			q.push(i.second[j]);
			ans = max(ans, (int)q.size());
		}
	}
	ans = n - ans;
	cout << ans + tmp << '\n';
	return 0;
}

E题

题目描述

给你一个 $N$ 和 $Q$ ，输入 $a_{1}$ ， $a_{2}$ $...$ $a_{N}$ ，接下来输入 $Q$ 对 $L$ 和 $R$ ，让你每次找出区间 $[L, R]$ 中最大值与最小值的差

思路分析

用两个ST来维护区间最值，模板题

代码

#include <iostream>

using namespace std;

const int N = 5e4 + 5;

int n, q;
int st_min[N][30];
int st_max[N][30];
int h[N];
int LOG2[N];

void init_log()
{
	LOG2[0] = -1;
	for (int i = 1; i < N; i++) {
		LOG2[i] = LOG2[i >> 1] + 1;
	}
}

int query_max(int first, int last)
{
	int k = LOG2[last - first + 1];
	return max(st_max[first][k], st_max[last - (1 << k) + 1][k]);
}

int query_min(int first, int last)
{
	int k = LOG2[last - first + 1];
	return min(st_min[first][k], st_min[last - (1 << k) + 1][k]);
}

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	cin >> n >> q;
	init_log();
	for (int i = 1; i <= n; i++) {
		cin >> h[i];
		st_min[i][0] = h[i];
		st_max[i][0] = h[i];
	}
	int k = LOG2[n];
	for (int j = 1; j <= k; j++) {
		int i = 1;
		for (i = 1; i <= n - (1 << (j - 1)); i++) {
			st_min[i][j] = min(st_min[i][j - 1], st_min[i + (1 << (j - 1))][j - 1]);
			st_max[i][j] = max(st_max[i][j - 1], st_max[i + (1 << (j - 1))][j - 1]);
		}
		for (; i <= n; i++) {
			st_min[i][j] = st_min[i][j - 1];
			st_max[i][j] = st_max[i][j - 1];
		}
	}
	int l, r;
	while (q-- > 0) {
		cin >> l >> r;
//		cout << query_max(l, r) << "<><><>" << query_min(l, r) << '\n';
		cout << query_max(l, r) - query_min(l, r) << '\n';
	}
	return 0;
}

F题

题目描述

Black Box 是一种原始的数据库。它可以储存一个整数数组，还有一个特别的变量 $i$ 。最开始的时候 Black Box 是空的．而 $i = 0$ 。这个 Black Box 要处理一串命令。

命令只有两种：

ADD(x)：把 $x$ 元素放进 Black Box;
GET： $i$ 加 $1$ ，然后输出 Black Box 中第 $i$ 小的数。

记住：第 $i$ 小的数，就是 Black Box 里的数的按从小到大的顺序排序后的第 $i$ 个元素。

我们来演示一下一个有11个命令的命令串。（如下表所示）

序号	操作	$i$	数据库	输出
1	`ADD(3)`	$0$	$3$	/
2	`GET`	$1$	$3$	$3$
3	`ADD(1)`	$1$	$1, 3$	/
4	`GET`	$2$	$1, 3$	$3$
5	`ADD(-4)`	$2$	$- 4, 1, 3$	/
6	`ADD(2)`	$2$	$- 4, 1, 2, 3$	/
7	`ADD(8)`	$2$	$- 4, 1, 2, 3, 8$	/
8	`ADD(-1000)`	$2$	$- 1000, - 4, 1, 2, 3, 8$	/
9	`GET`	$3$	$- 1000, - 4, 1, 2, 3, 8$	$1$
10	`GET`	$4$	$- 1000, - 4, 1, 2, 3, 8$	$2$
11	`ADD(2)`	$4$	$- 1000, - 4, 1, 2, 2, 3, 8$	/

现在要求找出对于给定的命令串的最好的处理方法。ADD 命令共有 $m$ 个，GET 命令共有 $n$ 个。现在用两个整数数组来表示命令串：

$a_1,a_2,\cdots,a_m$ ：一串将要被放进 Black Box 的元素。例如上面的例子中 $a = [3, 1, - 4, 2, 8, - 1000, 2]$ 。
$u_1,u_2,\cdots,u_n$ ：表示第 $u_i$ 个元素被放进了 Black Box 里后就出现一个 GET 命令。例如上面的例子中 $u = [1, 2, 6, 6]$ 。输入数据不用判错。
单调不降。

思路分析

按照题意，发现是动态维护序列中第 $i$ 小的值，可以使用对顶堆维护

代码

#include <iostream>
#include <queue>
#include <set>

using namespace std;

const int N = 2e5 + 5;

int m, n;
int k = 0;
set<int> s;
int u[N];
int a[N];
priority_queue<int> pq;
priority_queue<int, vector<int>, greater<int> > pq1;

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	cin >> m >> n;
	for (int i = 1; i <= m; i++) {
		cin >> a[i];
	}
	for (int i = 1; i <= n; i++) {
		cin >> u[i];
	}
	int j = 1;
	for (int i = 1; i <= n; i++) {
		k++;
		if (u[i] == u[i - 1]) {
			pq.push(pq1.top());
			pq1.pop();
		} else {
			for (; j <= u[i] && j <= m; j++) {
				if (!pq1.empty()) {
					if (a[j] < pq1.top()) {
						pq.push(a[j]);
					} else {
						pq.push(pq1.top());
						pq1.pop();
						pq1.push(a[j]);
					}
				} else {
					pq.push(a[j]);
				}
				while (!pq.empty() && pq.size() > k) {
					pq1.push(pq.top());
					pq.pop();
				}
			}
		}
		cout << pq.top() << '\n';
	}
	return 0;
}

三、存在的不足

对一些复杂问题的分析还不够透彻，例如 $C$ 题，想到了用前缀和，但没有想到将区间和问题转化为求某个数个数的问题
经常犯一些基础性的细节错误，就比如说在补 $D$ 题的时候，因为一开始忘了去重，检查了半个多小时，很浪费时间

四、下次考试时的改进措施

每道题想清楚了再开写，这次的 $C$ 题就是没想清楚，把我的算法的复杂度想错了，写上去~~喜提TLE~~没有写对
写代码前先把程序的框架理好了再写，不要漏写

NY_String

关注

21
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
07/01/24 融合热身赛赛后题解&总结

一、总体情况考试一共有六道题考试时前一个半小时AC了AAA、BBB、EEE、FFF四道题后一个半小时一直在想CCC题，但没想出来二、题解A题题目描述我们有一个尺寸为AAA × BBB × CCC 的长方体，由尺寸为1×1×1的方块构成。Snuke将会把这AAA × BBB × CCC 个方块中的每一个涂成红色或蓝色，使得：至少有一个红色方块和至少有一个蓝色方块。所有红色方块的并集形成一个长方体。所有蓝色方块的并集形成一个长方体。Snuke希望尽量减小红色方块数和蓝色方块数之间
复制链接

扫一扫