【题解】Educational Codeforces Round 142（CF1792）

没有手速，再加上被 E 卡了，废掉了。

A.GamingForces

题目描述：

Monocarp 正在玩电脑游戏。他打算杀死 $n$ 个怪兽，第 $i$ 个的血量为 $h_i$。

Monocarp 的角色有两个魔法咒语如下，都可以以任意顺序用任意次（可以不用），每次使用相当于一次操作。

选择两个怪兽并各扣一滴血。
选择一个怪兽并且直接杀死。

当一个怪兽血量为 $0$ 时，他死了。

求杀死所有怪兽的最少操作次数。

题目分析：

只有两个怪兽同为 $1$ 点血，这个时候我们通过 $1$ 操作直接把它们弄死才会比直接通过操作 $2$ 直接弄死更优。

所以判一下这个就好了。

代码：

点击查看代码

#include<bits/stdc++.h>

using namespace std;

const int N = 10005;

int a[N];

int main(){

	int T;scanf("%d",&T);

	while(T--){

		int n;scanf("%d",&n);

		for(int i=1; i<=n; i++)	scanf("%d",&a[i]);

		int cnt = 0;

		for(int i=1; i<=n; i++){

			if(a[i] == 1)	++cnt;

		}

		printf("%d\n",n - cnt / 2);

	}

	return 0;

}

B.Stand-up Comedian

题目描述：

Eve 是个单口相声新手。她的第一场表演聚集了总计 $2$ 个观众：Alice 和 Bob。

Eve 准备了 $a_1+a_2+a_3+a_4$ 个相声表演节目。$a_i$ 表示第 $i$ 类相声的数目，每类的的特征如下：

Alice 和 Bob 都喜欢这类相声。
Alice 喜欢，Bob 不喜欢。
Bob 喜欢，Alice 不喜欢。
Alice 和 Bob 都不喜欢这类相声。

一开始，两位观众的心情都为 $0$。

当一位观众听到他喜欢的相声表演时心情会加 $1$，当听到的是自己不喜欢的相声时，心情减 1。

当某位观众心情严格小于 $0$ 时，这位观众会离场。只要有一位这样的观众离场，Eve 会特别伤心并且结束整个表演。若演完了所有节目，也会结束表演。

求某种安排表演顺序的方式，使得 Eve 在结束表演前能表演的节目最多。输出最多能表演的节目数。

译者注：若演完某个节目有观众退场，这个节目也算在总数之中。

$0 \le a_1,a_2,a_3,a_4 \le 10^8$。

题目分析：

好像是个大细节题，但是我一遍过就很爽[狂笑]

考虑最优的一个操作顺序肯定是：$1 \to 2,3 \to 4$。

关键是中间 $2,3$ 造成的贡献比较难算，可以显然发现我们先操作一次 $2$ 后操作一次 $3$ 它们的代价就抵消了，而且会多出两次节目，但是要注意如果 $1$ 操作数量为 $0$ 就不能相互抵消了。

所以就按照：操作 $1$、$2,3$ 抵消、操作 $2,3$、操作 $4$，这样的顺序模拟一下即可。

代码：

点击查看代码

#include<bits/stdc++.h>

#define int long long

using namespace std;

int cnt[10];

signed main(){

//	freopen("in.txt","r",stdin);

//	freopen("out.txt","w",stdout);

	int T;scanf("%lld",&T);

	while(T--){

		for(int i=1; i<=4; i++)	scanf("%lld",&cnt[i]);

		int ans = 0;

		int a = cnt[1],b = cnt[1];ans += cnt[1];

		if(a == 0){

			if(cnt[2] + cnt[3] + cnt[4] > 0)	printf("1\n");

			else	printf("0\n");

			continue;

		}

		int tmp = min(cnt[2],cnt[3]);ans += 2 * tmp;

		cnt[2] -= tmp,cnt[3] -= tmp;

		if(cnt[2] > 0){

			tmp = min(cnt[2],b+1);ans += tmp;

			a += tmp,b -= tmp;

		}

		if(cnt[3] > 0){

			tmp = min(cnt[3],a+1);ans += tmp;

			a -= tmp,b += tmp;

		}

		if(a >= 0 && b >= 0){

			ans += min(min(a+1,b+1),cnt[4]);

		}

		printf("%lld\n",ans);

	}

	return 0;

}

C.Min Max Sort

题目描述：

对于一个排列，定义一次操作为：在排列中任选两个数字，将它们中的最大值插入至队尾，最小值插入至队首。

现在给定多个排列，问每个排列最少各需多少次操作才能变得严格递增。

$1 \le n\le 2\times 10^5$

题目分析：

如果我们要进行操作，那么最后 $1$ 操作必然是 $1,n$，然后倒推一下就会发现倒数第 $2$ 次操作必然是 $2,n-1$，然后就可以发现倒数第 $i$ 次操作必然是 $i,n-i+1$。

所以假设我们通过 $k$ 次操作可以使排列严格递增，也就是说值在 $[k+1,n-k]$ 是不用我们管的了，已经符合条件了，将两头的 $k$ 个进行排完序就结束了。

