AtCoder Beginner Contest 314（A~D题 + G题）讲解

A - 3.14

Description

Problem Statement

The number pi to the $100$-th decimal place is
3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679.
You are given an integer $N$ between $1$ and $100$, inclusive.
Print the value of pi to the $N$-th decimal place.
More precisely, truncate the value of pi to $N$ decimal places and print the result without removing the trailing 0s.

Constraints

$1\le N\le 100$
$N$ is an integer.

Input

The input is given from Standard Input in the following format:

$N$

Output

Print the value of pi to the $N$-th decimal place in a single line.

Sample Input 1

2

Sample Output 1

3.14

Truncating the value of pi to $2$ decimal places results in 3.14. Thus, you should print 3.14.

Sample Input 2

32

Sample Output 2

3.14159265358979323846264338327950

Do not remove the trailing 0s.

Sample Input 3

100

Sample Output 3

3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679

Solution

用一个 string 存储一下然后访问即可。

Code

#include <bits/stdc++.h>
#define int long long

using namespace std;

string s = "3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679";

signed main()
{
	cin.tie(0);
	cout.tie(0);
	ios::sync_with_stdio(0);

	int n;

	cin >> n;

	for (int i = 0; i <= n + 1; i ++)
		cout << s[i];

	return 0;
}

B - Roulette

Problem Statement

$N$ people, person $1$, person $2$, $\dots$, person $N$, are playing roulette.
The outcome of a spin is one of the $37$ integers from $0$ to $36$.
For each $i=1,2,\dots ,N$, person $i$ has bet on $C_i$ of the $37$ possible outcomes: $A_{i,1},A_{i,2},\dots ,A_{i,C_i}$.
The wheel has been spun, and the outcome is $X$.
Print the numbers of all people who have bet on $X$ with the fewest bets, in ascending order.
More formally, print all integers $i$ between $1$ and $N$, inclusive, that satisfy both of the following conditions, in ascending order:
Person $i$ has bet on $X$.
For each $j=1,2,\dots ,N$, if person $j$ has bet on $X$, then $C_i\le C_j$.
Note that there may be no number to print (see Sample Input 2).

Constraints

$1\le N\le 100$
$1\le C_i\le 37$
$0\le A_{i,j}\le 36$
$A_{i,1},A_{i,2},\dots ,A_{i,C_i}$ are all different for each $i=1,2,\dots ,N$.
$0\le X\le 36$
All input values are integers.

Input

The input is given from Standard Input in the following format:

$N$
$C_1$
$A_{1,1}$ $A_{1,2}$ $\dots$ $A_{1,C_1}$
$C_2$
$A_{2,1}$ $A_{2,2}$ $\dots$ $A_{2,C_2}$
$⋮$
$C_N$
$A_{N,1}$ $A_{N,2}$ $\dots$ $A_{N,C_N}$
$X$

Output

Let $B_1,B_2,\dots ,B_K$ be the sequence of numbers to be printed in ascending order.
Using the following format, print the count of numbers to be printed, $K$, on the first line,
and $B_1,B_2,\dots ,B_K$ separated by spaces on the second line:

$K$
$B_1$ $B_2$ $\dots$ $B_K$

Sample Input 1

4
3
7 19 20
4
4 19 24 0
2
26 10
3
19 31 24
19

Sample Output 1

2
1 4

The wheel has been spun, and the outcome is $19$.
The people who has bet on $19$ are person $1$, person $2$, and person $4$, and the number of their bets are $3$, $4$, and $3$, respectively.
Therefore, among the people who has bet on $19$, the ones with the fewest bets are person $1$ and person $4$.

Sample Input 2

3
1
1
1
2
1
3
0

Sample Output 2

0

The wheel has been spun and the outcome is $0$, but no one has bet on $0$, so there is no number to print.

Solution

按照题目中所说的暴力即可，注意要升序排列。

Code

#include <bits/stdc++.h>
#define int long long

using namespace std;

const int N = 1e2 + 10;

int n;
int t[N];
int a[N];
unordered_map<int, int> pos[N];

