【题解】Educational Codeforces Round 141（CF1783）

评价：educational

A.Make it Beautiful

题目描述：

如果一个数组中存在一个数恰好等于该数前面所有数之和，那么这个数组就是丑的。如果一个数组不是丑的，就是美的。

比如说：

• 数组 $[6, 3, 9, 6]$ 是丑的，因为 $9 = 6 + 3$ ；
• 数组 $[5, 5, 7]$ 是丑的，因为第二个 $5 = 5$ 。
• 数组 $[8, 4, 10, 14]$ 是美的，因为 $8 \ne 0$ , $4 \ne 8$ , $10 \ne 8 + 4$ , $14 \ne 8 + 4 + 10$ ，没有任何一个数等于它前面的数之和。

给定数组 $a$ 满足 $1 \le a_1 \le a_2 \le \dots \le a_n \le 100$ 。 你可以任意调整元素的顺序，也可以不调整，使它变成一个美的数组。

题目分析：

我们可以考虑从大到小排序，这样除了最大值可能出问题，其它的都没问题。
而最大值就可以只保留一个在序列开头，其余的放到结尾即可。

代码：

点击查看代码

#include<bits/stdc++.h>
using namespace std;
const int N = 100;
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]);
		vector<int> v;
		for(int i=n; i>=1; i--){
			if(a[i] == a[n] && i != n)	continue;
			v.push_back(a[i]);
		}
		for(int i=n; i>=1; i--){
			if(a[i] == a[n] && i != n)	v.push_back(a[i]);
		}
		bool flag = true;
		int sum = 0;
		for(int i=0; i<(int)v.size(); i++){
			if(v[i] == sum)	flag = false;
			sum += v[i];
		}
		if(flag){
			printf("YES\n");
			for(int i=0; i<(int)v.size(); i++)	printf("%d ",v[i]);
			printf("\n");
		}
		else	printf("NO\n");
	}
	return 0;
}

B.Matrix of Differences

题目描述：

对于一个 $n\times n$ 的矩阵，对于每一对相邻（有公共边）的值 $a,b$，写下 $|a-b|$（即 $a$ 与 $b$ 差的绝对值）。定义这个矩阵的美丽度为写下的不同的值的个数。以如下的矩阵为例：

$$\left(\begin{matrix}1&3\\4&2\end{matrix}\right)$$

则所有相邻值的绝对值分别是 $|1-3|=2,|1-4|=3,|3-2|=1,|4-2|=2$。共有 $1,2,3$ 三种不同的值，则这个矩阵的美丽度为 $3$。

给你 $t$ 次询问，每次询问给定一个正整数 $n$。输出任意一个 $n\times n$ 的矩阵，满足 $1\sim n^2$ 在矩阵中各出现一遍，并且该矩阵的美丽度最大。

$1\le t\le49,2\le n\le50$。

题目分析：

手摸了半天才搞出来的做法。
考虑 $n-1$ 会怎么得到，只有可能是 $1,n$，那 $n-2$ 呢？
可以是 $1,n-1$ 或者 $2,n$，为了构造的漂亮程度我们就不妨将 $n,n-1$ 放到 $1$ 的旁边，然后 $2$ 继续放到下面，也就是下面这种方式：

$$\begin{matrix} 1 &n-1 &4 &n-5 &\cdots\\ n &3 &n-4 &\cdots\\ 2 &n-3 &\cdots\\ n-2 &\cdots\\ \cdots \end{matrix}$$

然后就可以过了。

代码：

点击查看代码

#include<bits/stdc++.h>
using namespace std;
const int N = 100;
int a[N][N];
int main(){
//	freopen("in.txt","r",stdin);
//	freopen("out.txt","w",stdout);
	int T;scanf("%d",&T);
	while(T--){
		int n;scanf("%d",&n);
		int l = 1,r = n*n,tot = 0;
		for(int i=1; i<=n; i++){
			++tot;
			int nx = i,ny = 1;
			while(nx >= 1 && ny <= n){
				if(tot & 1)	a[nx][ny] = l,l++;
				else a[nx][ny] = r,--r;
				nx --,ny ++;
			}
		}
		for(int i=2; i<=n; i++){
			++tot;
			int nx = n,ny = i;
			while(nx >= 1 && ny <= n){
				if(tot & 1)	a[nx][ny] = l,l++;
				else a[nx][ny] = r,--r;
				nx --,ny ++;
			}
		}
		for(int i=1; i<=n; i++){
			for(int j=1; j<=n; j++){
				printf("%d ",a[i][j]);
			}
			printf("\n");
		}
	}
	return 0;
}

C.Yet Another Tournament

题目描述：

有 $n$ 个选手，编号为 $1$ 至 $n$ ，每两个选手对战时，编号大的将会胜利。