这个“不用管”用形式化的语言说其实就是，设 $pos_i$ 表示数 $i$ 出现的位置，则 $pos_{k+1} < pos_{k+2} < \cdots < pos_{n-k}$。

所以可以直接一个个枚举 $k$ 判断是否合法即可，也就是将 $k$ 从 $\lfloor \frac{n}{2} \rfloor$ 开始依次减 $1$，然后判断条件是否满足。

代码：

点击查看代码

#include<bits/stdc++.h>

using namespace std;

const int N = 2e5+5;

int a[N],p[N];

int main(){

	int T;scanf("%d",&T);

	while(T--){

		int n;scanf("%d",&n);

		for(int i=1; i<=n; i++)	scanf("%d",&a[i]),p[a[i]] = i;

		int k = n / 2;

		while(k && p[k] < p[k+1] && p[n-k] < p[n-k+1])	--k;

		printf("%d\n",k);

	}

	return 0;

}

D.Fixed Prefix Permutations

题目描述：

对于一个排列 $p$，定义其美丽度 $k$ 为

$p_1=1,p_2=2,\cdots,p_k=k,p_{k+1} \neq k+1$

若 $p,q$ 均为长度为 $n$ 的排列，定义排列的运算 $p \cdot q$ 为：

$p \cdot q = r$，$p,q,r$ 均为长度为 $n$ 的排列
$r_j = q_{p_j}$

现在给出 $n$ 个长度为 $m$ 的排列，对于每一个 $a_i$，求 $a_i \cdot a_j(1 \le j \le n)$ 美丽值最大为多少，允许有 $i=j$。

多测，$T \le 10^4$，$\sum n \le 5 \times 10^4$，$m \le 10$

题目分析：

考虑如果就是给定了两个排列 $p,q$ 怎么算它的美丽值。

要让 $i$ 经过两个排列的置换后依旧是在 $i$ 的位置，其实就是说设 $pos_i$ 表示 $i$ 在 $q$ 中的位置，则 $p_i = pos_i$，可以将置换理解为走路这种东西然后就很好理解了。

所以其实就是求出 $pos$ 之后两者的 $lcp$。

那么这个题就很好解决了，可以直接对于每一个排列都求出 $pos$，然后插入到 trie 树里，计算答案就是枚举每一个排列然后让它在字典树上走即可。

（我竟然一开始用了 bitset 维护这个过程，差点就过了）

代码：

点击查看代码

#include<bits/stdc++.h>

using namespace std;

const int N = 5e4+5;

int n,m,a[N][11],tot = 1,pos[N][11],ch[100 * N][11];

void insert(int x){

	int now = 1;

	for(int i=1; i<=m; i++){

		int to = pos[x][i];

		if(!ch[now][to])	ch[now][to] = ++tot;

		now = ch[now][to];

	}

}

int find(int x){

	int now = 1;

	int ans = 0;

	for(int i=1; i<=m; i++){

		if(ch[now][a[x][i]]){

			++ans,now = ch[now][a[x][i]];

		}

		else	break;

	}

	return ans;

}

int main(){

//	freopen("in.txt","r",stdin);

//	freopen("out.txt","w",stdout);

	int T;scanf("%d",&T);

	while(T--){

		scanf("%d%d",&n,&m);

		for(int i=1; i<=n; i++){

			for(int j=1; j<=m; j++){

				scanf("%d",&a[i][j]);

				pos[i][a[i][j]] = j;

			}

			insert(i);

		}

		for(int i=1; i<=n; i++)	printf("%d ",find(i));

		printf("\n");

		for(int i=1; i<=tot; i++){

			for(int j=1; j<=10; j++){

				ch[i][j] = 0;

			}

		}

		tot = 1;

	}

	return 0;

}

E.Divisors and Table

题目描述：

给定一张 $n \times n$ 的表格和一个正整数 $m = m_1 \times m_2$，表格第 $i$ 行第 $j$ 列的数 $a_{i, j} = i \times j$。

现在需要你求出 $m$ 的每个因子 $d$ 是否在表格中出现，若出现，则求出其出现在表格中的最小行号。

$1 \le n, m_1, m_2 \le 10^9$

题目分析：

（一种乱搞做法）

$10^{18}$ 以内的数，因子个数最多有大约 $10^5$ 个，所以显然可以将 $m$ 的的所有因子都拿出来然后挨个判断。

要求所有的因子其实就是要对 $m$ 质因数分解，可以直接用科技对 $m$ 分解，也可以分别为 $m_1,m_2$ 分解后合起来，这样我们就得到了 $m$ 的所有因子。

我们要做的其实就是分解 $d = a \times b$，且 $a,b \le n$，要求 $a$ 尽可能小。

因为 $d$ 为 $m$ 的因子，所以 $a,b$ 也必然是 $m$ 的因子，所以可以将因子排序之后二分。

具体来说就是二分最小的 $a$ 使得 $\lceil \frac{d}{a} \rceil \le n$，这样只需要向后枚举一些 $a$ 使得 $a \mid d$ 此时 $a$ 就是最优的 $a$ 了。

代码：

点击查看代码

#include <iostream>

#include <cstdio>

#include <algorithm>

