Codeforces 2023/2024 A-H

合集 - Codeforces(11)

1.Codeforces 2023/2024 A-H2024-10-30

2.Codeforces 4 A-D2024-10-303.Codeforces 1847 A-F2024-11-064.Codeforces 909 A-F2024-11-085.Codeforces 983 A-E2024-11-096.Codeforces 777 题目研讨2024-11-117.Codeforces 1450 题目研讨2024-11-128.Codeforces 250 题目分析2024-11-189.Codeforces 1145 题目分析2024-11-2010.Codeforces 55 题目分析2024-11-2211.Codeforces 333 题目研讨2024-11-27

收起

题面

A B C D E F G H

难度：红 橙 黄 绿 蓝 紫 黑 黑

题解

A

题目大意：

输入 $a$，$b$，解不等式 $b-2x\le a-x(0\le x\le a)$，输出 $a-x_{min}$。

解题思路：移项，得 $x\ge b-a$。

#include <bits/stdc++.h>
using namespace std;
int t, a, b;
int main() {
	scanf("%d", &t);
	while (t--) {
		scanf("%d%d", &a, &b);
		if (a >= b) printf("%d\n", a);
		else {
			int x = b - a;
			if (x <= a) printf("%d\n", a - x);
			else printf("0\n");
		}
	}
	return 0;
}

---

B

洛谷上这道题的题意翻译是我写的。

题目大意：

本题有多组测试数据。
有一台柠檬水自动售货机。机器上有 $n$ 个槽位和 $n$ 个按钮，每个槽位对应一个按钮，但你并不知道每个按钮对应的是哪个槽位。
当您按下第 $i$ 个按钮时，有两种可能的事件：

• 若 $i$ 号槽位有至少一瓶柠檬水，则其中一瓶柠檬水会从这个槽位里掉下来，然后你会把它取走。
• 若 $i$ 号槽位没有柠檬水，则什么都不会发生。

柠檬水下落速度很快，因此您看不清它从哪个槽位掉出。您只知道每个槽位中瓶装柠檬水的数量 $a_i(1\le a_i\le {10}^9)$
您需要求出至少收到 $k$ 瓶柠檬水的最小按按钮次数。
数据保证机器中至少存在 $k$ 瓶柠檬水。

题目分析：
贪心+排序。

定义“按钮按空”表示：该按钮按下若干次后，不再掉下柠檬水（即对应槽位中没有柠檬水）。

设当前有柠檬水的槽位中，数量最少的槽位为 $p$，显然对于每个已知按下能掉出柠檬水的按钮，至少需要按 $a_p$ 次，才能使这些按钮中存在“被按空”的按钮。

因此考虑进行如下操作：找到所有有柠檬水的槽位中，数量最少的槽位的柠檬水数，设为 $x$，然后对于所有“没有被按空”的按钮，每个分别按下 $x$ 次。由于是最坏情况，下一个按钮将“被按空”。此时标记这个按钮，并在下一轮中不再按下它。

解题思路：
可以考虑从小到大对数组 $a$ 排序，再从小到大进行枚举，直到已经掉出的柠檬水数量达到 $k$。

总时间复杂度 $O(n\text{log}n)$。

注：写下这篇题解时，作者想要复习一下堆的用法。

#include <bits/stdc++.h>
using namespace std;
long long n, k, a[200010];
priority_queue<long long, vector<long long>, greater<long long> > q;
int main() {
	long long t;
	scanf("%lld", &t);
	while (t--) {
		while (!q.empty()) q.pop();
		scanf("%lld%lld", &n, &k);
		for (long long i = 1; i <= n; i++) {
			scanf("%lld", &a[i]);
			q.push(a[i]);
		}
		long long tmpn = n, cnt = 0;
		long long ans = 0;
		while (true) {
			if ((q.top() - cnt) * tmpn >= k) {
				ans += k;
				break;
			}
			ans += (q.top() - cnt) * tmpn + 1;
			k -= (q.top() - cnt) * tmpn;
			tmpn--;
			cnt = q.top();
			q.pop();
		}
		printf("%lld\n", ans);
	}
	return 0;
}

---

C

题目大意：

有 $n$ 个二元组 $a_i(1\le i\le n)$。需要将二元组拼接形成一个序列，使序列中的逆序对个数最少。求这个序列。

题目分析：
不难想到贪心。观察可以发现对于二元组 $a_i=(p,q)$，以 $p+q$ 为关键字进行升序排序可以得到答案。

#include <bits/stdc++.h>
using namespace std;
struct akioi {
    int a, b;
} dat[100010];
int n, t;
bool cmp(akioi a, akioi b) { return a.a + a.b < b.a + b.b; }
int main() {
    scanf("%d", &t);
    while (t--) {
        scanf("%d", &n);
        for (int i = 1; i <= n; i++) {
            scanf("%d%d", &dat[i].a, &dat[i].b);
        }
        sort(dat + 1, dat + n + 1, cmp);
        for (int i = 1; i <= n; i++) {
            printf("%d %d ", dat[i].a, dat[i].b);
        }
    }
    return 0;
}

---

D

题目大意：

Prokhor 想要参加 IOI 3024。比赛共有 $n$ 道题，参赛者会先看到第 $1$ 题。比赛规则和现行规则有区别。
当他看到第 $i$ 题时有两种可能的操作：

• A 了这道题，并获得 $a_i$ 分；
• 放弃这道题。

