Codeforces Round #735 (Div. 2)(全部题解)

&が&

于 2021-09-26 10:10:47 发布

阅读量240

点赞数 13

分类专栏：题目文章标签：算法 c++ 动态规划深度优先

本文链接：https://blog.csdn.net/qq_51467306/article/details/120378623

版权

题目专栏收录该内容

15 篇文章 0 订阅

订阅专栏

A. Cherry

B. Cobb

C. Mikasa

D. Diane

E. You

A. Cherry

分析：
这道题需要求出在整个数组范围内，某一区间内的最大值乘于最小值所得的值的最大值。我们记录某一区间内的最大值乘于最小值所得的值的最大值为rmq;假设我们考虑三个相邻的的数 a[i] 和 a[i+1]和a[i+2]（此时所考虑的区间为[i,i+2]）,计算出该区间的rmq为ans。我们将区间分解为两个区间[i,i+1]和[i+1,i+2]，区间1的rmq为r1,区间2的rmq为r2;那么ans和r1与r2之间又有什么关系呢？显然ans==max(r1,r2).为什么呢？由于涉及三个数的大小关系，所以有6种可能（我们记a[i]=a, a[i+1]=b, a[i+2]=c）：

a最大，b中间,c最小： ans==a*b;
a最大，b最小,c中间：ans==a*b
a中间，b最大,c最小：ans==a*b;
a中间，b最小,c最大：ans==b*c;
a最小，b中间,c最大：ans==b*c;
a最小，b最大,c中间：ans==b*c;
由此可知，区间最大值rmq一定在相邻两个数之间取到，所以只需要遍历一遍数组，求出所有的相邻数乘积比较出最大值即可。
效率：时间复杂度为O(n).
注意：要用long long毕竟1e6 * 1e6超出int范围.

AC代码：

#include<iostream>
using namespace std;
const int N=2e5+5;
int main(){
	int t;
	cin>>t;
	while(t--){
	   long long int ans=0;	
	   int n;
	   int a[N];
	   cin>>n;
	   for(int i=1;i<=n;i++)
		cin>>a[i];
		for(int i=2;i<=n;i++)
		if((1LL*a[i]*a[i-1])>ans) ans=1LL*a[i]*a[i-1];	
		cout<<ans<<endl;
	}
	return 0;
}

B. Cobb

分析：
仔细观察k的范围，会发现k<=100;又显然1<=ai<=n，所以 ai | aj <=2 * n。i * j最大可达到n^2,而k*(ai | aj)最大也就是200 * n;显然，当n在一定大的时候，200*n所起的作用并不是很大，只需要在n一定大的时候遍历所有的n即可。那这个一定大的范围应该在哪里呢？我们记函数f( i , j )=i * j-k * (ai | aj).则f(n-1,n)=n * n-2 * k * n-n。我们需要找到可能的最小的i,使f(i, j)>f(n-1,n).假设ai=an=0，那么f(i,n)=i * n（此时i一定是最小的，因为被减数k * (ai | aj)为0，j为最大值n）。那么令 i * n>n * n-2 * k * n-n;
则i>n-2 * k-1。所以我们只需要从max(1,n-2 * k)开始遍历i即可得到答案。
效率：时间复杂度为O(k^2).
AC代码：

#include<bits/stdc++.h>
using namespace std;
const long long INF=1e12;
const int maxn=2e5+10;
int n,k,a[maxn];
inline int read(){
	int x=0,f=1;
	char c=getchar();
	while(c<'0'||c>'9') {if(c=='-') f=-1;c=getchar();}
	while(c>='0'&&c<='9') x=x*10+c-'0',c=getchar();
	return x*f; 
}
inline long long f(int i,int j){
	return 1LL*i*j-1LL*k*(a[i]|a[j]);
} 
int main(){
	int t;t=read();
	while(t--){
		memset(a,0,sizeof(a));
		n=read(),k=read();
        for(int i=1;i<=n;i++) a[i]=read();
        long long ans=-INF;
        int i,j;
		i=max(1,n-2*k);
        for(;i<=n;i++)
           for(j=i+1;j<=n;j++)
           ans=max(ans,f(i,j));
        printf("%lld\n",ans);
	}
	return 0;
}