signed main()
{
	cin.tie(0);
	cout.tie(0);
	ios::sync_with_stdio(0);

	cin >> n;

	for (int i = 1; i <= n; i ++)
	{
		cin >> t[i];
		for (int j = 1; j <= t[i]; j ++)
			cin >> a[j], pos[i][a[j]] = 1;
	}

	int x;

	cin >> x;

	std::vector<pair<int, int>> v;
	for (int i = 1; i <= n; i ++)	
		if (pos[i][x])
			v.push_back({t[i], i});

	sort(v.begin(), v.end());

	for (int i = 1; i < v.size(); i ++)
		if (v[i].first > v[i - 1].first)
		{
			cout << i << endl;
			std::vector<int> v2;
			for (int j = 0; j < i; j ++)
				v2.push_back(v[j].second);

			sort(v2.begin(), v2.end());

			for (auto c : v2)
				cout << c << " ";

			return 0;
		}

	std::vector<int> v2;
	for (int j = 0; j < v.size(); j ++)
		v2.push_back(v[j].second);

	sort(v2.begin(), v2.end());

	cout << v2.size() << endl;
	for (auto c : v2)
		cout << c << " ";

	return 0;
}

C - Rotate Colored Subsequence

Description

Problem Statement

You are given a string $S$ of length $N$ consisting of lowercase English letters.
Each character of $S$ is painted in one of the $M$ colors: color $1$, color $2$, …, color $M$; for each $i=1,2,\dots ,N$, the $i$-th character of $S$ is painted in color $C_i$.
For each $i=1,2,\dots ,M$ in this order, let us perform the following operation.
Perform a right circular shift by $1$ on the part of $S$ painted in color $i$.
That is, if the $p_1$-th, $p_2$-th, $p_3$-th, $\dots$, $p_k$-th characters are painted in color $i$ from left to right, then simultaneously replace the $p_1$-th, $p_2$-th, $p_3$-th, $\dots$, $p_k$-th characters of $S$ with the $p_k$-th, $p_1$-th, $p_2$-th, $\dots$, $p_{k-1}$-th characters of $S$, respectively.
Print the final $S$ after the above operations.
The constraints guarantee that at least one character of $S$ is painted in each of the $M$ colors.

Constraints

$1\le M\le N\le 2\times 10^5$
$1\le C_i\le M$
$N$, $M$, and $C_i$ are all integers.
$S$ is a string of length $N$ consisting of lowercase English letters.
For each integer $1\le i\le M$, there is an integer $1\le j\le N$ such that $C_j=i$.

Input

The input is given from Standard Input in the following format:

$N$ $M$
$S$
$C_1$ $C_2$ $\dots$ $C_N$

Output

Print the answer.

Sample Input 1

8 3
apzbqrcs
1 2 3 1 2 2 1 2

Sample Output 1

cszapqbr

Initially, $S = $ apzbqrcs.
For $i=1$, perform a right circular shift by $1$ on the part of $S$ formed by the $1$-st, $4$-th, $7$-th characters, resulting in $S = $ cpzaqrbs.
For $i=2$, perform a right circular shift by $1$ on the part of $S$ formed by the $2$-nd, $5$-th, $6$-th, $8$-th characters, resulting in $S = $ cszapqbr.
For $i=3$, perform a right circular shift by $1$ on the part of $S$ formed by the $3$-rd character, resulting in $S = $ cszapqbr (here, $S$ is not changed).
Thus, you should print cszapqbr, the final $S$.

Sample Input 2

2 1
aa
1 1

Sample Output 2

aa

Solution

其实暴力交换就行，看似是两重循环，但其实还是 $O(n)$ 的，大家不要被其迷惑了双眼。
因为，我们其实复杂度是 $O(\sum _{i=1}^k{M}_i)$，其中 $k$ 为颜色数量，$M_i$为每一种颜色数量的个数。但是 $\sum _{i=1}^k{M}_i$其实就等于 $n$，所以时间复杂度还是 $O(n)$ 的。

Code

#include <bits/stdc++.h>
#define int long long

using namespace std;

const int N = 2e5 + 10;

int n, m;
string s;
int c[N];
std::vector<int> pos[N];

signed main()
{
	cin.tie(0);
	cout.tie(0);
	ios::sync_with_stdio(0);

	cin >> n >> m >> s;

	for (int i = 0; i < n; i ++)
		cin >> c[i], pos[c[i]].push_back(i);

	for (int i = 1; i <= m; i ++)
	{
		for (int j = pos[i].size() - 1; j >= 1; j --)
			swap(s[pos[i][j]], s[pos[i][j - 1]]);
	}

	cout << s << endl;

	return 0;
}

D - LOWER

Problem Statement