你可以准备 $m$ 单位时间，每准备 $a_i$ 时间就可以赢 $i$ 号选手。

按胜利的总次数排名，求你最高多少名。

题目分析：

一个想法就是我们直接将 $a$ 最小到大排序，这样就可以赢尽可能多的场，看上去就是很好的排名。
但是我们的排名还与我们赢了哪些人有关，所以就有点不可做的样子。
注意到，当我们赢了 $x$ 场就相当于要选择 $n-x$ 个人多赢一场，然后寻找赢场数大于 $x$ 的人的个数，而只有赢场数等于 $x$ 的人会受到我们选择加一的影响，所以其实此时只需要判断能不能通过调整使得我们可以赢过胜场为 $x$ 的人即可。

代码：

点击查看代码

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N = 5e5+5;
int a[N],b[N];
signed main(){
//	freopen("in.txt","r",stdin);
//	freopen("out.txt","w",stdout);
	int T;scanf("%lld",&T);
	while(T--){
		int n,m;scanf("%lld%lld",&n,&m);
		for(int i=1; i<=n; i++)	scanf("%lld",&a[i]),b[i] = a[i];
		sort(b+1,b+n+1);
		int pos = 0;
		for(int i=1; i<=n; i++){
			if(m - b[i] >= 0){
				pos = i;
				m -= b[i];
			}
		}
		if(!pos){
			printf("%lld\n",n+1);
			continue;
		}
		if(pos != n && a[pos+1] <= m + b[pos])	++pos;
		printf("%lld\n",n-pos + 1);
	}
	return 0;
}

D.Different Arrays

题目描述：

给你一个有 $n$ 个元素的序列，你需要进行 $n-2$ 次操作。

对于第 $i$ 次操作，你可以选择让 $a_i-a_{i+1}$ 且 $a_{i+2}+a_{i+1}$ 或者可以选择让 $a_i+a_{i+1}$ 且 $a_{i+2}-a_{i+1}$

问最后能产生多少个不同的序列。

题目分析：

一个想法就是判断什么样的序列是能被表示的，但是想了一会发现根本没有任何头绪，所以考虑换个想法，也就是直接使用 $dp$ 去决策每一次的操作。
为了方便理解，我们将第 $i$ 次操作，成为操作第 $i+1$ 个数。
但是这样看上去有很多重复的情况就很难办，注意一点就是要使得产生相同的序列则必然满足存在 $a_i = 0$ 的情况，然后操作 $a_i$，否则一定不会产生相同的情况，所以我们完全不用考虑什么去重之类的问题，只需要判断 $a_i = 0$ 即可。
所以可以考虑设 $dp_{i,j}$ 表示操作完了前 $i$ 个数，$a_{i+1} = j$ 的方案数，记第二维的原因是我们此时需要决策第 $i+1$ 次操作就必须知道对应的 $a$ 是什么。
转移就是显然的，也就是直接枚举 $a_{i+1}$ 是怎么操作的，以及特判 $a_{i+1} = 0$。
注意到第二维可以为负，所以加一个偏移量。

代码：

点击查看代码

#include<bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const int MAX = 90000;
int dp[305][90005 * 2];
int a[305];
void add(int &a,int b){
	a = (a + b)%MOD;
}
int main(){
	int n;scanf("%d",&n);
	for(int i=1; i<=n; i++)	scanf("%d",&a[i]);
	dp[1][MAX+a[2]] = 1;
	for(int i=1; i<n; i++){
		for(int k=-MAX; k<=MAX; k++){
			if(!dp[i][k+MAX])	continue;
			if(k == 0){
				dp[i+1][a[i+2]+MAX] = (dp[i+1][a[i+2]+MAX] + dp[i][k+MAX])%MOD;
			}
			else{
				dp[i+1][a[i+2]+k+MAX] = (dp[i+1][a[i+2]+k+MAX] + dp[i][k+MAX])%MOD;
				dp[i+1][a[i+2]-k+MAX] = (dp[i+1][a[i+2]-k+MAX] + dp[i][k+MAX])%MOD;
			}
		}
	}
	int ans = 0;
	for(int j=-MAX; j<=MAX; j++)	add(ans,dp[n-1][j+MAX]);
	printf("%d\n",ans);
	return 0;
}

E.Game of the Year

题目描述：

Monocarp 和 Polycarp 正在玩电脑游戏。游戏特点：$n$ 个编号从 $1$ 到 $n$ 的BOSS。

他俩将用以下方式与BOSS战斗

• Monocarp 进行 $k$ 次尝试撒掉boss;
• Polycarp 进行 $k$ 次尝试撒掉boss;
• Monocarp 进行 $k$ 次尝试撒掉boss;
• Polycarp 进行 $k$ 次尝试撒掉boss;
• ...

