2020牛客多校联赛第三场 （ABCLEF）
文章目录
- A：Clam and Fish
- 题目
- 翻译
- 例子
- 大意
- 思路
- 代码
- B： Classical String Problem
- 题目
- 翻译
- 例子
- 思路
- 代码
- C： Operation Love
- 题目
- 翻译
- 例子
- 大意
- 思路
- 代码
- L： Problem L is the Only Lovely Problem
- 题目
- 翻译
- 例子
- 大意
- 思路
- 代码
- E：Two Matchings
- 题目
- 翻译
- 例子
- 思路
- 代码
- F： Fraction Construction Problem
- 题目
- 翻译
- 例子
- 思路
- 代码
A：Clam and Fish
题目
There is a fishing game as following:
The game contains nn stages, numbered from 11 to nn.
There are four types of stages (numbered from 00 to 33):
type 0: There are no fish and no clam in this stage.
type 1: There are no fish and one clam in this stage.
type 2: There are one fish and no clam in this stage.
type 3: There are one fish and one clam in this stage.
In each stage, you can do exactly one of the following four actions.
1、If there is a clam in the stage, you can use this clam to make one pack of fish bait. And the number of packs of fish bait you have is increased by one. You can use this pack of fish bait to catch fish after this stage.
2、If there is one fish in the stage, you can catch this fish without any fish bait. After this stage, the number of packs of fish bait you have is not changed.
3、If you have at least one pack of fish bait. You can always catch one fish by using exactly one pack of fish bait even if there are no fish in this stage. After this stage, the number of packs of fish bait you have is decreased by one.
4、You can do nothing.
Now, you are given nn and the type of each stage. Please calculate the largest number of fish you can get in the fishing game.
输入描述:
The first line contains one integer t (1 \le t \le 2.5 \times 10^51≤t≤2.5×10
5
) — the number of test cases.
There are two lines in each test. The first line contains one integer n (1 \le n \le 2 \times 10^61≤n≤2×10
6
), indicating the number of stages in this game. The second line contains a string with length n. The i-th character of this string indicates the type of the i-th stage.
The sum of n across the test cases doesn’t exceed 2 \times 10^62×10
6
.
输出描述:
For each test case print exactly one integer — the maximum number of fish you can catch in the game configuration.
翻译
有一个钓鱼游戏如下:
博弈包含n阶段，从1到n编号。
有四种阶段(编号从0到3):
0型:这个阶段没有鱼和蛤蜊。
类型1:这个阶段没有鱼，只有一只蛤蜊。
类型2:只有一条鱼，这个阶段没有蛤蜊。
类型3:在这个阶段有一条鱼和一只蛤蜊。
在每个阶段，您都可以执行以下四个操作中的一个。
1、如果在这个阶段有一只蛤蜊，你可以用这个蛤蜊做一袋鱼饵。鱼饵的数量增加了一袋。你可以用这包鱼饵在下个阶段捕鱼。
2、如果舞台上有一条鱼，你不用任何鱼饵就能钓到这条鱼。这一阶段结束后，鱼饵包的数量就不会改变了。
3、如果你至少有一包鱼饵。即使在这个阶段没有鱼，你也可以用一袋鱼饵钓到一条鱼。在这一阶段之后，鱼饵的数量会减少一袋。
4、你什么也做不了。
现在，已知n和每个阶段的类型。请计算在钓鱼游戏中你能得到的鱼的最大数量。
输入描述:
第一行包含一个整数t (1≤t≤2.5×10^5)——测试用例的数量。
每个测试中有两行。第一行包含一个整数n ( 1≤n≤2 ×10^6)，表示游戏的阶段数。第二行包含一个长度为n的字符串。该字符串的第i个字符表示第i阶段的类型。
整个测试用例的n的和不超过2*10^6。
输出描述:
对于每个测试用例，打印一个整数——在游戏配置中可以捕获的鱼的最大数量。
例子
输入
2
4
0103
1
1
输出
2
0
大意
给出阶段数和相应的类型数，判断可获得的鱼最大数量。
思路
有鱼的天数就抓一条鱼，光有蛤的时候，可以选择这一阶段做鱼饵还是在这一天用鱼饵钓一条鱼。遍历一遍，即 0 的时候有鱼饵就用鱼饵钓鱼，2,3 都是钓鱼。对 1 ，可以捕鱼也可以做鱼饵，但是默认制饵，最后加上剩下的鱼饵数除 2 就是答案，可以当作一半用来制饵，一半用来捕鱼。就是内容的储存与变换，确认鱼饵与鱼的数量。
代码
#include B： Classical String Problem
题目
Given a string S consists of lower case letters. You’re going to perform Q operations one by one. Each operation can be one of the following two types:
// Modify: Given an integer x. You need to modify S according to the value of x. If x is positive, move the leftmost x letters in S to the right side of S; otherwise, move the rightmost |x| letters in S to the left side of S.
// Answer: Given a positive integer x. Please answer what the x-th letter in the current string S is.
翻译
给定字符串S由小写字母组成。你将一个接一个地执行Q运算。每种操作可以是以下两种类型之一:
//修改:给定一个整数x，需要根据x的值对S进行修改，如果x为正，则将S中最左边的x个字母移到S的右侧;否则，把S中最右边的|x|字母移到S的左边。
//回答:给定一个正整数x。请回答当前字符串S中的第x个字母是什么。
例子
输入
nowcoder
6
A 1
M 4
A 6
M -3
M 1
A 1
输出
n
o
w
思路
明确任务，选择相应的任务完成，输出结果。
代码
#include C： Operation Love
题目
Alice is a beauty in a robot society. So many robots want to marry her. Alice determines to marry a robot who can solve the following puzzle:
Firstly, the shape of Alice’s right palm is as follow:
And the shape of Alice’s left palm is symmetrical to her right palm.
In this puzzle, Alice will give the challenger many handprints of her palm. The challenger must correctly tell Alice each handprint is her left palm or right palm. Notice that the handprint of Alice’s palm is given by its 2D plane coordinates in clockwise or counterclockwise order. And The shape may be rotated and translated. But the shape won’t be zoomed in nor be zoomed out.
Although you are not a robot, you are interested in solving puzzles. Please try to solve this puzzle.
输入描述:
The first line contains one integer t (1 \le t \le 10^31≤t≤10
3
) — the number of handprints in Alice’s puzzle.
Each handprint is described by a simple polygon composed of 20 points. Each point in this polygon will be given in clockwise or counterclockwise order. Each line contains two real numbers with exactly six digits after the decimal point, representing the coordinate of a point. So a handprint is composed of 20 lines in the input.
All values of coordinate in the input is in the range [-1000.0000000, 1000.000000].
输出描述:
For each footprint of palm, print a line contains “right” or “left”, indicating the footprint is the right palm or the left palm respectively.
翻译
爱丽丝是机器人社会中的美女。很多机器人都想娶她。爱丽丝决定嫁给一个能解开以下难题的机器人:
首先，爱丽丝右手掌的形状如下:
爱丽丝左手掌的形状和右手掌是对称的。
在这个谜题中，爱丽丝会给挑战者很多她的手印。挑战者必须正确地告诉爱丽丝每个手印是她的左手掌还是右手掌。请注意，爱丽丝手掌上的手印是由它的二维平面坐标按顺时针或逆时针顺序给出的。形状可以旋转和平移。但形状不会被放大或缩小。
虽然你不是机器人，但你对解决谜题很感兴趣。请试着解决这个难题。
输入描述:
第一行包含一个整数t (1 \le t \le 10^31≤t≤10)
3.
)——爱丽丝的字谜中手印的数目。
每个手印由20个点组成的简单多边形描述。多边形中的每个点将按顺时针或逆时针顺序给出。每条线包含两个实数，小数点后有六位，表示一个点的坐标。所以一个手印在输入中由20行组成。
输入的坐标值均在[-1000.0000000,1000.000000]范围内。
输出描述:
对于每个掌纹，打印一条包含“右”或“左”的线，表示掌纹分别是右掌纹或左掌纹。
例子
示例1
输入
2
1.000000 0.000000
10.000000 0.000000
10.000000 8.000000
9.000000 8.000000
9.000000 5.000000
8.000000 5.000000
8.000000 10.000000
7.000000 10.000000
7.000000 5.000000
6.000000 5.000000
6.000000 10.000000
5.000000 10.000000
5.000000 5.000000
4.000000 5.000000
4.000000 10.000000
3.000000 10.000000
3.000000 3.000000
2.000000 3.000000
2.000000 6.000000
1.000000 6.000000
-1.000123 0.000000
-10.000123 0.000000
-10.000123 8.000000
-9.000123 8.000000
-9.000123 5.000000
-8.000123 5.000000
-8.000123 10.000000
-7.000123 10.000000
-7.000123 5.000000
-6.000123 5.000000
-6.000123 10.000000
-5.000123 10.000000
-5.000123 5.000000
-4.000123 5.000000
-4.000123 10.000000
-3.000123 10.000000
-3.000123 3.000000
-2.000123 3.000000
-2.000123 6.000000
-1.000123 6.000000
输出
right
left
示例2
输入
1
19.471068 -6.709056
13.814214 -1.052201
13.107107 -1.759308
15.228427 -3.880629
14.521320 -4.587735
10.985786 -1.052201
10.278680 -1.759308
13.814214 -5.294842
13.107107 -6.001949
9.571573 -2.466415
8.864466 -3.173522
12.400000 -6.709056
11.692893 -7.416162
8.157359 -3.880629
7.450253 -4.587735
12.400000 -9.537483
11.692893 -10.244590
9.571573 -8.123269
8.864466 -8.830376
13.107107 -13.073017
输出
right
大意
根据所给数据，将这个手掌通过旋转或平移，判断是左掌还是右掌。
思路
因为不改变手掌的大小，值改变手掌的位置和方向，所以只需要找到相邻且没重复的两条边，用叉积判断他们的位置关系即可判断是左手还是右手。
向量的点乘:a * b
公式：a * b = |a| * |b| * cosθ 点乘又叫向量的内积、数量积，是一个向量和它在另一个向量上的投影的长度的乘积；是标量。
向量的叉乘：a x b
a x b = |a| * |b| * sinθ 向量积被定义为： 模长：（在这里θ表示两向量之间的夹角(共起点的前提下)（0° ≤ θ ≤ 180°），它位于这两个矢量所定义的平面上。）
需要注意的是，若左手掌逆时针输入的话，边的长度就和顺时针的右手掌一样，所以也要计算一遍叉积。
在CSDN题解上发现的一张图很清晰明了
代码
const int mxn = 1010;
const double eps = 1e-3;
struct po
{
double x, y;
} a[mxn];
po operator-(po a, po b)
{
return (po){a.x - b.x, a.y - b.y};
}
double len(po a)
{
return sqrt(a.x * a.x + a.y * a.y);
}
bool dengyu(double x, double y)
{
return abs(x - y) < eps;
}
int n = 20;
double cro(po a, po b)
{
return a.x * b.y - b.x * a.y;
}
bool sol()
{
for (int i = 0; i < n; i++)
{
scanf("%lf%lf", &a[i].x, &a[i].y);
}
a[n] = a[0];
a[n + 1] = a[1];
for (int i = 0; i <= n; i++)
{
po p = a[i + 1] - a[i], q = a[i + 2] - a[i + 1];
if (dengyu(len(p), 6.0) && dengyu(len(q), 9.0))
{
return cro(p, q) > 0;
}
} //逆时针给点
for (int i = 0; i <= n; i++)
{
po p = a[i + 1] - a[i], q = a[i + 2] - a[i + 1];
if (dengyu(len(q), 6.0) && dengyu(len(p), 9.0))
{
return cro(q, p) > 0;
}
} //顺时针给点
return 0;
}
int main()
{
int T;
scanf("%d", &T);
while (T--)
{
if (!sol())
printf("left\n");
else
printf("right\n");
}
return 0;
}
L： Problem L is the Only Lovely Problem
题目
Dreamoon loves lovely things, like lovely girls, lovely bed sheets, lovely clothes…
So he thinks a string is lovely if and only if it begins with the word “lovely”(case insensitive). You are given a string. Please tell us whether Dreamoon thinks that string is lovely.
输入描述:
The input contains only one line.
This line contains a string s s s. The length of s s s is between 8 8 8 and 10 10 10.
s s s consists of only the English alphabet. It can be lower case or upper case.
输出描述:
If a string is lovely, please output “lovely”, Otherwise, output “ugly”. (The output is case sensitive).
翻译
梦乡喜欢可爱的东西，像可爱的女孩，可爱的床单，可爱的衣服……
所以他认为一个字符串只有在以单词“lovely”(大小写不敏感)开头时才是可爱的。给你一个字符串。请告诉我们梦是否认为那弦是可爱的。
输入描述:
输入只包含一行。
这一行包含一个字符串 s s s。 s s s的长度在 8 8 8和 10 10 10之间。
s s s只包含英文字母。它可以是小写或大写。
输出描述:
如果字符串很可爱，请输出“lovely”，否则输出“ugly”。(输出区分大小写)
例子
示例1
输入
LovelyAA
输出
lovely
示例2
输入
lovelymoon
输出
lovely
示例3
输入
NOWCOWDER
输出
ugly
示例4
输入
LoveLive
输出
ugly
大意
给出例子，注意例子的开头是不是Lovely，并且lively的相应字母有可能大写也有可能小写。给出相应的答案。
思路
只注意开头，并且不区分大小写，且判断条件不可一次写完，要分段写，一个一个判断。
代码
#includeE：Two Matchings
题目
翻译
例子
输入
2
4
0 8 0 0
6
3 1 4 1 5 9
输出
16
16
思路
有 n 个点，每个点一个值，要求求出两个 1 - n 的排列满足排列的任意两个相同下标的值都不同，并且这两个排列要满足下标不等于值，并且要满足两两交换，即以这个下标的值为下标的值等于这个下标，换句话来说，就是两两一组交换下标。求出按照这两个排列分成的n/2组数对的差的绝对值之和的最小值并输出
首先最小的置换一定是将数组排序后，相邻的两个数字的下标交换，考虑次小，一定是4个数字一组交换或者6个数字一组交换最优，8个一组可以拆成 4 和 4，2个一组和之前的排列重合了，所以考虑 dp ，并且4个一组的贡献是确定的（可以通过枚举来得到次小值），假设 a
原文链接：https://blog.csdn.net/qq_41608020/article/details/107449661
代码
#includeF： Fraction Construction Problem
题目
翻译
例子
输入
3
4 1
1 6
37111
输出
-1 -1 -1 -1
1 2 1 3
145 87 104 78
思路
来源于以下博客：
原文链接：https://blog.csdn.net/qq_43627087/article/details/107446337
代码
void exgcd(ll a, ll b, ll &x, ll &y)
{
if (!b)
{
x = 1, y = 0;
return;
}
exgcd(b, a % b, y, x);
y -= a / b * x;
}
const int N = 2e6 + 10;
int pri[N], cnt;
bool st[N];
int Mipri[N];
void init(int n)
{
st[0] = st[1] = true;
Mipri[1] = 1;
for (int i = 2; i <= n; i++)
{
if (!st[i])
pri[cnt++] = i, Mipri[i] = i;
for (int j = 0; j < cnt && 1ll * i * pri[j] <= n; j++)
{
st[i * pri[j]] = true;
Mipri[i * pri[j]] = pri[j];
if (i % pri[j] == 0)
break;
}
}
}
int main()
{
init(N - 1);
int t;
sd(t);
while (t--)
{
int a, b;
sdd(a,b);
int g = gcd(a, b);
if (g > 1)
{
int e = 1, f = 1, c = a / g + b / g, d = b / g;
printf("%d %d %d %d\n", c, d, e, f);
}
else
{
ll d = 1, f = b, k = Mipri[b];
while (k != 1 && f % k == 0)
d *= k, f /= k;
if (d == b && f == 1)
puts("-1 -1 -1 -1");
else
{
ll e, c;
exgcd(d, f, e, c);
e = -e;
while (e <= 0 || c <= 0)
{
c += d;
e += f;
}
e *= a, c *= a;
printf("%lld %lld %lld %lld\n", c, d, e, f);
}
}
}
return 0;
}