不论执行哪种操作，第 $i$ 题都被标记“已访问”。
接着，他会看到编号为 $j$ 的问题。对于两种操作：

• 若 A 了第 $i$ 题，则有条件 $j\le i$；
• 若放弃第 $i$ 题，则有条件 $j\le b_i$。

无论如何，第 $j$ 题应“未被访问过”。此时取满足条件 $j$ 的最大值。
当不存在合法 $j$ 的时候比赛结束。显然，如果他 A 了第 $1$ 题，则比赛立即终止。
Prokhor 很 FAKE，所以他能 AK IOI。你需要帮他确定一种做题方案使得他获得全场最高分。

题目分析：

注意到到达第 $i$ 个题的最大得分为左右题的总分减去放弃的题的分数。于是改为求最少的跳过分数。不难想到 Dijkstra。由于第 $i$ 个题放弃时会跳转到第 $b_i$ 题（假设该题目未访问），同时失去了 $a_i$ 分，所以从 $i$ 向 $b_i$ 连边，权值为 $a_i$；由于第 $i$ 题回答完会跳转到第 $i-1$ 题（假设该题目未访问），没有失去分数，所以从 $i$ 向 $i-1$ 连边，权值为 $0$。

答案为 $$(\sum _{j=1}^i{a}_i-{\text{dis}}_i{)}_{max}$$，其中 ${\text{dis}}_i$ 表示从 $1$ 到 $i$ 的最短路。

#pragma GCC optimize(3)
#include <bits/stdc++.h>
using namespace std;
#define int long long
struct Edge {
	int y, w;
};
struct Node {
	int y, d;
	bool operator < (const Node &n1) const {
		return d > n1.d;
	}
};
const int inf = 0x3f3f3f3f;
const int N = 400005;
int n, d[N], a[N], b[N];
vector<Edge> g[N];
bool vis[N];
void dijkstra(int v0) {
	priority_queue<Node> q;
	for (int i = 1; i <= n; i++) {
		vis[i] = false;
		d[i] = 0x7f7f7f7f7f7f7f7f;
	}
	d[v0] = 0;
	q.push((Node) {
		v0, 0
	});
	while (!q.empty()) {
		Node n1 = q.top();
		q.pop();
		int x = n1.y;
		if (vis[x]) continue;
		vis[x] = true;
		for (int j = 0; j < g[x].size(); j++) {
			Edge next = g[x][j];
			int y = next.y, w = next.w;
			if (vis[y]) continue;
			if (d[x] + w < d[y]) {
				d[y] = d[x] + w;
				q.push((Node) {
					y, d[y]
				});
			}
		}
	}
}
char buf[1 << 20], *p1, *p2;
inline char gc() { return p1 == p2 ? p2 = buf + fread(p1 = buf, 1, 1<<20, stdin), (p1 == p2) ? EOF : *p1++ : *p1++; }
inline int read() {
	char c = gc(); int x = 0;
	while (c < '0' || c > '9') c = gc();
	while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = gc();
	return x;
}
inline void write(int x) {
	if (x > 9) write(x / 10);
	putchar(x % 10 ^ 48);
}
signed main() {
	int t = read();
	while (t--) {
		n = read();
		g[1].clear();
		for (int i = 2; i <= n; i++) {
			g[i].clear();
			g[i].push_back({i - 1, 0});
		}
		for (int i = 1; i <= n; i++) {
			a[i] = read();
		}
		for (int i = 1; i <= n; i++) {
			b[i] = read();
			g[i].push_back({b[i], a[i]});
			a[i] += a[i - 1]; // qian zhui he
		}
		dijkstra(1);
		int ans = 0;
		for (int i = 1; i <= n; i++) {
			ans = max(ans, a[i] - d[i]);
		}
		write(ans);
		putchar('\n');
	}
	return 0;
}

---

E

题目大意：

在两个强连通图中连接 $n$ 条有向边，使得：

• 每个环的长度为 $k$ 的倍数；
• 所有“入点”恰好多一条入边；
• 所有“出点”恰好多一条出边；
• 每条边从其中一个强连通图出发，指向另一个强连通图。

题目分析：
还是看这个吧，这是官方题解。下面是文章翻译：

考虑一个强连通图，其中所有环的长度都是 $k$ 的倍数。注意到，总是可以用 $k$ 种颜色给这个图上色，使得任何一条边都可以将一个颜色为 $c$ 的顶点连接到一个颜色为 $(c+1)\mathrm{\%}k$ 的顶点。不难发现，只有当这些边保持所描述的颜色不变时，我们才能向图中添加边。

让我们给原图上一些颜色。使用固定的颜色，很容易检查是否可以添加所需的边。为此，我们将为每种颜色和每种顶点创建相应的 $cnt$ 数组，然后我们将根据上面提到的标准比较数组的元素。然而，我们最初可以用不同的方式给第二个图上色，例如，通过在每个顶点的颜色上加上 $1$ 对 $k$ 取模。不难验证第二个图的计数数组的所有值在一个周期内都会移动 $1$。同样，根据颜色的不同，所有的值都可以循环地任意移动。为了解决这个问题，我们将以这样一种方式构造初始数组，对于固定的着色，需要检查它们是否相等。如果对某些着色实现了相等，则意味着一个数组是另一个数组的循环移位。可以使用 KMP 算法检查这种情况。