Monocarp 在第 $a_i$ 次尝试中撒掉了第 $i$ 只BOSS。Polycarp 在第 $b_i$ 次尝试中撒掉了第 $i$ 只BOSS。其中一个人撒掉第 $i$ 只BOSS后，他们就会尝试撒第 $(i+1)$ 只BOSS。并且他们的尝试计数器都会清空。撒掉第 $n$ 只BOSS后，游戏结束。

找到从$1$ 到 $n$所有的 $k$ 值， 使得 Monocarp 可以杀死所有的BOSS。

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

题目分析：

题目说的实在是太抽象了，转化一下题意就是要找到满足以下条件的 $k$：

$$\begin{aligned} &\forall i\in[1,n] & \lceil \frac{a_i}{k} \rceil \le \lceil \frac{b_i}{k} \rceil \end{aligned}$$

首先就是可以直接整除分块就能找到所有满足条件的 $k$，复杂度 $O(n\sqrt{n})$ 但是常数有点逆天据说不能过，考虑优化。
一个经典的想法就是既然不能枚举约数，那么我们就枚举倍数，即枚举 $k$ 然后枚举 $k$ 的倍数。
可以发现 $k$ 的倍数将序列分成了 $O(\frac{n}{k})$ 段，而要使得上述条件满足就是 $a_i$ 所在的块不在 $b_i$ 所在的块后面。
如果原来就满足 $a_i \le b_i$ 则无论如何都满足条件，就不管了。
如果 $a_i > b_i$ 条件其实就是 $a_i$ 所在的块与 $b_i$ 所在的块相同，这个不是很好判，那么什么时候是不在一块呢？
既然不在一块也就是说 $[b_i,a_i]$ 跨过了一个分界点，如果我们以 $k$ 的倍数作为每一段的右端点，也就是 $[b_i,a_i)$ 包含 $k$ 的倍数。
可以直接预处理出每一个位置是否可以作为右端点，然后对于每一个 $k$ 的倍数判断一下即可。
复杂度 $O(n \log n)$

代码：

点击查看代码

#include<bits/stdc++.h>
using namespace std;
const int N = 5e5+5;
int a[N],b[N],sum[N];
vector<int> v;
int main(){
//	freopen("in.txt","r",stdin);
//	freopen("out.txt","w",stdout);
	int T;scanf("%d",&T);
	while(T--){
		int n;scanf("%d",&n);
		for(int i=1; i<=n; i++)	scanf("%d",&a[i]);
		for(int i=1; i<=n; i++)	scanf("%d",&b[i]);
		for(int i=1; i<=n; i++){
			if(a[i] > b[i])	sum[b[i]]++,sum[a[i]]--;
		}
		for(int i=1; i<=n; i++)	sum[i] += sum[i-1];
		for(int i=1; i<=n; i++){
			bool flag = true;
			for(int j=i; j<=n; j+=i){
				if(sum[j])	flag = false;
			}
			if(flag)	v.push_back(i);
		}
		printf("%d\n",v.size());
		for(int i=0; i<v.size(); i++)	printf("%d ",v[i]);
		printf("\n");
		for(int i=0; i<=n; i++)	sum[i] = 0;
		v.clear();
	}
	return 0;
}

F.Double Sort II

题目描述：

有两个 $1..n$ 的排列 $a,b$。

你可以进行若干次操作，每次操作流程如下：

• 选择一个整数 $i \in [1,n]$。

• 找出两个整数 $x,y$，使得 $a_x=b_y=i$。

• 交换 $a_x$ 和 $a_i$，以及 $b_y$ 和 $b_i$。

问把 $a$ 和 $b$ 从小到大排序的最小操作次数

题目分析：

考虑将排列看作一个置换，然后建图，也就是连边 $i \to a_i$ 与 $i \to b_i$，注意这是两张图。
我们的一次操作相当于将某个点缩成一个自环，其他点不受影响，所以对于每一个置换环设其长度为 $len$ 只需要操作 $len-1$ 次就可以将所有点缩成自环，即我们可以对于每一个环钦定一个点使得这个点不被操作，要最大化钦定点的数量。
而两张图其实也是差不多的，如果钦定 $i$ 不被操作，也就是说 $i$ 在 $a,b$ 中的环上均只能选择 $i$ 这一个点不被操作，这个其实就是一个匹配的感觉。
所以可以对于每一个点 $i$，找到其在 $a,b$ 上的环，将这两个环连边，最后跑一个最大匹配就是最多的不用被操作的点数。

代码：