You are given a string $S$ of length $N$ consisting of uppercase and lowercase English letters.
Let us perform $Q$ operations on the string $S$.
The $i$-th operation $(1\le i\le Q)$ is represented by a tuple $(t_i,x_i,c_i)$ of two integers and one character, as follows.
If $t_i=1$, change the $x_i$-th character of $S$ to $c_i$.
If $t_i=2$, convert all uppercase letters in $S$ to lowercase (do not use $x_i,c_i$ for this operation).
If $t_i=3$, convert all lowercase letters in $S$ to uppercase (do not use $x_i,c_i$ for this operation).
Print the $S$ after the $Q$ operations.

Constraints

$1\le N\le 5\times 10^5$
$S$ is a string of length $N$ consisting of uppercase and lowercase English letters.
$1\le Q\le 5\times 10^5$
$1\le t_i\le 3(1\le i\le Q)$
If $t_i=1$, then $1\le x_i\le N(1\le i\le Q)$.
$c_i$ is an uppercase or lowercase English letter.
If $t_i\ne 1$, then $x_i=0$ and $c_i=$ ‘a’.
$N,Q,t_i,x_i$ are all integers.

Input

The input is given from Standard Input in the following format:

$N$
$S$
$Q$
$t_1$ $x_1$ $c_1$
$t_2$ $x_2$ $c_2$
$⋮$
$t_Q$ $x_Q$ $c_Q$

Output

Print the answer in a single line.

Sample Input 1

7
AtCoder
5
1 4 i
3 0 a
1 5 b
2 0 a
1 4 Y

Sample Output 1

atcYber

Initially, the string $S$ is AtCoder.
The first operation changes the $4$-th character to i, changing $S$ to AtCider.
The second operation converts all lowercase letters to uppercase, changing $S$ to ATCIDER.
The third operation changes the $5$-th character to b, changing $S$ to ATCIbER.
The fourth operation converts all uppercase letters to lowercase, changing $S$ to atciber.
The fifth operation changes the $4$-th character to Y, changing $S$ to atcYber.
After the operations, the string $S$ is atcYber, so print atcYber.

Sample Input 2

35
TheQuickBrownFoxJumpsOverTheLazyDog
10
2 0 a
1 19 G
1 13 m
1 2 E
1 21 F
2 0 a
1 27 b
3 0 a
3 0 a
1 15 i

Sample Output 2

TEEQUICKBROWMFiXJUGPFOVERTBELAZYDOG

Solution

贪心的思路可以想到找到最后的一个 $3$ 或 $2$ 的操作，因为到达这个点要么都是小写，要么都是大写。所以在此之前只需要处理字符的转变即可，然后将整个序列全转成大写或小写，最后将后面的修改处理完就可以啦。

Code

#include <bits/stdc++.h>
#define int long long

using namespace std;

const int N = 5e5 + 10;

int n, q;
string s;
int op[N], x[N];
char c[N];

signed main()
{
	cin.tie(0);
	cout.tie(0);
	ios::sync_with_stdio(0);

	cin >> n >> s >> q;

	int last = 0;
	for (int i = 1; i <= q; i ++)
	{
		cin >> op[i] >> x[i] >> c[i];
		if (op[i] == 2 || op[i] == 3)
			last = i;
	}

	int l1 = 0, l2 = 0;
	for (int i = 1; i <= last; i ++)
		if (op[i] == 1)
			s[x[i] - 1] = c[i];
		else if (op[i] == 2)
			l1 = i;
		else
			l2 = i;

	if (l1 == 0 && l2 == 0);
	else if (l1 > l2)
	{
		for (auto &c : s)
			if (c >= 'A' && c <= 'Z')
				c = c - 'A' + 'a';
	}
	else
	{
		for (auto &c : s)
			if (c >= 'a' && c <= 'z')
				c = c - 'a' + 'A';
	}

	for (int i = last + 1; i <= q; i ++)
		s[x[i] - 1] = c[i];

	cout << s << endl;

	return 0;
}

E - Roulettes

奋力钻研中…

F - A Certain Game

奋力钻研中…

G - Amulets

Description

Problem Statement

There are $N$ monsters in a cave: monster $1$, monster $2$, $\dots$, monster $N$. Each monster has a positive integer attack power and a type represented by an integer between $1$ and $M$, inclusive.
Specifically, for $i=1,2,\dots ,N$, the attack power and type of monster $i$ are $A_i$ and $B_i$, respectively.
Takahashi will go on an adventure in this cave with a health of $H$ and some of the $M$ amulets: amulet $1$, amulet $2$, $\dots$, amulet $M$.
In the adventure, Takahashi performs the following steps for $i=1,2,\dots ,N$ in this order (as long as his health does not drop to $0$ or below).