C. Mikasa

分析：
由于t<=30000,m<=1e9;显然直接暴力肯定会超时，这时候我们需要仔细想想一定要遍历每一个数吗？显然不需要，在想到好方法之前，大家得知道一件事：n^x=k,则n ^ k=x（ ^为异或）。该题需要我们找到最小的非负整数ans，ans在n ^x（x属于0~ m）中没有出现。也就是让我们找到一个最小的k，使n ^ k>m;因为当n^k<=m（记住k==n ^ x）的时候，在n ^x的时候该k都已经出现过。所以我们可以通过比较n与m+1的二进制每一位数来得到最小的满足条件的k，也就是答案ans。那么应该怎样比较呢？首先先理解我们需要比较的公式 n^ k>=m,也就是n与最小的k异或的结果大于等于m+1。那么我们可以从二进制最高位向最低位开始遍历每一位数字。首先要知道2的30次方刚好大于1e9，是满足条件的。所以我们从i=30开始遍历到i=0,然后比较n与m+1的第i+1位二进制数(因为i=0时，是第一位二进制数);比较情况有以下三种情况：假设n的第i+1位二进制为a,m+1的第i+1位二进制数是b。（a,b只能等于0或1）

a==b：此时这两位的二进制数相等，为了让k最小，我们让k的第i+1位二进制数为0。因为如果a=b=1,a^0=1=b;否则a=b=0;a ^ 0=0=b。
a=0,b=1:此时为了让n ^k >=m+1;n ^k的高位二进制应该大于等于m+1的该位。所以k的该位二进制只能等于1。这样a ^1=b。
a=1,b=0:此时k的该位二进制可为0也可为1，（因为a ^1(或0)>=b）但由于是从高位开始遍历的，所以为了让k最小，只能让k=0。此时我们可以很清晰的发现，n ^ k在该位之前的所有二进制数都是相等的，而该位是n ^k=1>=m+1=0,由于这是高位，此时无论接下来的二进制是啥，n ^k都一定大于等于m+1。所以可以跳出循环了，并且让之后的k的二进制数全为0即为k的最小值。
效率：时间复杂度为O(1). 是不是很不可思议！！！
注意：求二进制的每一位数字应该用（x>>i）&1而不只是n>>i。因为n>>i所求的值是i+1位及之前所有二进制数字的值总和。用(x>>i)&1可以只判断这一位是0还是1.

AC代码:

#include<bits/stdc++.h>
using namespace std;
inline int read(){
	int x=0,f=1;
	char c=getchar();
	while(c<'0'||c>'9') {if(c=='-') f=-1;c=getchar();}
	while(c>='0'&&c<='9') x=x*10+c-'0',c=getchar();
	return x*f; 
}
int main(){
    int t=read();
	while(t--){
		int n=read(),m=read();
		if(m<n) {
			printf("0\n");
			continue;
		}
		++m;
		int ans=0;
		for(int i=30;i>=0;i--){ //二进制从高位开始处理 
			if((n>>i&1)==(m>>i&1)) continue;
			else if(!(n>>i&1)&&(m>>i&1)) ans+=(1<<i);
			else break;
		}
		printf("%d\n",ans);
	}	
	return 0;
}

D. Diane

