Atcoder AGC010 题解

最新推荐文章于 2020-04-06 23:31:28 发布
最新推荐文章于 2020-04-06 23:31:28 发布
阅读量427 收藏
点赞数 2
分类专栏： 杂项 Atcoder AGC题解 文章标签： atcoder
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/litble/article/details/83183748
版权

A - Addition

要么擦两个奇数，加一个偶数，要么擦两个偶数，加一个偶数。所以如果奇数的个数是奇数个，最后会剩一奇一偶，否则剩下一个偶数。

#include<bits/stdc++.h>
using namespace std;
#define RI register int
int read() {
	int q=0;char ch=' ';
	while(ch<'0'||ch>'9') ch=getchar();
	while(ch>='0'&&ch<='9') q=q*10+ch-'0',ch=getchar();
	return q;
}
int n,js;
int main()
{
	n=read();
	for(RI i=1;i<=n;++i) js+=read()&1;
	if(js&1) puts("NO");
	else puts("YES");
	return 0;
}

B - Boxes

首先我们可以知道要做 m = ∑ a n ( n + 1 ) 2 m=\frac{\sum a}{\frac{n(n+1)}{2}} m=2n(n+1)​∑a​次这样的操作才可能把石子取完（当然 m m m如果不是非负整数就肯定输出NO）。

然后对于一个盒子 i i i和它前面的盒子 i − 1 i-1 i−1，它们可能会被做两种类型的操作，一种叫做 i i i取1个 i − 1 i-1 i−1取 n n n个，一种叫做 i i i取 x + 1 x+1 x+1个 i − 1 i-1 i−1取 x x x个，则第一种操作会使 d i = a i − a i − 1 d_i=a_i-a_{i-1} di​=ai​−ai−1​的值增加 n − 1 n-1 n−1，第二种会使 d i d_i di​减少 1 1 1。

如果最后都取完，则 d i d_i di​显然一样了，所以设第一种操作做了 x x x次，则第二种做了 m − x m-x m−x次， ( n − 1 ) x − ( m − x ) + d i = 0 (n-1)x-(m-x)+d_i=0 (n−1)x−(m−x)+di​=0，解得 x = m − d i n x=\frac{m-d_i}{n} x=nm−di​​，如果解出来不是非负整数肯定输出NO。

于是我们知道了这 m m m次操作是从哪个盒子开始取第一个石子，也就知道了每个盒子里应该有多少石子，检验一遍即可（这个扫两遍就可以求了，具体可以看代码）。

#include<bits/stdc++.h>
using namespace std;
#define RI register int
int read() {
	int q=0;char ch=' ';
	while(ch<'0'||ch>'9') ch=getchar();
	while(ch>='0'&&ch<='9') q=q*10+ch-'0',ch=getchar();
	return q;
}
typedef long long LL;
const int N=100005;
LL sum,nowadd,nows,a[N],orz[N],m;int n;
int work() {
	int js=0;
	for(RI i=0;i<n;++i) {
		int b=a[i]-a[(i-1+n)%n];
		if((m-b)%n||m-b<0) return 0;
		orz[i]=(m-b)/n,js+=orz[i];
	}
	if(js!=m) return 0;
	for(RI i=0;i<n;++i) {
		nows+=orz[i],nowadd+=nows;
		if(a[i]<nowadd) return 0;
		a[i]-=nowadd;
	}
	for(RI i=0;i<n;++i) {
		nows-=orz[i],nowadd-=1LL*n*orz[i],nowadd+=nows;
		if(a[i]!=nowadd) return 0;
	}
	return 1;
}
int main()
{
	n=read();
	for(RI i=0;i<n;++i) a[i]=read(),sum+=a[i];
	if(sum%(1LL*(n+1)*n/2)) {puts("NO");return 0;}
	m=sum/(1LL*(n+1)*n/2);
	if(work()) puts("YES");
	else puts("NO");
	return 0;
}

C - Cleaning

出题人你和石子有什么仇什么怨…

这个里面的花，我们在所有的叶子节点 i i i中放 a i a_i ai​个小精灵。每一次所有小精灵都会往父亲飞，当一群小精灵聚集在 x x x这个节点时，从不同儿子节点飞上来的小精灵可以选择组成一对“好朋友”，并且以后不再往父亲走。接着小精灵们会开始捡石头，一对“好朋友”只会捡走一个石头，单身的小精灵每人捡走一个石头，石头必须被捡完，所以组成多少对朋友就是固定的。然后没有找到朋友的小精灵会继续往父亲节点飞。问是否所有小精灵都能找到朋友并且所有石头都要被捡完。

