Atcoder Beginner Contest 350

nuo534202

已于 2024-06-23 22:41:30 修改

阅读量1.8k

点赞数 56

分类专栏： Atcoder Contest 文章标签：算法 c++ 数据结构 c语言

于 2024-04-25 00:10:12 首次发布

本文链接：https://blog.csdn.net/djhws144/article/details/138168660

版权

Atcoder Contest 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

传送门

A - Past ABCs

时间限制：2秒内存限制：1024MB

分数：100分

问题描述

给定一个长度为 6 的字符串 S。保证 S 的前三个字符是 ABC，而后三个字符是数字。判断 S 是否是在这个竞赛开始之前由 AtCoder 举办并结束的竞赛的缩写。在这里，一个字符串 T 是在这个竞赛开始之前由 AtCoder 举办并结束的竞赛的缩写，当且仅当它等于以下 348 个字符串之一：

ABC001, ABC002, …, ABC314, ABC315, ABC317, ABC318, …, ABC348, ABC349.

注意ABC316不包括在内。

限制

S是一个长度为 6 的字符串，其中前三个字符是 ABC，而后三个字符是数字。

输入格式

$S$

输出格式

如果 S 是在这个竞赛开始之前由 AtCoder 举办并结束的竞赛的缩写，则输出 Yes；否则，输出 No。

输入输出样例

输入样例1

$ABC349$

输出样例1

$Yes$

ABC349 是上周在 AtCoder 上举办并结束的比赛的缩写。

输入样例2

$ABC350$

输出样例2

$No$

ABC350 是这次比赛，尚未结束。

输入样例3

$ABC316$

输出样例3

$No$

ABC316 并没有在 AtCoder 上举办。

代码

#include <bits/stdc++.h>
using namespace std;

int main() {
	string s;
	cin >> s;
	int d = (s[3] - '0') * 100 + (s[4] - '0') * 10 + s[5] - '0';
	if (s[0] == 'A' && s[1] == 'B' && s[2] == 'C') {
		if (d >= 1 && d <= 349 && d != 316) { printf("Yes"); return 0; }
	}
	printf("No");
    return 0;
}

B - Dentist Aoki

时间限制：2秒内存限制：1024MB

分数：200分

问题描述

Takahashi 有 N 颗牙齿，分别在编号为 1，2，…，N 的洞里面。牙医 Aoki 将会对这些牙齿和洞进行Q次治疗。

在第 i 次治疗中，对洞 $T_{i}$ 的处理如下：

如果洞 $T_{i}$ 中有一颗牙齿，则将牙齿从洞 $T_{i}$ 中取出。
如果洞 $T_{i}$ 中没有牙齿（即洞是空的），则在洞 $T_{i}$ 中种植一颗牙齿。

完成所有治疗后，Takahashi 有多少颗牙齿？

限制

所有输入的值都是整数。
$1 \leq N,Q \leq 1000$
$1 \leq T_{i} \leq N$ $28$

输入格式

$N \hspace{1em} Q\\ T_{1} \hspace{1em} T_{2} \hspace{1em} \cdots \hspace{1em} T_{Q}$

输出格式

输出一个表示牙齿数量的整数

样例输入输出

输入样例1

$30 \hspace{0.5em} 6 \\ 2 \hspace{0.5em} 9 \hspace{0.5em} 18 \hspace{0.5em} 27 \hspace{0.5em} 18 \hspace{0.5em} 9$

输出样例1

$28$

开始时，Takahashi 有 30 颗牙齿，Aoki 进行了六次治疗。

在第一次治疗中，处理了第 2 号洞。洞中有一颗牙齿，因此将其移除。
在第二次治疗中，处理了第 9 号洞。洞中有一颗牙齿，因此将其移除。
在第三次治疗中，处理了第 18 号洞。洞中有一颗牙齿，因此将其移除。
在第四次治疗中，处理了第 27 号洞。洞中有一颗牙齿，因此将其移除。
在第五次治疗中，处理了第 18 号洞。洞中没有牙齿，因此长出一颗新牙。
在第六次治疗中，处理了第 9 号洞。洞中没有牙齿，因此长出一颗新牙。

最终的牙齿数为 28 颗。

输入样例2

$1 \hspace{0.5em} 7\\ 1 \hspace{0.5em} 1 \hspace{0.5em} 1 \hspace{0.5em} 1 \hspace{0.5em} 1 \hspace{0.5em} 1 \hspace{0.5em} 1$

输出样例2

$0$

输入样例3

