Codeforces Round #670 (Div. 2)

最新推荐文章于 2020-09-16 14:15:09 发布

原创最新推荐文章于 2020-09-16 14:15:09 发布 · 279 阅读

0 ·

CC 4.0 BY-SA版权

总结同时被 2 个专栏收录

5 篇文章

订阅专栏

Codeforces

3 篇文章

订阅专栏

本文分享了在Codeforces竞赛中解决A至E级问题的高效算法策略，包括使用桶和差分数组优化搜索，通过调整法寻找树的重心，以及利用质数筛选法解决复杂数学问题。作者强调了思维灵活性的重要性，并提供了实战经验总结。

正题

A. Subset Mex

开个桶,相当于只需要知道什么时候第一次出现某个值出现次数<2,和某个值出现次数<1,加起来就是答案

#include<bits/stdc++.h>
using namespace std;

const int N=110;
int a[N],T,n;

int main(){
	scanf("%d",&T);
	while(T--){
		scanf("%d",&n);
		int x;
		memset(a,0,sizeof(a));
		for(int i=1;i<=n;i++) scanf("%d",&x),a[x]++;
		int t1=0,t2=0;
		for(int i=0;i<=100;i++) if(a[i]<=1){t1=i;break;}
		for(int i=0;i<=100;i++) if(a[i]<=0){t2=i;break;}
		printf("%d\n",t1+t2);
	}
}

B. Maximum Product

找一个五元组使其最大,有负数的情况,维护前i个数选j个数的最大最小值即可,然后转移的时候互相贡献一下,因为有负数的情况,这样解决的证明可以考虑要维护j+1个集合,集合里面的元素是一个k元组乘起来,每次可以由第k-1的某个元素乘上一个数贡献而来,也可以不选这个数,显然只有最小最大值有用.

#include<bits/stdc++.h>
using namespace std;

const int N=200010;
long long f[N][6],g[N][6];
int T,n;

int main(){
	scanf("%d",&T);
	while(T--){
		scanf("%d",&n);
		int x;f[0][0]=g[0][0]=1;
		for(int i=1;i<=n;i++){
			scanf("%d",&x);
			f[i][0]=f[i-1][0];g[i][0]=g[i-1][0];
			for(int j=1;j<=min(5,i-1);j++){
				f[i][j]=max(f[i-1][j],max(f[i-1][j-1]*x,g[i-1][j-1]*x));
				g[i][j]=min(g[i-1][j],min(f[i-1][j-1]*x,g[i-1][j-1]*x));
			}
			if(i<=5){
				f[i][i]=max(f[i-1][i-1]*x,g[i-1][i-1]*x);
				g[i][i]=min(f[i-1][i-1]*x,g[i-1][i-1]*x);
			}
		}
		printf("%lld\n",f[n][5]);
	}
}

C. Link Cut Centroids

给你一棵树,现在要问要删除哪条边并加上那条边,可以使其仍然是一棵树并且重心只有一个.

找重心题目已经说的很清楚了,就是要找最大子树最小的那个点,我们考虑另外一种找重心的方式,当前在x点,如果有一个子树>n/2(注意这里没有上取整和下取整),那么这个点x一定不是重心,而那个子树对应的连接点y,一定是一个更优的点,证明可以考虑走到那一个点y的时候,最大子树要么就是x对应的子树,这东西的大小肯定是<n/2的.所以要么就一定比原来x为根时y子树小,所以y一定是一个比x更优的点.

这种方法就叫调整法,知道这个以后,就可以明白为什么一棵树最多只有两个重心了,并且可以明白为什么点数为奇数的树肯定只有一个重心了.(自行思考)

如果有两个重心,那么割掉这两个重心之间的边(显然只有一条)后,肯定会分成两个大小相同的联通块,考虑将一个重心x的某个子树接到另一个重心y上就肯定可以完成操作,因为此时的重心肯定是y,因为没有一个子树>n/2.

#include<bits/stdc++.h>
using namespace std;

const int N=100010;
struct edge{
	int y,nex;
}s[N<<1];
int first[N],len=0,sz[N],son[N];
int T,n,A,B;

void ins(int x,int y){s[++len]=(edge){y,first[x]};first[x]=len;}

void dfs(int x,int fa){
	sz[x]=1;son[x]=0;
	for(int i=first[x];i!=0;i=s[i].nex) if(s[i].y!=fa){
		dfs(s[i].y,x);
		sz[x]+=sz[s[i].y];
		if(sz[s[i].y]>sz[son[x]]) son[x]=s[i].y;
	}
}

int main(){
	scanf("%d",&T);
	while(T--){
		scanf("%d",&n);
		for(int i=1;i<=n;i++) first[i]=0;len=0;
		int x,y;A=B=0;
		for(int i=1;i<n;i++){
			scanf("%d %d",&x,&y);
			ins(x,y);ins(y,x);
		}
		if(n&1){
			printf("%d %d\n%d %d\n",s[1].y,s[2].y,s[1].y,s[2].y);
			continue;
		}
		dfs(1,0);
		for(int i=1;i<=n;i++)
			if(max(sz[son[i]],n-sz[i])*2==n){
				if(!A) A=i;
				else B=i;
			}
		if(!A){
			printf("%d %d\n%d %d\n",s[1].y,s[2].y,s[1].y,s[2].y);
			continue;
		}
		else{
			int pos=0;
			for(int i=first[B];i!=0;i=s[i].nex) if(s[i].y!=A) {pos=s[i].y;break;}
			printf("%d %d\n%d %d\n",B,pos,A,pos);
		}
	}
}