那么会前文已说，从每个节点继续往上飞的小精灵数是固定的，所以每个节点处组成朋友的小精灵对数也是固定的，重点在求出最多可以组成多少对朋友，判断能不能达成石头恰好被捡完这个目标。

那么这个找朋友的过程怎么进行呢？我们让从同一个儿子节点飞上来的小精灵暂时站在一艘船上，由于只有不同船上的小精灵可以组队，所以有精灵的船越多越有利。所以我们每次选择两艘小精灵数最多的船，让它们上面各一个小精灵组成一对，然后她们两个下船，以此类推。

于是我们发现最多能组的队数只有两种情况，一种是有一艘船上的小精灵特别多，多到别的船都空了这艘船上还有很多小精灵单身。一种是我们这么操作着操作着所有船上的小精灵数越来越多接近，最后几乎所有的小精灵都有了朋友，但是如果总精灵数是奇数，那必然有一个小精灵找不到朋友。

最多组的队数与想要石头恰好被捡完应该组的队数比较即可判断。

#include<bits/stdc++.h>
using namespace std;
#define RI register int
int read() {
	int q=0;char ch=' ';
	while(ch<'0'||ch>'9') ch=getchar();
	while(ch>='0'&&ch<='9') q=q*10+ch-'0',ch=getchar();
	return q;
}
typedef long long LL;
const int N=100005;
int n,tot,h[N],ne[N<<1],to[N<<1],du[N];
LL a[N],f[N];
void add(int x,int y) {to[++tot]=y,ne[tot]=h[x],h[x]=tot;}
void dfs(int x,int las) {
	if(du[x]==1) {f[x]=a[x];return;}
	LL orzabs=0,p,mx=0;
	for(RI i=h[x];i;i=ne[i]) {
		if(to[i]==las) continue;
		dfs(to[i],x),f[x]+=f[to[i]],mx=max(mx,f[to[i]]);
	}
	if(mx>f[x]-mx) p=f[x]-mx;
	else p=f[x]/2;
	if(f[x]<a[x]) {puts("NO");exit(0);}
	if(f[x]-a[x]>p) {puts("NO");exit(0);}
	f[x]-=(f[x]-a[x])*2LL;
}
int main()
{
	int x,y;
	n=read();
	for(RI i=1;i<=n;++i) a[i]=read();
	if(n==2) {
		if(a[1]==a[2]) puts("YES");
		else puts("NO");
		return 0;
	}
	for(RI i=1;i<n;++i)
		x=read(),y=read(),add(x,y),add(y,x),++du[x],++du[y];
	for(RI i=1;i<=n;++i) if(du[i]>1) {
		dfs(i,0);
		if(f[i]) puts("NO");
		else puts("YES");
		return 0;
	}
	return 0;
}

D - Decrementing

出题人你和黑板有什么仇什么怨…

假如没有所有数除以gcd这个操作（我们称为“简化版游戏”），谁输谁赢显然只与所有数取到1要走的步数的奇偶性有关。而发现只有你取完这个1之后，所有数都变成了偶数，才有可能奇偶性情况与简化版游戏取完后不同。

假如当前局面在简化版游戏下为必胜局，因为所有数肯定互质，所以至少有一个奇数。你取一个偶数，它就变成了奇数，后手无论如何都无法将所有奇数取完扭转乾坤，所以你还是必胜。

假如当前局面在简化版下为必败局，如果大于1的奇数数量不是1个，你也没法扭转乾坤，还是必败。否则你肯定去掉那个奇数，所有数除以gcd，这样来回操作最多 log ⁡ \log log次，所以递归即可。

#include<bits/stdc++.h>
using namespace std;
#define RI register int
int read() {
	int q=0;char ch=' ';
	while(ch<'0'||ch>'9') ch=getchar();
	while(ch>='0'&&ch<='9') q=q*10+ch-'0',ch=getchar();
	return q;
}
typedef long long LL;
const int N=100005;
int n,a[N];
int GCD(int x,int y) {return y?GCD(y,x%y):x;}
int work() {
	LL sum=0;int js=0,x,gcd;
	for(RI i=1;i<=n;++i) {
		sum+=a[i]-1;
		if((a[i]&1)&&a[i]!=1) ++js,x=i;
	}
	if(sum&1) return 1;
	if(js!=1) return 0;
	--a[x],gcd=a[1];
	for(RI i=2;i<=n;++i) gcd=GCD(gcd,a[i]);
	for(RI i=1;i<=n;++i) a[i]/=gcd;
	return work()^1;
}
int main()
{
	n=read();
	for(RI i=1;i<=n;++i) a[i]=read();
	if(work()) puts("First");
	else puts("Second");
	return 0;
}