$9 \hspace{0.5em} 20\\ 9 \hspace{0.5em} 5 \hspace{0.5em} 1 \hspace{0.5em} 2 \hspace{0.5em} 2 \hspace{0.5em} 2 \hspace{0.5em} 8 \hspace{0.5em} 9 \hspace{0.5em} 2 \hspace{0.5em} 1 \hspace{0.5em} 6 \hspace{0.5em} 2 \hspace{0.5em} 6 \hspace{0.5em} 5 \hspace{0.5em} 8 \hspace{0.5em} 7 \hspace{0.5em} 8 \hspace{0.5em} 5 \hspace{0.5em} 9 \hspace{0.5em} 8$

输出样例3

$5$

代码

#include <bits/stdc++.h>
using namespace std;

int n, q, t[1005], vis[1005], cnt = 0;

inline int read() {
	int x = 0, f = 1; char c = getchar();
	while (c < '0' || c > '9') {
		if (c == '-') f = -1;
		c = getchar();
	}
	while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
	return x * f;
}

int main() {
	n = read(), q = read();
	for (int i = 1; i <= q; i++) {
		t[i] = read();
		vis[t[i]] ^= 1;
	} // 0为有牙, 1为无牙
	for (int i = 1; i <= n; i++) if (!vis[i]) cnt++;
	cout << cnt;
    return 0;
}

C - Sort

时间限制：2秒内存限制：1024MB

分数：300分

问题描述

给定一个对于 1，2，…， N 的排列 $A = \{A_{1}, A_{2},\cdots,A_{N}\}$ 。

通过执行以下操作，将 A 转换为 (1，2，…，N)，操作可以执行 0 到 N - 1 次，包括 0 和 N - 1：

操作：选择任意一对整数(i，j)，使得1 ≤ i < j ≤ N。交换 A 中第 i 个位置和第 j 个位置的元素。

可以证明，在给定的约束条件下，总是可以将 A 变换为(1，2，…，N)。

限制

$2 \leq N \leq 2 \times 10^{5}$
$(A_{1}, A_{2},\cdots,A_{N})$ 是 1，2，…， N 的全排列
所有输入的值都是整数。

输入格式

$N \\ A_{1} \hspace{1em} A_{2} \hspace{1em} \cdots \hspace{1em} A_{N}$

输出格式

        设 K 为操作的次数。输出 K + 1 行。
        第一行输出 K。
        第 (l + 1) 行（1 ≤ l ≤ K）应包含选定用于第 l 次操作的整数 i 和 j，用一个空格分隔。
        任何满足问题描述中条件的输出都是正确。

输入输出样例

输入样例1

$5\\ 3 \hspace{0.5em} 4 \hspace{0.5em} 1 \hspace{0.5em} 2 \hspace{0.5em} 5$

输出样例1

$2\\ 1 \hspace{0.5em} 3\\ 2 \hspace{0.5em} 4$

操作会改变序列如下：

初始时，A = (3，4，1，2，5)。
第一次操作交换第一个和第三个元素，变为 A = (1，4，3，2，5)。
第二次操作交换第二个和第四个元素，变为 A = (1，2，3，4，5)。

一下其他类似的输出也是正确的：

$4\\ 2 \hspace{0.5em} 3\\ 3 \hspace{0.5em} 4\\ 1 \hspace{0.5em} 2\\ 2 \hspace{0.5em} 3\\$

输入样例2

$4\\ 1 \hspace{0.5em} 2 \hspace{0.5em} 3 \hspace{0.5em} 4$

输出样例2

$0$

输入样例3

$3\\ 3 \hspace{0.5em} 1 \hspace{0.5em} 2$

输出样例3

$2\\ 1 \hspace{0.5em} 2\\ 2 \hspace{0.5em} 3$

思路

由于 $N \leq 2 \times 10^{5}$ 所以如果使用冒泡排序的话一定会超时，需要考虑 $O(n)$ 时间复杂度的算法。我们可以开一个 vis 数组来存 1，2，…，N 中每个元素的位置，当 a[ i ] 不等于 i 的时候再进行交换，同时用一个 vector 储存被选取得整数对 i，j ，最后按照格式输出即可。

代码

#include <bits/stdc++.h>
using namespace std;

const int N = 2e5 + 10;
int n, a[N], vis[N], flag = 0;
vector<pair<int,int>> v;

inline int read() {
	int x = 0, f = 1; char c = getchar();
	while (c < '0' || c > '9') {
		if (c == '-') f = -1;
		c = getchar();
	}
	while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
	return x * f;
}