D. Three Sequences

我们把c用b和a表示出来: $c_i=a_i-b_i$ ,并且写出所有的条件: $b_i<=b_{i+1},a_i-b_i>=a_{i+1}-b_{i+1} |(i>=1)$ ,最后求的就是 $\max(b_n,a_1-b_1)$ .

变形一下: $b_{i+1}-b_i>=a_{i+1}-a_i,b_{i+1}-b_i>=0| (i>=1)$ ,这东西相当于啥,我们把a,b差分成A,B之后,就有 $B_i>=\max(A_i,0)|(i>=2)$ ,我们想让 $B_n$ 最小,而 $B_n=B_1+\sum_{i=2}^n B_i$ ,后面这坨东西最小化显然是取 $B_i=\max(A_i,0)$ ,区间加差分之后就变成了单点加,然后就可以O(1)维护,记为S,那么相当于求的就是 $\max(A_1-B_1,B_1+S)$ ,这个解一下就可以知道答案是啥了吧.

#include<bits/stdc++.h>
using namespace std;

const int N=100010;
long long a[N];
int n,q;
long long S;

void add(int x,int t){
	if(x>n) return ;
	if(x>1 && a[x]>=0) S-=a[x];
	a[x]+=t;
	if(x>1 && a[x]>=0) S+=a[x];
}

int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++) scanf("%lld",&a[i]);
	for(int i=n;i>=1;i--) a[i]-=a[i-1];
	for(int i=2;i<=n;i++) if(a[i]>=0) S+=a[i];
	printf("%.0lf\n",ceil((a[1]-S)/2)+S);
	scanf("%d",&q);
	int l,r,x;
	while(q--){
		scanf("%d %d %d",&l,&r,&x);
		add(l,x);add(r+1,-x);
		printf("%.0lf\n",ceil((a[1]-S)/2)+S);
	}
}

E. Deleting Numbers

太菜了,一直没相当用B的返回值来做.

我们可以求出如果没有x的这个限制,在[2,i-1]筛完之后,i能筛掉多少个数,将它记为 $p_i$

显然只有质数i,才有 $p_i\not =0$ .那么我们可以将质数从小到大问一问B,如果返回值不跟 $p_i$ 相同,那么这个质因子必是答案.

但是x的最小质因子q是判断不出来的,因为x就算筛得掉,也会在q这里被筛,删除前问q的倍数有多少个没被删除是与用q筛掉的数是相同的.

所以问题就转化为了x的最小质因子,考虑对素数分块,每块大小100,每B完100个质数,我们就问一下A 1,若总删除个数不与x筛得掉时总删除个数相等,那么说明100个中必有x的质因子,暴力从小到大A一遍这100个质数,若返回值不为0,那么就找到了最小质因子,那么找最小质因子的次数就是([1,n]的质数个数/100+100)(这个除号可能要上取整,这个100也可能取不满,质数最多9592个,那么这东西不超过200

前面的B 质数不超过9600,找最小质因子不超过200,后面只需要2*log_2(x)次就可以找到对应质因子的次数,不超过200.

实际上最多9800次.

#include<bits/stdc++.h>
using namespace std;

const int N=100010;
int n;
int p[N],sum,a[N];
bool tf[N],vis[N];
vector<int> V;

bool check(long long x){
	if(x>n) return false;
	printf("A %lld\n",x);fflush(stdout);
	scanf("%lld",&x);
	return x==1;
}

int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++) tf[i]=true;
	int ans=1,t=0,las=0,y;
	for(int i=2;i<=n;i++){
		for(int j=i;j<=n;j+=i) a[i]+=tf[j],tf[j]=false;
		sum+=a[i];
		if(a[i]){
			t++;
			printf("B %d\n",i);fflush(stdout);
			scanf("%d",&y);
			if(a[i]!=y) V.push_back(i);
			if(t%100==0 && ans==1){
				printf("A 1\n");fflush(stdout);
				scanf("%d",&y);
				if(n-sum!=y){
					for(int j=las+1;j<=i;j++) if(a[j]){
						printf("A %d\n",j);fflush(stdout);
						scanf("%d",&y);
						if(y) {ans=j;break;}
					}
				}
				las=i;
			} 
		}
	}
	if(t%100!=0 && ans==1){
		printf("A 1\n");fflush(stdout);
		scanf("%d",&y);
		if(n-sum!=y){
			for(int j=las+1;j<=n;j++) if(a[j]){
				printf("A %d\n",j);fflush(stdout);
				scanf("%d",&y);
				if(y) {ans=j;break;}
			}
		}
	}
	if(ans!=1) V.push_back(ans);ans=1;
	for(int i=0;i<V.size();i++){
		long long x=V[i];
		while(check(x*V[i])) x*=V[i];
		ans*=x;
	}
	printf("C %d\n",ans);
}

总结

这次想的比较快,代码也没有什么锅,前4题都是一遍过,十分的幸运,在56分钟左右写完了前四题,最后一题一直在想用9600次筛掉所有数之后怎么做,交了很多发随机数贪心,大概就是将>sqrt(n)的质数随机排列,因为这些质数的指数最多出现1次,然后取前200个质数问一问,剩下的sqrt(n)以内的质数大概只有不到100个,暴力即可,谁知数据很强,最多过两个点.

思路被阻塞,固化,是严重的问题,解决方法就是多做比赛,日常遇到不会做的题都写Blog来总结,思维能力才能提高,这次CF实际上没有考察代码能力,自认为写烦题,细节题还是有很大的提升空间的,板子也要不断得背,这样在比赛场上才会有更好的思想维度.