分析：
这显然是一道找规律然后构造字符串的题。那么找规律就变成了关键也是难点。接下来我们就来看看通过题意能发现什么规律啊！我们需要让所有可能出现的相同子串出现次数为奇数，那么我们想想什么情况下子串出现次数为奇数呢？首先由于需要我们自己去构造字符串，所以尽量让构造的字符串简单，用的字母少肯定越好。我们假设字符串pp全是字母a,若字符串长度为k,则f(a)=k; f(aa)=k-1; f(aaa)=k-2; … (f(i)表示字符串中出现子串i的次数); 假设字符串qq全是字母a且字符串长度为k-1,则f(a)=k-1; f(aa)=k-2； f(aaa)=k-3…;那么对于pp+qq这个长串来说，假设每一个子串（a,aa,aaa或aaaa等等）其在串pp中出现次数都为x,那么在qq中都为x-1;因为x+x-1=2*x-1;一定为奇数。所以规律便已经找到了。
我们只需要把每一个长度为n的字符串分为三部分，左边长为k=n/2，全是字母a,右边长为k-1=n/2-1,全是字母a;中间长为len=n-2*k+1。那么n为奇数时，len=2;只需要补bc即可；n为偶数时，len=1;只需要补b即可。
效率：时间复杂度为O(n).
注意：n=1时单独判断输出任意一个字母即可；否则会把n为奇数看待补上bc就超出n范围了.

AC代码如下：

#include<bits/stdc++.h>
using namespace std;
int main(){
	int t;cin>>t;
	while(t--){
		int n;cin>>n;
		int l=n/2,r=l-1;
		if(n==1) cout<<"a";
		else if(n&1){
			for(int i=1;i<=l;i++) cout<<"a";
			cout<<"bc";
			for(int i=1;i<=r;i++) cout<<"a";
		}
		else{
			for(int i=1;i<=l;i++) cout<<"a";
			cout<<"b";
			for(int i=1;i<=r;i++) cout<<"a";
		}
		cout<<endl;
	}
	return 0;
}

E. You

分析：
蒻蒻一看这是一道2600分的题就已经被吓到了！！！不过在蒻蒻集许多大佬的思想集一身时，终于拨开云雾见光明了。首先用邻接表存树的无向边，应该是很基本的操作了。该题要求从1~n的每一个值k在gcd(a1,a2,…,an)=k时出现的次数，也就是不同的序列次数。那么我们就需要找点规律了，不然无从下手。我们可以开一个ans[maxn]数组，ans[i]记录gcd(a1,a2,…,an)是i的倍数的出现次数。为啥这样做呢？看完接下来的解析你就会明白了。我们可以发现这棵树有n-1条边，每条边连着两个结点u,v；那么分权有两种情况：如果先删除结点u,那么分权a[u]+1;否则就是a[v]+1;所以不难发现，每条边有两种情况，所以总情况次数为2^(n-1)。又因为1肯定是任意整数的因子（注意：gcd（0，x）=x）;所以ans[1]=2^(n-1)。
对于其他的k>1;那么又是什么情况呢？
仔细观察，对于每一个分权序列a1,a2,…,an来说，由于只有n-1条边对分权有贡献，且每条边贡献为1，所以a1+a2+…+an=n-1;那么k>1的时候，只有当所有的ai（i=1,2,…,n）都能整除k的时候，k才是a1,a2,…,an的公因数(暂且不讨论是否是最大公因数)。所以所有的ai都能整除k，也就是a1+a2+…+an都能整除k;于是此时n-1便也能整除k。接下来就有两种情况：

(n-1)%k!=0 ：此时必定有不能整除k的ai;所以gcd(a1,a2,…,an)不可能等于k的倍数，即ans[k]==0。
(n-1)%k==0 :此时就需要进行判断。判断是否每一个ai都是k的倍数，由于他们的和是k的倍数，但每一个ai却也不一定都是k的倍数。 此时可以用dfs深搜，从结点1开始搜索这棵树的所有结点，并先全部搜到树的叶节点之后再一步步回溯判断。判断也有多种情况：
一：对于叶节点v(父亲为u)的边来说，它的分权一定是赋给了点u；若是赋给了点v,那么就是先删除点v再删除点u;此时a[v]=1；那么a[v]就不能是k(k>1)的倍数。
二：对于非叶结点v(父亲为u)的边来说： 若此时a[v]%k = =0 ,也就是此时结点v的分权已经是k的倍数了，那么该条边的分权必然是给结点u;也就是先删除结点u再删除结点v;若此时a[v]%k != 0，那么该条边的分权必然是给结点v,也就是先删除结点v再删除节点u;但如果现在a[v]%k !=0的话;也就是结点v的分权不可能等于k的倍数，那么就可以跳出深搜了,并且ans[k]=0；否则a[v]%k == 0的话，就继续深搜下去，直到所有的结点都满足a[i]%k==0;此时ans[k]=1。思考一下，为什么此时ans[k] = =1呢？其实原理很简单，回过头看深搜的回溯过程，你会发现在以上的分析过后，每一条边的分权其实都是固定给了某个点，而不出现选择的情况。也就是每个点的分权都是固定的，即删除所有结点的次序是固定的，所以删除次序唯一，所以ans[k]=1。