int main() {
	n = read();
	for (int i = 1; i <= n; i++) {
		a[i] = read();
		if (a[i] != i) flag = 1;
		vis[a[i]] = i;
	}
	if (flag) {
		for (int i = 1; i <= n; i++) {
			if (a[i] != i) {
				v.push_back(make_pair(i, vis[i]));
				vis[a[i]] = vis[i];
				a[vis[i]] = a[i];
				vis[i] = i;
			}
		}
	}
	printf("%d\n", v.size());
	for (auto i : v) printf("%d %d\n", i.first, i.second);
    return 0;
}

E - Toward 0

时间限制：2秒内存限制：1024MB

分数：450分

问题描述

题目给定一个整数 N。你可以进行以下两种操作：

1. 支付 X 日元，将 N 替换为 $\left \lfloor \frac{N}{A} \right \rfloor$ 。
2. 支付 Y 日元，掷一个显示 1 到 6 之间整数的骰子（各数值出现的概率相同）。设掷出的结果为 b，将 N 替换为 $\left \lfloor \frac{N}{b} \right \rfloor$ 。

这里， $\left \lfloor s \right \rfloor$ 表示不大于 s 的最大整数。例如， $\left \lfloor 3 \right \rfloor = 3$ 和 $\left \lfloor 2.5 \right \rfloor = 2$ 。

你需要确定在最优选择操作的情况下，使 N 变为 0 之前所支付的最小预期费用。

每次操作中的骰子结果是相互独立的，并且可以在观察到前一次操作结果后再选择操作。

限制

$1 \leq N \leq 10^{18}$
$2 \leq A \leq 6$
$1 \leq X,Y \leq 10^{9}$
All input values are integers.

输入格式

输入内容由标准输入提供，格式如下：

$N \hspace{1.0em} A \hspace{1.0em} X \hspace{1.0em} Y$

输出格式

输出答案。

如果输出的绝对误差或相对误差与正确答案最多为 $10^{6}$ ，则视为正确。

输入输出样例

输入样例1

$3 \hspace{0.5em} 2 \hspace{0.5em} 10 \hspace{0.5em} 20$

输出样例1

$20.000000000000000$

可用的操作如下：

支付 10 日元，将 N 替换为 $\left \lfloor \frac{N}{2} \right \rfloor$ 。
支付 20 日元，掷一个骰子。设结果为 b，将 N 替换为 $\left \lfloor \frac{N}{b} \right \rfloor$ 。

最优策略是执行第一种操作两次。

输入样例2

$3 \hspace{0.5em} 2 \hspace{0.5em} 20 \hspace{0.5em} 20$

输出样例2

$32.000000000000000$

可用的操作如下：

支付 10 日元，将 N 替换为 $\left \lfloor \frac{N}{2} \right \rfloor$ 。
支付 20 日元，掷一个骰子。设结果为 b，将 N 替换为 $\left \lfloor \frac{N}{b} \right \rfloor$ 。

最优策略如下：

首先，执行第二种操作来掷骰子。

如果结果是 4 或更大，那么 N 变为0。

如果结果是 2 或 3，那么 N 变为1。此时，执行第一种操作使 N = 0。

如果结果是 1，则重新开始。

输入样例3

$314159265358979323 \hspace{0.5em} 4 \hspace{0.5em} 223606797 \hspace{0.5em} 173205080$

输出样例3

$6418410657.7408381$

思路

分别对于两种操作求期望，利用map来储存期望值

操作1： $dfs(N) = dfs(\left \lfloor \frac{N}{A} \right \rfloor) + X$

操作2： $dfs(N) = \frac{1}{6} \sum_{i = 1}^{6}dfs(\frac{N}{i}) +Y$

由于等式两边都有 $dfs(N)$ ，因此可以进行化简（否则在实际操作的时候由于 $dfs(N)$ 会一直调用 $dfs(N)$ 陷入死循环），化简后结果是 $dfs(N) = \frac{1}{5}\sum_{i = 2}^{6} dfs(\frac{N}{i}) + \frac{6}{5}Y$

代码

#include<bits/stdc++.h>
using namespace std;

#define int long long
#define double long double //提高精度

int n, a, x, y;
map<int, double> mp;

inline int read() {
	int x = 0, f = 1; char c = getchar();
	while (c < '0' || c > '9') { if (c == '-') f = -1; c = getchar(); }
	while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
	return x * f;
}

double dfs(int tar) {
	if (tar == 0) return 0.0;
	if (mp[tar]) return mp[tar];
	double ans = y;
	for (int i = 2; i <= 6; i++) ans += dfs(tar / i) + y;
	ans /= 5.0;
	mp[tar] = min(ans, dfs(tar / a) + x);
	return mp[tar];
} // 记忆化搜索

signed main(){
	n = read(), a = read(), x = read(), y = read();
	dfs(n);
	printf("%.15Lf\n", mp[n]);
    return 0;
}