Codeforces Round #633 (Div. 2) A~D题解

A.Filling Diamonds

如果这个菱形是竖着的,那么后面的形状便会固定
答案就是$n$

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int t;
ll n;
void solve(){
	scanf("%d",&t);
	while(t--){
		scanf("%lld",&n);
		printf("%lld\n",n);
	}
}
int main(void)
{
	solve();
	return 0;
 } 

B.Sorted Adjacent Differences

题意:
给定一个长度为n的数组,让你重新排列,满足
$|a1-a2|\le |a2-a3|\le \dots \le |an-1-an|$
题解:
从中间开始,向右跳一格,向左跳两格,向右跳三格,反复横跳.

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAX = 1e5+5;
int t,n,a[MAX],mid,len,op;
void solve(){
	scanf("%d",&t);
	while(t--){
		scanf("%d",&n);
		for(int i=1;i<=n;++i) scanf("%d",&a[i]);
		sort(a+1,a+1+n);
		mid=n/2;
		if(n&1) ++mid;
		len=op=0;
		for(int i=1;i<=n;++i){
			printf("%d ",a[mid]);
			len++;
			if(!op){
				op=1;
				mid+=len;
			}
			else{
				op=0;
				mid-=len;
			}
		}
		printf("\n");
	}
}
int main(void)
{
	solve();
	return 0;
 } 

C.Powered Addition

题意:
给定一个长度为$n$的数组,在第i秒你可以进行一次操作:
选择数组中的一些数,将他们加上$2^{i-1}$.
求最少的操作次数使得数组非递减.
题解:
由于一次操作我们可以选择任意多的数,那么只需要找出要变成非递减数组上升最大的那个数即可,只要这个数满足了,其他的数一定会满足.
处理出一个b数组:

b数组的意义为经过最少次的变换后的非递减数组.
取个max(b[i]-a[i]),这样就可以求出上升最大的那个数,从而求出最少的操作次数.

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAX = 1e5+5;
const ll INF = 0x3f3f3f3f3f3f3f3f;
int t,n,ans;
ll a[MAX],b[MAX],mx,now,j;
void solve(){
	scanf("%d",&t);
	while(t--){
		scanf("%d",&n);
		for(int i=1;i<=n;++i) scanf("%lld",&a[i]);
		b[0]=-INF,mx=-INF,ans=0,now=0,j=0;
		for(int i=1;i<=n;++i){
			if(a[i]>b[i-1]) b[i]=a[i];
			else b[i]=b[i-1];
			mx=max(mx,b[i]-a[i]);
		}
		while(1){
			if(now>=mx) break;
			now+=(1ll<<j);
			++j;
			++ans;
		}
		printf("%d\n",ans);
	}
}
int main(void)
{
	solve();
	return 0;
 } 

D.Edge Weight Assignment

题意:
给定一颗树,每条边有一条边权,要满足任意两个叶子结点之间的简单路径的所有边权的异或和为0.求分别求出满足条件的最少和最多的不同边权数

题解:
最少边权数:
指定1节点为根节点,然后求出所有叶子结点的深度,如果叶子结点的深度中既有偶数也有奇数,那么最少边权数为3,否则为1.
假如说深度只有奇数或者只有偶数的话,那么任意两个节点之间的距离都为偶数,那么所有边权都取一样的就行,偶数个相同的数异或和为0.
如果说既有奇数也有偶数,那么会有两个节点之间的距离为奇数的情况,那么至少需要三个数才能使得异或和为0.

最多边权数:
首先考虑一条链的情况,显然答案为这条链的长度.
假如说在这条链的基础上加上几个点.
如下图:

上图中三个红线连到的点和那条绿线连到的点的权值必须是一样的.

在此基础上,又加了一个点A,此时黄色的边和两条红色的边权值是必须一样的,但是两条绿色的边权值可以不同.
可以看出,当一个节点有多个叶子结点时,边权就会产生重复.
所以答案为n-1-(每个节点的儿子中重复的边权数之和)

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAX = 1e5+5;
int n,first[MAX],nextt[MAX*2],u[MAX*2],v[MAX*2],cnt=0,du[MAX];
int deep[MAX],ji,ou,ans1,ans2;
void add(int a,int b){
	u[cnt]=a,v[cnt]=b;
	nextt[cnt]=first[u[cnt]];
	first[u[cnt]]=cnt;++cnt;
}
void dfs(int dot,int dep,int fa){
	deep[dot]=dep;
	for(int num = first[dot];num!=-1;num=nextt[num]){
		if(v[num]==fa) continue;
		dfs(v[num],dep+1,dot);
	}
}
void solve(){
	memset(first,-1,sizeof(first));
	scanf("%d",&n);
	for(int i=1;i<n;++i){
		int a,b;
		scanf("%d%d",&a,&b);
		++du[a],++du[b];
		add(a,b),add(b,a);
	}
	dfs(1,1,0);
	for(int i=1;i<=n;++i) {
		if(du[i]==1&&deep[i]&1) ji=1;
		else if(du[i]==1&&deep[i]%2==0) ou=1;
	}
	if(ji&&ou) ans1=3;
	else ans1=1;
	ans2=n-1;
	for(int i=1;i<=n;++i){
		if(du[i]!=1){
			int tot=0;
			for(int num = first[i];num!=-1;num=nextt[num]){
				if(du[v[num]]==1){
					++tot;
				}
			}
			ans2-=max(tot-1,0);
		}
	}
	printf("%d %d\n",ans1,ans2);
}
int main(void)
{
	solve();
	return 0;
}