• If Takahashi has not brought amulet $B_i$ with him, monster $i$ will attack him and decrease his health by $A_i$.
• Then,
  • if his health is greater than $0$, he defeats monster $i$;
  • otherwise, he dies without defeating monster $i$ and ends his adventure.

Solve the following problem for each $K=0,1,\dots ,M$ independently.

Find the maximum number of monsters that Takahashi can defeat when choosing $K$ of the $M$ amulets to bring on the adventure.

The constraints guarantee that there is at least one monster of type $i$ for each $i=1,2,\dots ,M$.

Constraints

$1\le M\le N\le 3\times 10^5$
$1\le H\le 10^9$
$1\le A_i\le 10^9$
$1\le B_i\le M$
For each $1\le i\le M$, there is $1\le j\le N$ such that $B_j=i$.
All input values are integers.

Input

The input is given from Standard Input in the following format:

$N$ $M$ $H$
$A_1$ $B_1$
$A_2$ $B_2$
$⋮$
$A_N$ $B_N$

Output

For each $i=0,1,2,\dots ,M$, let $X_i$ be the maximum number of monsters that Takahashi can defeat when $K=i$.
Print $X_0,X_1,\dots ,X_M$ separated by spaces in the following format:

$X_0$ $X_1$ $\dots$ $X_M$

Sample Input 1

7 3 7
3 2
1 1
4 2
1 2
5 1
9 3
2 3

Sample Output 1

2 5 7 7

Consider the case $K=1$. Here, Takahashi can bring amulet $2$ to defeat the maximum possible number of monsters, which is $5$.
The adventure proceeds as follows.
For $i=1$, he avoids the attack of monster $1$ since he has amulet $2$. Then, he defeats monster $1$.
For $i=2$, he takes the attack of monster $2$ and his health becomes $6$ since he does not have amulet $1$. Then, he defeats monster $2$.
For $i=3$, he avoids the attack of monster $3$ since he has amulet $2$. Then, he defeats monster $3$.
For $i=4$, he avoids the attack of monster $4$ since he has amulet $2$. Then, he defeats monster $4$.
For $i=5$, he takes the attack of monster $5$ and his health becomes $1$ since he does not have amulet $1$. Then, he defeats monster $5$.
For $i=6$, he takes the attack of monster $6$ and his health becomes $-8$ since he does not have amulet $3$. Then, he dies without defeating monster $6$ and ends his adventure.
Similarly, when $K=0$, he can defeat $2$ monsters; when $K=2$, he can defeat all $7$ monsters by bringing amulets $2$ and $3$; when $K=3$, he can defeat all $7$ monsters by bringing amulets $1$, $2$, and $3$.

Sample Input 2

15 5 400
29 5
27 4
79 1
27 2
30 3
4 1
89 2
88 3
75 5
3 1
39 4
12 1
62 4
38 2
49 1

Sample Output 2

8 12 15 15 15 15

Solution

动态维护每一种选择的护身符抵挡的伤害之和的集合($use$)，以及每一种不选择的护身符所造成的伤害之和的集合($unused$)。集合的类型为 multiset。

对于打死怪物 $1\sim x$（$x\in [1,n]$）：就是在打败怪物 $1\sim x-1$ 的基础上，打死怪物 $x$

• 如果之前选过怪物 $x$ 的类型的护身符，那么怪物 $x$ 就不会再造成伤害，那么 $use$ 集合中的抵挡当前怪物类型的伤害总和就会增加 $A_x$（$A_x$ 表示怪物 $x$ 的攻击量）
• 如果之前没有选过怪物 $x$ 的类型的护身符，那么怪物 $x$ 就会造成 $A_x$ 攻击量，所以对于 $unused$ 集合中怪物 $x$ 的类型所造成的伤害之和就会增加 $A_x$

然后，我们进行贪心的考虑，如果 $use$ 集合最小抵挡的伤害量，也就是 $use$ 集合的第一个元素（因为是 multiset，集合是升序的）小于 $unused$ 集合最大造成的伤害量，也就是 $unused$ 集合的最后一个元素，那么如果我们不选择 $use$ 集合第一个元素所代表的护身符的类型，而选择 $unused$ 集合最后一个元素所代表的护身符的类型，那么护身符所抵挡伤害之和一定就会增加，而我们所要承受的伤害反而会减少！何乐而不为呢？