#include <vector>

using namespace std;

#define int long long

int t, n, m1, m2;

vector<int> a, b, c;

signed main()

{

	scanf("%lld", &t);

	while (t -- )

	{

		int cnt = 0, ans = 0;

		a.clear();

		b.clear();

		c.clear();

		scanf("%lld%lld%lld", &n, &m1, &m2);

		for (int i = 1; i <= m1 / i; i ++ )

		{

			if(m1 % i == 0)

			{

				a.push_back(i);

				if(m1 / i != i) a.push_back(m1 / i);

			}

		}

		for (int i = 1; i <= m2 / i; i ++ )

		{

			if(m2 % i == 0)

			{

				b.push_back(i);

				if(m2 / i != i) b.push_back(m2 / i);

			}

		}

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

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

		for (int i = 0; i < a.size(); i ++ )

			for (int j = 0; j < b.size(); j ++ )

				c.push_back(a[i] * b[j]);

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

		c.erase(unique(c.begin(), c.end()), c.end());

		for (int i = 0; i < c.size(); i ++ )

		{

			int l = 0, r = i;

			while (l <= r)

			{

				int mid = l + r >> 1;

				if ((c[i] + c[mid] - 1) / c[mid] <= n) r = mid - 1;

				else l = mid + 1;

			}

			for (int j = l; j < c.size(); j ++ )

			{

				if(c[j] > n) break;

				if(c[i] % c[j] == 0)

				{

					ans ^= c[j];

					cnt ++;

					break;

				}

			}

		}

		printf("%lld %lld\n", cnt, ans);

	}

}

F1.Graph Coloring

题目描述：

简单版和困难版之间的唯一区别是 $n$ 的数据范围不同。

给出一个 $n$ 个顶点的无向完全图。完全图是指图上任意两个顶点皆有一条边相连。你需要给图上的每条边染上红色或蓝色。

一个顶点的集合 $S$ 被称作是红色连接的，如果对于 $S$ 中每对顶点 $(v_1,v_2)$，都存在只通过红边和 $S$ 中顶点的路径。相仿地，一个顶点的集合 $S$ 被称作是蓝色连接的，如果对于 $S$ 中每对顶点 $(v_1,v_2)$，都存在只通过蓝边和 $S$ 中顶点的路径。

你需要以如下方式对图进行染色：

至少有一条红边。
至少有一条蓝边。
对于每个大小不小于 $2$ 的顶点集 $S$（也即 $|S|\geqslant 2$），$S$ 或者是红色连接的，或者是蓝色连接的，但不能同时是红色和蓝色连接的。

计算染色方法数对 $998244353$ 取模后的结果。

$1\le n \le 5\times 10^3$

题目分析：

（不写 F2 了，是一个多项式科技）

题目条件就是要求对于任意一个导出子图，要么通过红色边可以联通，要么通过蓝色边可以联通，但是不能通过两种边都可以联通。

注意到一点就是：这是一个完全图，所以蓝色边和红色边互为补图，也就是如果蓝色边不连通则红色边必然联通，反之亦然。

所以我们可以直接 $dp_n$ 表示节点个数为 $n$ 的图，不能通过蓝色边联通的合法的方案数。

转移就是考虑枚举点 $n$ 所在的蓝色连通块大小 $x$：

\[dp_n = \sum_{x=1}^{n-1} \binom{n-1}{x-1} dp_x \times (2 - [x = n-1])dp_{n-x}
\]

对于 $n$ 所在的连通块这 $x$ 个点必然满足蓝色联通也就是红色不连通，方案数等同于 $dp_x$。

对于其余的 $n-x$ 个点，它们之间蓝色联通或者红色联通都可以，所以就是系数有 $2$ 的贡献，但当 $n-x = 1$ 时，显然只有一种方案。

因为题目要求必须同时出现红边和蓝边，所以将答案减 $2$ 即可。

代码：

点击查看代码

#include<bits/stdc++.h>

#define int long long

using namespace std;

const int N = 5e3+5;

const int MOD = 998244353;

int fac[N],inv[N],f[N];

int binom(int n,int m){

	if(n < m || n < 0 || m < 0)	return 0;

	return fac[n] * inv[m] % MOD * inv[n-m] % MOD;

}

int power(int a,int b){

	int res = 1;

	while(b){

		if(b & 1)	res = res * a % MOD;

		a = a * a % MOD;

		b >>= 1;

	}

	return res;

}

signed main(){

	int n;scanf("%lld",&n);

	fac[0] = 1;

	for(int i=1; i<=n; i++)	fac[i] = fac[i-1] * i % MOD;

	inv[n] = power(fac[n],MOD-2);

	for(int i=n-1; i>=0; i--)	inv[i] = inv[i+1] * (i+1) % MOD;

	f[1] = 1;

	for(int i=2; i<=n; i++){

		for(int j=1; j<=i-1; j++){

			f[i] = (f[i] + f[j] * f[i-j] %MOD* binom(i-1,j-1) * (2 - (j == i-1))%MOD)%MOD;

		}

	}

	printf("%lld\n",(2 * f[n] %MOD - 2 + MOD)%MOD);

	return 0;

}