评价：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\) 开始变化，这样每次都是加的操作了。