当然我们在计算的过程中也要维护一个需要承受的伤害的总值，也就是 $unused$ 集合中所有元素的和。这样我们在每一次进行完上面的操作之后，承受的伤害总和一定是最少的了，所以此时判断一下有没有大于等于我们的血量，如果大于等于了，那么我们再贪心的选择 $unused$ 集合中选择抵挡血量最多的护身符，然后使用它。

最后，我们就需要统计答案了，对于打死怪物 $1\sim x$ 所需要的护身符数量，就是 $use$ 集合的元素个数，那么在 $1\sim x-1$ 所需要的护身符的数量，一直到小于当前 $use$ 集合的数量这一段区间所用的护身符都只能杀死 $x-1$ 只怪物，记录一下即可。然后，计算打死所有怪物的数量所需的护身符的数量。

这样，就可以顺利的解决这道题了！

Code

#include <bits/stdc++.h>
#define int long long

using namespace std;

const int SIZE = 3e5 + 10;

signed main()
{
	cin.tie(0);
	cout.tie(0);
	ios::sync_with_stdio(0);

	int N, M, H;

	cin >> N >> M >> H;

	std::vector<int> Attack(N + 1, 0), Kind(N + 1, 0);
	std::vector<int> Health(N + 1, 0); //Health存储每一种护身符的数量
	for (int i = 1; i <= N; i ++)
		cin >> Attack[i] >> Kind[i];

	multiset<int> Use, Unused; //存储每一种护身符选/不选所抵挡/造成的伤害之和
	int Health_Damage = 0, Amulets = 0;
	for (int i = 1; i <= M; i ++) Unused.insert(0);
	std::vector<int> Result(M + 1);
	for (int i = 1; i <= N; i ++)
	{
		int Past = Health[Kind[i]];
		int Now = Health[Kind[i]] + Attack[i];
		Health[Kind[i]] = Now;
		if (Use.count(Past)) //说明之前已经使用了这个种类，我们就可以将其抵挡的伤害改为Now。
		{
			Use.erase(Use.find(Past)); //删除再插入=修改 orz,orz！
			Use.insert(Now);
		}
		else //说明此时会造成伤害
		{
			Unused.erase(Unused.find(Past));
			Unused.insert(Now);
			Health_Damage += Attack[i]; //伤害数会增多
		}
		if (Use.size() && Unused.size() && *Unused.rbegin() > *Use.begin()) //这说明我们当前的选择不是最优，将其改为最优即可，之前讲解也说过了~~~
		{
			int A = *Unused.rbegin(), B = *Use.begin();
			Unused.erase(Unused.find(A));
			Unused.insert(B);
			Health_Damage += B - A; //造成的伤害数会减少
			Use.erase(Use.find(B));
			Use.insert(A);
		}
		if (Unused.size() && Health_Damage >= H) //说明我们嗝屁了，需要多一些护身符
		{
			int A = *Unused.rbegin(); //贪心的选择给我们防护最大的
			Unused.erase(Unused.find(A));
			Use.insert(A);
			Health_Damage -= A;
		}
		//大家可以想一想为什么上面两个用 if 即可，没有必要用 while
		while (Amulets < Use.size()) //记录答案，此时看似是个 while，其实总共最多就循环 m 次，因为 Amulets 会不停地加，最多加 M 次。
		{
			Result[Amulets] = i - 1; //这里我们考虑打死怪物 1 ~ i - 1 多少个护身符的个数，而不是打死怪物 i，因为有很多种可能，就比如说你选择 2 个或 3 个护身符都是打死怪物 i - 1，而此时我们只是知道打死怪物 i，所需的最少的个数，也就是下界，而不知道上界，上一次的打死 1 ~ i - 1 所需的数量就是下界，而此时诞生出了上界，也就是打死第 i 个怪物至少需要的次数减 1。所以考虑的是打死怪物 i - 1。如果还是不明白的话，可以手算一下~~~
			Amulets ++;
		}
	}

	while (Amulets <= M) //统计打死所有怪物，所需的护身符
	{
		Result[Amulets] = N;
		Amulets ++;
	}

	for (auto c : Result)
		cout << c << " ";

	return 0;
}

Time Complexity: O ( N log ⁡ 2 N ) O(N\log_2{N}) O(Nlog2​N)

参考了大佬 ksun48 的代码~~~文章来源地址https://www.toymoban.com/news/detail-645254.html

到了这里，关于AtCoder Beginner Contest 314（A~D题 + G题）讲解的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！