点击查看代码

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5+5;
struct edge{
	int nxt,to,id;
	edge(){}
	edge(int _nxt,int _to,int _id){
		nxt = _nxt,to = _to,id = _id;
	}
}e[2 * N];
int cnt,col1[N],col2[N],head[N],flag[N],match[N],a[N],b[N];
bool vis[N],tag[N];
void add_edge(int from,int to,int id){
	e[++cnt] = edge(head[from],to,id);
	head[from] = cnt;
}
bool dfs(int now){
	if(vis[now])	return false;
	vis[now] = true;
	for(int i=head[now] ;i ; i=e[i].nxt){
		int to = e[i].to;
		if(!match[to] || dfs(match[to])){
			match[now] = to,match[to] = now;
			flag[now] = flag[to] = e[i].id;
			return true;
		}
	}
	return false;
}
void dfs1(int now,int col){
	if(col1[now])	return;
	col1[now] = col;
	if(!col1[a[now]])	dfs1(a[now],col);
}
void dfs2(int now,int col){
	if(col2[now])	return;
	col2[now] = col;
	if(!col2[b[now]])	dfs2(b[now],col);
}
int main(){
//	freopen("in.txt","r",stdin);
//	freopen("out.txt","w",stdout);
	int n;scanf("%d",&n);
	for(int i=1; i<=n; i++)	scanf("%d",&a[i]);
	for(int i=1; i<=n; i++)	scanf("%d",&b[i]);
	int tot = 0;
	for(int i=1; i<=n; i++){
		if(col1[i])	continue;
		++tot;dfs1(i,tot);
	}
	int tmp = tot;
	memset(vis,false,sizeof(vis));
	for(int i=1; i<=n; i++){
		if(col2[i])	continue;
		++tot;dfs2(i,tot);
	}
	for(int i=1; i<=n; i++){
		add_edge(col1[i],col2[i],i);
		add_edge(col2[i],col1[i],i);
//		printf("%d %d\n",col1[i],col2[i]);
	}
	int ans = 0;
	for(int i=1; i<=tmp; i++){
		memset(vis,false,sizeof(vis));
		ans += dfs(i);
	}
	printf("%d\n",n - ans);
	for(int i=1; i<=tmp; i++){
		tag[flag[i]] = true;
	}
	for(int i=1; i<=n; i++){
		if(!tag[i])	printf("%d ",i);
	}
	return 0;
}

G.Weighed Tree Radius

题目描述：

给你一个$n$个点的树和$n-1$条边。第$i$个点的初始权值为$a_i$。

定义结点$v$到结点$u$的距离$d_v(u)$等于$v$和$u$之间的边的数量。注意:$d_v(u)=d_u(v),d_v(v)=0$

定义结点$v$到结点$u$的权值距离$w_v(u)=d_v(u)+a_u$。注意：$w_v(v)=a_v,w_v(u) \neq w_u(v)$如果$a_u \neq a_v$

与通常的距离类似，让我们定义结点$v$的偏心距$e(v)$是从$v$到其他结点的最大权值距离（包括$v$本身），即$e(v)=\max\limits_{1\leq u \leq n} w_v(u)$。

最后，我们定义树的半径$r$是所有偏心距的最小值，即$r=\min\limits_{1\leq v\leq n} e(v)$

你需要对$m$次询问进行回答，对于第$j$次询问，给出两个数$v_j$和$x_j$，表示将$a_{v_j}$的值修改为$x_j$。

在每次询问后，输出当前该树的半径$r$。

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

题目分析：

题目已经提示了这东西叫做半径，那么是不是直接求直径然后除以 $2$ 就可以呢？
我们定义 $w'(u,v) = a_u + a_v + dis(u,v)$，那么满足 $w'(u,v)$ 最大的两个点 $u,v$ 之间的路径的长度我们称为直径。
这里我们将 $a_u$ 理解为挂在 $u$ 上长度为 $a_u$ 的链，$a_v$ 理解为挂在 $v$ 上长度为 $a_v$ 的链。
设直径的中点为 $mid$，若 $mid$ 在直径的某一个节点上，则显然 $r = \lceil \frac{w'(u,v)}{2} \rceil$，可是如果 $mid$ 不在直径的某一个节点上呢。
若 $mid$ 在 $a_u$ 对应的链上，则必然满足 $e_u = a_u$，则对于其它的任意一个点 $x$ 都必然满足 $e_x \ge dis(u,x) + a_u > a_u = e_u$，即 $r = a_u$，但是这样的话就必然满足直径为 $w'(u,u)$ 就不可能不存在了。

下面我们的问题就转化为了维护直径。
考虑假设我们原来的直径为 $(u,v)$ 现在将 $a_x$ 增大了一些，那么我们新直径的端点必然是 $u,v,x$ 其中的两个，可以直接分类讨论得到答案。
而如果我们将 $a_x$ 减小了一些，我们就无法判断直径端点的变化，所以可以考虑使用线段树分治维护修改，这样每次将值从 $0$ 开始变化，这样每次都是加的操作了。