现在ans[maxn]数组已经处理完了，就只剩下最后一件事了，那就是找答案。我们可以发现对于k=2和k=4来说，若gcd(a1,a2,…,an)==4的话，那么它对k=2;也有贡献，也就是对于一个数k来说，ans[k]对所有k的因子都有贡献，所以k的因子就需要减掉k的贡献。我们可以逆序用i遍历n~1；找到所有的它的倍数j（j=2i,3i,…,一直到j<=n）,然后ans[i]-ans[j]即可。最后的ans数组就记录了我们需要的答案。
效率：时间复杂度为O(nlogn+n*f(n-1)). f(n-1)为n-1的因子个数。 在创建ans[]数组时的判断和dfs需要O(n*f(n-1));在最后找答案的过程需要O(nlogn)。

AC代码如下：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod=998244353;
const int maxn=2e5+10;
int n,ans[maxn],dp[maxn];
int flag;
vector<int>g[maxn];
inline int read(){
	int x=0,f=1;
	char c=getchar();
	while(c<'0'||c>'9') {if(c=='-') f=-1;c=getchar();}
	while(c>='0'&&c<='9') x=x*10+c-'0',c=getchar();
	return x*f;
}
void Init(){
	for(int i=1;i<=n;i++) dp[i]=ans[i]=0,g[i].clear();
}
int quick_power(ll base,int power){
	ll res=1;
	while(power){
		if(power&1) res=(res*base)%mod;
		power>>=1;
		base=(base*base)%mod;
	}
	res%=mod;
	return (int)res;
}
void dfs(int u,int fa,int k){
	for(int i=0;i<g[u].size();i++){
		if(!flag) return ;
		int v=g[u][i];
		if(v==fa) continue;
		dfs(v,u,k);
		if(dp[v]%k){
			dp[v]++;
			if(dp[v]%k) flag=0;
		}
		else dp[u]++;
	}
}
int main(){
	int t=read();
	while(t--){
		n=read();
		Init();
		for(int i=1;i<n;i++){
			int u=read(),v=read();
			g[u].push_back(v);
			g[v].push_back(u);
		}
		ans[1]=quick_power(2,n-1);
		for(int i=2;i<=n;i++){
			if((n-1)%i!=0) continue;
			flag=1;
			dfs(1,0,i);
			ans[i]=flag;
			memset(dp,0,sizeof(dp));
		}
		for(int i=n;i>=1;i--){
			if((n-1)%i!=0) continue;
			for(int j=2*i;j<=n;j+=i) ans[i]=(ans[i]-ans[j]+mod)%mod;
		}
		for(int i=1;i<=n;i++) printf("%d ",ans[i]);
		printf("\n");
	}
	return 0;
}

&が&

关注

13
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
Codeforces Round #735 (Div. 2)(全部题解)

A. CherryB. CobbC. MikasaD. DianeE. YouA. Cherry分析：这道题需要求出在整个数组范围内，某一区间内的最大值乘于最小值所得的值的最大值。我们记录某一区间内的最大值乘于最小值所得的值的最大值为rmq;假设我们考虑三个相邻的的数 a[i] 和 a[i+1]和a[i+2]（此时所考虑的区间为[i,i+2]）,计算出该区间的rmq为ans。我们将区间分解为两个区间[i,i+1]和[i+1,i+2]，区间1的rmq为r1,区间2的rmq为r2;那么ans和
复制链接

扫一扫