E - Rearranging

出题人你和黑板有什么仇什么怨…

考虑先手已经把序列排好了，那么不互质的两个数的相对位置肯定不变，所以对于不互质的两个数，前面那个往后面那个连一条有向边，最大字典序拓扑就是最终序列。

那么现在，我们将不互质的两个数之间连一条无向边，显然我们希望大一些的数尽量在走了小一些的数后才能够被走到，所以我们建立dfs森林，每次选择能到的点中最小的那个走到。然后对新图进行最大字典序拓扑（也就是开个堆来拓扑排序）即可。

#include<bits/stdc++.h>
using namespace std;
#define RI register int
int read() {
	int q=0;char ch=' ';
	while(ch<'0'||ch>'9') ch=getchar();
	while(ch>='0'&&ch<='9') q=q*10+ch-'0',ch=getchar();
	return q;
}
typedef long long LL;
const int N=2005;
int n,tot,a[N],vis[N],h[N],ne[N<<1],to[N<<1],du[N];
vector<int> orz[N];
int gcd(int x,int y) {return y?gcd(y,x%y):x;}
void add(int x,int y) {to[++tot]=y,ne[tot]=h[x],h[x]=tot,++du[y];}
void dfs(int x) {
	vis[x]=1;
	for(RI i=0;i<orz[x].size();++i)
		if(!vis[orz[x][i]]) add(x,orz[x][i]),dfs(orz[x][i]);
}
priority_queue<int> q;
int main()
{
	n=read();
	for(RI i=1;i<=n;++i) a[i]=read();
	sort(a+1,a+1+n);
	for(RI i=1;i<=n;++i)
		for(RI j=i+1;j<=n;++j)
			if(gcd(a[i],a[j])>1) orz[i].push_back(j),orz[j].push_back(i);
	for(RI i=1;i<=n;++i) if(!vis[i]) dfs(i);
	for(RI i=1;i<=n;++i) if(!du[i]) q.push(i);
	while(!q.empty()) {
		int x=q.top();q.pop();printf("%d ",a[x]);
		for(RI i=h[x];i;i=ne[i]) {
			--du[to[i]];
			if(!du[to[i]]) q.push(to[i]);
		}
	}
	return 0;
}

F - Tree Game

出题人你跟石子什么仇什么怨…

判定方法是，如果一个子树必胜，那么必定存在一个它的儿子，满足儿子的权值小于当前点的权值，并且儿子是一个必败节点。这个很显然，因为如果这样一个儿子存在的话，你直接给他移过去，如果对面不服再移回来，你就再给他移过去，移到他服为止，当然了，他也只能服。否则的话不是必胜点，那么是一个必败点咯。
——最强的yyb

