寒假预备役第一次测试

CF—1674C（1000）D

给一个只含小写字母 a 的字符串 s 和一个用来替换的字符串 t 。

你可以将 s 中任意一个字母 a 用 t 来替换，替换的次数不限。

对于每一个 s 和 t ，你可以得到几个不同的字符串？如果有无限个，输出 -1 。

Input

输入的第一行包含一个整数 q（1≤q≤10^4），表示测试数据组数。

对于每组测试数据：

• 第一行包含一个只包含 a 的非空字符串 s，s 的长度不超过 50。
• 第二行包含一个非空小写英文字符串 t，t 的长度不超过 50。

Output

对于每组测试数据，输出一个整数，表示你可以得到的不同的字符串数量。如果有无限个不同字符串，输出 -1。

Sample 1

Input	Output
3 aaaa a aa abc a b	1 -1 2

解题思路

本题为一道思维题，可以分为3种情况，

1.t串字符串中含有字符a且数量大于1

2.t串含有字符a且字符数量为1

3.t串不含有字符a

第一种情况下s串每次替换一个a又会加上a和其他字符，a可以无限使用，所以结果为 -1

第二种情况虽然可以无限次替换a但是s串没有变化所以结果为1；

第三种情况因为t串中没有a，所以替换次数取决于s串字符的数量，所以结果为2^n(n为s串字符的数量）

AC代码

#include<stdio.h>
#include<string.h>
int main()
{
	int q;
	long long dp[55] = { 0,2,0 };
	for (int i = 2; i <= 50; i++)//预处理2的n次方
		dp[i] = dp[i - 1] * 2;
	char a[66], t[66];
	scanf("%d", &q);
	while (q--)
	{
		int flag = 0;
		scanf("%s %s", a, t);
		int h = strlen(t);//字符串长度
		int k = strlen(a);//字符串长度
		if (h == 1)//t串字符为一
		{
			if (t[0] == 'a')
				printf("1\n");
			else//不为a输出2的n次方
				printf("%lld\n", dp[k]);
			continue;
		}
		else
		{
			for (int i = 0; i < h; i++)
			{
				if (t[i] == 'a')//如果存在字符a
				{
					flag = 1;
					break;
				}
			}
			if (flag == 1)//存在a，无限个
				printf("-1\n");
			else//不存在2的n次方个
				printf("%lld\n", dp[k]);
		}
	}
	return 0;
}

CF—1709B（900）E

你正在测试新的秘密Terraria更新。这个更新将在游戏中添加任务！

简单来说，世界地图可以表示为长度为n的数组，其中世界的第i列高度为ai。

你有m个任务需要测试。第j个任务由两个整数sj和tj表示。在这个任务中，你需要从第sj列移动到第tj列。在任务开始时，你出现在第sj列。

在一次移动中，你可以从第x列移动到第x−1列或者第x+1列。在这个版本中，你有幽灵靴，可以让你飞行。由于这是测试版本，它们有bug，所以只有在向上飞行时才能飞行，并且飞行持续时间无限。当你从高度为p的列移动到高度为q的列时，你会受到一定的坠落伤害。如果高度p大于高度q，你会受到p−q的坠落伤害，否则你会飞起来并受到0的伤害。

对于给定的每个任务，确定你在完成这个任务时可以受到的最小坠落伤害。

输入

输入的第一行包含两个整数n和m（2≤n≤10^5;1≤m≤10^5）— 世界中的列数和你需要测试的任务数。

输入的第二行包含n个整数a1,a2,…,an（1≤ai≤10^9），其中ai是世界的第i列的高度。

接下来的m行描述了任务。第j个任务包含两个整数sj和tj（1≤sj,tj≤n;sj≠tj1），表示你需要在第j个任务期间从第sj列移动到第tj列。

注意sj可能大于tj。

输出

输出m个整数。其中第j个整数应该是在第j个任务完成时你可以受到的最小坠落伤害。

示例 1

Input	Output
7 6 10 8 9 6 8 12 7 1 2 1 7 4 6 7 1 3 5 4 2	2 10 0 7 3 1

 解题思路

本题测试数据较大，暴力容易超限，前缀和一下就可以了，这题方向有两边，分别前缀和一下

AC代码

#include<stdio.h>
int n, m, a[200010], b[200010], c[200010];
long long dp1[200010], dp2[200010];
int main()
{
	scanf("%d %d", &n, &m);
	for (int i = 1; i <= n; i++)
		scanf("%d", &a[i]);
	for (int i = 1; i < n; i++)
	{
		//计算差值
		if (a[i] > a[i + 1])
			b[i] = a[i] - a[i + 1];
		else
			c[i] = a[i + 1] - a[i];
	}
	for (int i = 1; i < n; i++)//前缀和
	{
		dp1[i] = dp1[i - 1] + b[i];
		dp2[i] = dp2[i - 1] + c[i];
	}
	while (m--)//查询m次
	{
		int x, y;
		scanf("%d %d", &x, &y);
		if (x < y)//根据大小判断方向
			printf("%lld\n", dp1[y - 1] - dp1[x - 1]);
		else
			printf("%lld\n", dp2[x - 1] - dp2[y - 1]);
	}
	return 0;
}

CF—1920B（1100）F

爱丽丝和鲍勃正在玩一个游戏。 他们有一个数组 a1,a2,…,an。 游戏包括两个步骤：

• 首先，爱丽丝将从数组中移除 最多 k 个元素。
• 其次，鲍勃将把数组中的 最多 x 个元素乘以 −1。

爱丽丝希望最大化数组元素的和，而鲍勃希望最小化它。找到游戏结束后数组元素的总和，假设两位玩家都采取最优策略。

输入

每个测试包括多个测试用例。第一行包含一个整数 t (1≤t≤10^4) — 测试用例的数量。接下来是测试用例的描述。

每个测试用例的第一行包含三个整数 n, k, 和 x (1≤n≤2⋅10^5, 1≤x,k≤n) — 数组中的元素数量，爱丽丝可以移除的元素数量限制，以及鲍勃可以乘以 −1 的元素数量限制。

每个测试用例的第二行包含 n 个整数 a1,a2,…,an (1≤ai≤1000) — 数组的元素。

保证所有测试用例中 n 的总和不超过 2⋅10^5。

输出

对于每个测试用例，输出一个整数 — 假设两位玩家都采取最优策略后，游戏结束后数组元素的总和。

示例 1

Input	Output
8 1 1 1 1 4 1 1 3 1 2 4 6 6 3 1 4 3 2 5 6 6 6 1 3 7 3 3 32 15 8 5 3 5 5 3 3 3 2 9 9 10 6 4 1 8 2 9 3 3 4 5 3 200 2 2 1 4 3 2 1 2 1 3	0 2 0 3 -5 -9 0 -1

注意

在第一个测试用例中，爱丽丝最好移除数组中唯一的元素。然后，游戏结束后数组元素的总和为 0。

在第二个测试用例中，爱丽丝最好不移除任何元素。然后，鲍勃将把 4 乘以 −1。所以最终数组元素的总和为 3+1+2−4=2。

在第五个测试用例中，爱丽丝最好移除 9,9。然后，鲍勃将把 5,5,3 乘以 −1。所以最终数组元素的总和为 −5−5−3+3+3+2=−5。

 解题思路

首先我们知道鲍勃希望操作后的数组最小，所以说鲍勃肯定优先将最大的数操作变成相反数且鲍勃能操作几个数就全都操作，爱丽丝可以去除数组中的数，然而具体去除几个数不知道，但知道的是要想鲍勃操作后数组最大，去除的肯定优先去除最大的数，具体去除几个，直接暴力比较一下取最大值，这里可以前缀和一下，就是爱丽丝去除某个元素的所有和，方便计算。先排序

注意：爱丽丝操作的数量和鲍勃操作的数量加起来可能超过数组的大小，要优先爱丽丝的操作

手写快排过不了，可以用归并。

AC代码

#include<stdio.h>
long long a[200010], dp[200010], b[200010];
void nb(long long x, long long y)//归并排序，从小到大
{
    if (x >= y) return;
    long long mid = (x + y) / 2, i, j;
    nb(x, mid);
    nb(mid + 1, y);
    int cnt = 0;
    for (i = x, j = mid + 1; i <= mid && j <= y;)
    {
        if (a[i] <= a[j])
            b[++cnt] = a[i++];
        else
            b[++cnt] = a[j++];
    }
    while (i <= mid)
        b[++cnt] = a[i++];
    while (j <= y)
        b[++cnt] = a[j++];
    for (i = 1; i <= cnt; i++)
        a[x + i - 1] = b[i];
}
int main()
{
	int t;
	long long n, k, x, i, max, p, q;
	scanf("%d", &t);
	while (t--)//t个测试数据
	{
		max = -1e9;//每个测试数据清零
		scanf("%lld %lld %lld", &n, &k, &x);
		for (i = 1; i <= n; i++)
			scanf("%lld", &a[i]);
		nb(1, n);//升序
		for (i = 1; i <= n; i++)//前缀和一下
			dp[i] = dp[i - 1] + a[i];
		for (i = 0; i <= k; i++)
		{
			if (n < i + x)//优先爱丽丝的操作
				x = n - i;
			p = dp[n - i - x];
			q = dp[n - i] - p;
			if (max < p - q)//更新最大值
				max = p - q;
		}
		printf("%lld\n", max);//输出结果
	}
	return 0;
}

CF—1921D（1100）G

彼特亚有一个长度为ai的整数数组。他的哥哥瓦西亚嫉妒起来，决定自己也要创建一个长度为n的整数数组。

为此，他找到了m个整数bi（m≥n），现在他想从中选择一些整数，并以特定顺序排列它们，以得到一个长度为n的数组ci。

为了避免与他哥哥相似，瓦西亚希望使他的数组与彼特亚的数组尽可能不同。具体来说，他希望总差异D=∑ni=1|ai−ci|尽可能大。

帮助瓦西亚找到他可以获得的最大差异D。

输入

每个测试包含多个测试用例。第一行包含一个整数t（1≤t≤100）—测试用例的数量。接下来是测试用例的描述。

每个测试用例的第一行包含两个整数n和m（1≤n≤m≤2⋅10^5）。

每个测试用例的第二行包含n个整数ai（1≤ai≤10^9）。每个测试用例的第三行包含m个整数bi��（1≤bi≤10^9）。

保证在一个测试中，所有测试用例的m之和不超过2⋅10^5。

输出

对于每个测试用例，输出一个整数—可以获得的最大总差异D。

示例 1

Input	Output
9 4 6 6 1 2 4 3 5 1 7 2 3 3 4 1 1 1 1 1 1 1 5 5 1 2 3 4 5 1 2 3 4 5 2 6 5 8 8 7 5 8 2 10 2 2 4 1 9 6 4 6 8 10 6 4 3 10 6 1 8 9 3 5 6 5 2 1 7 9 7 2 5 5 9 10 6 3 7 5 9 2 3 9 1 6 3 2 7 10 1 1 5	16 0 12 11 10 23 15 25 7

注意

在第一个示例中，瓦西亚可以，例如，创建数组(1,5,7,2)。然后总差异将为D=|6−1|+|1−5|+|2−7|+|4−2|=5+4+5+2=16。

在第二个示例中，瓦西亚可以使用的所有整数都等于1，所以他只能创建数组(1,1,1)，差异为D=0。

在第三个示例中，瓦西亚可以，例如，创建数组(5,4,3,2,1)。然后总差异将为D=|1−5|+|2−4|+|3−3|+|4−2|+|5−1|=4+2+0+2+4=12。

解题思路

先对两个数组排序，4个指针分别指向两个数组的头尾，比较一下4种匹配情况谁的差值更大优先操作谁。

AC代码

#include<stdio.h>
#include<math.h>
long long  b[200010];
void nb(long long x, long long y,long long a[])//归并排序，参数分别为数组和数组左右区间
{
    if (x >= y) return;
    long long mid = (x + y) / 2, i, j;
    nb(x, mid,a);
    nb(mid + 1, y,a);
    int cnt = 0;
    for (i = x, j = mid + 1; i <= mid && j <= y;)
    {
        if (a[i] <= a[j])
            b[++cnt] = a[i++];
        else
            b[++cnt] = a[j++];
    }
    while (i <= mid)
        b[++cnt] = a[i++];
    while (j <= y)
        b[++cnt] = a[j++];
    for (i = 1; i <= cnt; i++)
        a[x + i - 1] = b[i];
}
long long n, m, a[200010], c[200010];
int main()
{
	int t;
	scanf("%d", &t);
	while (t--)//t组测试数据
	{
		long long sum = 0;
		scanf("%lld %lld", &n, &m);
		for (int i = 1; i <= n; i++)
			scanf("%lld", &a[i]);
		for (int i = 1; i <= m; i++)
			scanf("%lld", &c[i]);
		nb(1, m, c);//c数组升序
		nb(1, n, a);//a数组升序
		//4个指针
		int p = 1, q = m;
		int x = 1, y = n;
		while (x <= y)//匹配结束条件为c数组所有元素都匹配完
		{
			int mid = (c[p] + c[q]) / 2, i;
			if (abs(a[x] - mid) >= abs(a[y] - mid))//与中间的值进行比较，取差值大的
				i = x;
			else
				i = y;
			if (abs(a[i] - c[p]) > abs(a[i] - c[q]))
			{
				sum += abs(a[i] - c[p]);
				p++;
			}
			else
			{
				sum += abs(a[i] - c[q]);
				q--;
			}
			if (i == x)//操作完成指针移动
				x++;
			else
				y--;
		}
		printf("%lld\n", sum);
	}
	return 0;
}