#include<bits/stdc++.h>
using namespace std;
#define RI register int
int read() {
	int q=0;char ch=' ';
	while(ch<'0'||ch>'9') ch=getchar();
	while(ch>='0'&&ch<='9') q=q*10+ch-'0',ch=getchar();
	return q;
}
const int N=3005;
int h[N],ne[N<<1],to[N<<1],sg[N],a[N];
int n,tot;
void add(int x,int y) {to[++tot]=y,ne[tot]=h[x],h[x]=tot;}
void dfs(int x,int las) {
	sg[x]=0;
	for(RI i=h[x];i;i=ne[i]) {
		if(to[i]==las) continue;
		dfs(to[i],x);
		if(a[to[i]]<a[x]&&!sg[to[i]]) sg[x]=1;
	}
}
int main()
{
	int x,y;
	n=read();
	for(RI i=1;i<=n;++i) a[i]=read();
	for(RI i=1;i<n;++i) x=read(),y=read(),add(x,y),add(y,x);
	for(RI i=1;i<=n;++i) {dfs(i,0);if(sg[i]) printf("%d ",i);}
	return 0;
}
litble
关注
专栏目录
Atcoder AGC005 B Minimum Sum-思维
岂曰无衣，与子同袍
10-03 359
看到这道题的第一反应是线段树 然而小蒟蒻只会粘板 洋洋洒洒的代码实在是望而生畏 在Atcoder上浪了一波 看到tourist巨佬的程序 昨天晚上脑子有点挂机 没怎么看懂 今天早上爬起来看 实在是妙啊 不愧是巨佬 首先有一个巧妙的转化思想 就是枚举区间找最小值的复杂度很高 但我们可以去找每一个元素的“贡献区间” 而且这种关系是一一对应的 即是没有两个元素 对应同一个区间 后面的找区间和统计答案...
Atcoder agc040简要题解
mayaohua
04-03 951
补一下最近几场的agc。 A - >< 略 B - Two Contests 略 C - Neither AB nor BA 先考虑没有′C′'C'′C′的情况。注意到如果存在多对′AA′'AA'′AA′或′BB′'BB'′BB′且有解，随便消去一对都可以得到一组合法解。那么考虑将2k−12k-12k−1和2k2k2k分一组，如果相同直接消掉，易证有解当且仅当剩下的′AB′'AB'′A...
【Atcoder】AGC010 B-F简要题解
远行客
03-09 247
B.差分转换 C.F 简单博弈
AtCoder AGC038D Unique Path (图论)
suncongbo's blog
09-23 279
题目链接 https://atcoder.jp/contests/agc038/tasks/agc038_d 题解 orz zjr神仙做法 考虑把所有\(C_i=0\)的提示的两点连边，那么连完之后的每个连通块都是一棵树 那么同一连通块内就不能出现\(C_i=1\)的提示，然后不同连通块之间可以任意连边，但是要满足两个连通块之间只能连一条边，还要连通 设有\(c\)个连通块，那么就要在连...
【AtCoder】AGC011
weixin_30413739的博客
05-02 150
AGC011 A - Airport Bus 大意：有N个人，每个人只能在\([T_i,T_i +K]\)这段区间乘车，每辆车安排C人，问最少安排几辆车 直接扫，遇到一个没有车的在\(T_i +K\)分配一辆 #include <iostream> #include <algorithm> #include <cstdio> #include <...
【AtCoder】AGC021
weixin_30731305的博客
11-15 200
A - Digit Sum 2 从高位到低位数的第i位以前前缀都相同，第i位比当前位上的数小1的情况下，后面都填9 枚举一下然后计算最大的就好 #include <bits/stdc++.h> #define fi first #define se second #define pii pair<int,int> #define mp make_pair #def...
Atcoder agc041简要题解
mayaohua
04-06 613
A - Table Tennis Training 略 B - Voting Judges 略 C - Domino Quality 当N≤3N\leq 3N≤3时特判。 经过一些构造，可以在N=4,5,6,7N=4,5,6,7N=4,5,6,7时都构造出每行每列恰有333个的方案，具体构造的方案可以看代码。注意到在NNN的一个每行每列恰有333个的方案右下方放一个N=4N=4N=4的方案，就可以...
Atcoder AGC018 简要题解
DZYO的博客
10-29 309
传送门 Coins 先转化为一个点只有两种属性xi,yix_i,y_ixi​,yi​，选出XXX个xix_ixi​，X+YX+YX+Y个xi+yix_i+y_ixi​+yi​的最大值。 如果固定选的集合那么肯定要选yiy_iyi​前kkk大的，我们枚举一下第kkk大的yiy_iyi​是多大然后在两边贪心即可。 #include &amp;lt;bits/stdc++.h&amp;gt; using namespa...
Atcoder AGC017 简要题解
DZYO的博客
10-28 330
传送门 Snuke and Spells 答案等于nnn条线段[i−cnti+1,i][i-cnt_i+1,i][i−cnti​+1,i]覆盖不到1∼n1\sim n1∼n的位置，每次只修改一个地方可以O(1)O(1)O(1)维护。 #include &lt;bits/stdc++.h&gt; using namespace std; const int RLEN=1&lt;&lt;18|1;...
AtCoder AGC006D（LgAT2165） Median Pyramid Hard 题解（AtCoder风格，二分答案）
LightningUZ的博客
05-11 430
原链接： AtCoder：点我QωQ 洛谷：点我QωQ 题意简述 有一个金字塔，长这样： //blog1 底层有2n−12n-12n−1个元素。给定nnn和这2n−12n-12n−1个元素，依次向上填，某一个格子上填的数是它下面三个数中的中位数（显然每个格子下面都有三个数）。求塔顶的那个数。 数据 输入 第一行是一个nnn。接下来一行给定2n−12n-12n−1个数。 输出 塔顶的那个数 样例 输...
【AtCoder】AGC034
weixin_30598225的博客
06-06 258
AGC034 刷了那么久AtCoder我发现自己还是只会ABCE（手动再见 A - Kenken Race 大意是一个横列，每个点可以跳一步或者跳两步，每个格子是空地或者石头，要求每一步不能走到石头或者有人的格子上，求是否能把\(A\)移动到\(C\)，\(B\)移动到\(D\)，\(A < C,B < D,A < B\) 看\(A\)到\(C\)和\(B\)到\(D\...
Atcoder agc028F
mayaohua
12-06 485
考虑从大往小枚举左上角(i,j)(i,j)(i,j)，求出所有能到达的点的权值和sum[i][j]sum[i][j]sum[i][j]。 如果(i,j+1)(i,j+1)(i,j+1)和(i+1,j)(i+1,j)(i+1,j)中至多只有一个非障碍格子，那么容易计算。否则直接加上sum[i][j+1]sum[i][j+1]sum[i][j+1]和sum[i+1][j]sum[i+1][j]sum[...
Atcoder agc031E
mayaohua
03-05 364
考虑费用流。拆点行列模型，枚举总共选的个数kkk，理解成从小到大选匹配的kkk个横坐标和kkk个纵坐标。额外增加kkk个对应选择横坐标的点和kkk个对应选择纵坐标的点，我们可以将mmm个限制转化为对这2k2k2k个点选择范围的限制，这样可以得到一个点数为O(N+k)\mathcal O(N+k)O(N+k)，边数为O(Nk)\mathcal O(Nk)O(Nk)的图，对它跑费用流即可。 因为流量是...
Atcoder agc024E
mayaohua
03-05 274
倒着考虑，从一个给定的ANA_NAN​不断删除字符能得到多少种不同的方案。为了不计重复，我们要求每次删掉一个字符xix_ixi​时，满足xi+1≠xix_{i+1}\neq x_ixi+1​​=xi​，那么合法的条件是∃j≥i,xi=xi+1=...=xj,xj+1<xi\exist j\geq i,x_i=x_{i+1}=...=x_j,x_{j+1}<x_i∃j≥i,xi​=xi...
Atcoder AGC010E :Rearranging
DZYO的博客
09-10 270
传送门 题解： 不互质的连边，联通块内部尽量小，联通块之间尽量大。 尽量大直接贪心，考虑内部如何尽量小。 我们先选取最小的，然后把与他相连的边从小到大dfs,肯定形成若干联通块。然后贪心就跟上面一样了。 #include &lt;bits/stdc++.h&gt; using namespace std; typedef pair &lt;int,int&gt; pii; typed...
Atcoder agc023E
mayaohua
11-02 413
这个题感觉比较简单？可是场上只过了777个人。 如果要计数有多少个排列是经典问题，按AiA_iAi​排序后，答案就是∏i=1n(Ai−i+1)\prod_{i=1}^{n}(A_i-i+1)∏i=1n​(Ai​−i+1)。 现在要求逆序对的总数，显然考虑枚举点对计数。假设我们算的是(i,j)(i<j)(i,j)(i<j)(i,j)(i<j)的贡献，那么当Ai≤AjA_i \leq...
【做题记录】AtCoder AGC做题记录
suncongbo's blog
06-26 224
做一下AtCoder的AGC锻炼一下思维吧 目前已做题数: 127 总共题数: 269 每一场比赛后面的字母是做完的题，括号里是写完题解的题 AGC001: ABCDEF (DEF) AGC002: ABCEF (EF) AGC003: ABE AGC004: EF (EF) AGC005: EF (E) AGC006: CD AGC007: E (E) AGC009: E (E) AG...
Atcoder agc027D
mayaohua
11-13 186
我们令m=1m=1m=1，对网格黑白染色后，要求白格的权值比相邻的黑格大，并且模相邻的黑格余111。 不考虑ai,j≤1015a_{i,j}\leq 10^{15}ai,j​≤1015的限制的话，有一个显然的构造，令黑格取不同的奇质数，白格取相邻黑格的lcm+1lcm+1lcm+1，这样显然互不相同且合法，问题是权值太大了。 考虑调整一下这个做法，我们给每条主对角线和反对角线分别对应一个奇质数，每...
atcoder agc002 D[克魯斯卡爾重構樹+倍增]
zjc0201的博客
12-06 483
D - Stamp Rally Time limit : 2sec / Memory limit : 256MB Problem Statement We have an undirected graph with N vertices and M edges. The vertices are numbered 1 through N, and the edges are numbered 1...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值