Codeforces Round #629 (Div. 3) (A~F)

传送

A. Divisibility Problem （求余）
B. K-th Beautiful String （模拟 规律）
C. Ternary XOR （构造）
D. Carousel （构造）
E. Tree Queries（树链）
F. Make k Equal（贪心+思维）

A. Divisibility Problem

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;

int main()
{
	int T;
	cin>>T;
	while(T--){
		int a,b;
		cin>>a>>b;
		int t = a%b;
		if(t!=0) t = b-t;
		cout<<t<<endl;
	}
	return 0;
 } 

B. K-th Beautiful String

关于此题还是需要，实际手动模拟一下下标就🆗了。思路是总共就两个b，初始两个b都在最后，之后每挪动一次第一个b，第二个b就依次会有2、3、4、5……个位置可以放，题目已经给出了总和是多少，这样就可以模拟出两个b的位置了。

#include<iostream>
#include<cstdio>
#include<algorithm>

using namespace std;

int main()
{
	int T;
	cin>>T;
	while(T--){
		int a,b;
		cin>>a>>b;
		int sum=0,i=0,j;
		while(sum<b) i++,sum+=i;
		j = b-(sum-i);
		j = a-j+1;	//将倒数第j个位置，转化成正数第j个方便输出。
		i++;
		i = a-i+1;	//同上
		for(int k = 1 ;k<=a;k++){
			if(k==i||k==j) printf("b");
			else printf("a");
		}puts("");
	}
	return 0;
}

C. Ternary XOR

感觉比上个题还简单，，直接分类讨论一下，当遇到1的时候就把1给第一个数，之后的数就全给第二个数，否则就对半分就🆗了

#include<iostream>
#include<cstdio>
#include<algorithm>

using namespace std;

int main()
{
	int T;
	cin>>T;
	while(T--){
		vector<int> a,b;
		int n;
		cin>>n;
		string s;
		cin>>s;
		a.push_back(1);
		b.push_back(1);
		int flag=1;
		for(int i=1;i<n;i++){
			if(s[i]=='0'){
				a.push_back(0);
				b.push_back(0);
			}
			else if(s[i]=='2'&&flag) {
				a.push_back(1);
				b.push_back(1);
			}
			else if(s[i]=='1'&&flag){
				a.push_back(1);
				b.push_back(0);
				flag=0;
			}
			else {
				a.push_back(0);
				b.push_back(s[i]-'0');
			}
		}
		for(int i=0;i<n;i++) cout<<a[i];
		cout<<"\n";
		for(int i=0;i<n;i++) cout<<b[i];
		cout<<"\n";
	}
	return 0;
}

D. Carousel

题意：给围成一圈的动物染色，然后相邻的不同动物不然能然同一个色，其他随意染，问最少的颜色数。
思路：其实染色数不会超过3，因为我们可以212121的染色，这时候只要考虑首尾是否相同就可以了，分类讨论一下即可。
1：只有一种动物。
2：动物数是偶数，直接212121的染就🆗了。或者动物数是奇数，但是有两个相同的动物挨着（当首尾两个动物相同也算），这时候把这两个染成一个色，剩下的就按偶数处理了。
3：动物数是奇数且没有两个相同的动物挨着，这时候为了首尾两个动物染不同的色，直接给尾部染3，其他按偶数212121的染就好。

#include<bits/stdc++.h>

using namespace std;
typedef long long LL;
const int N = 2e5+7;

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);
		a[0] = a[n];	//注意首尾处理
		int ok=1;
		for(int i=2;i<=n;i++) if(a[i]!=a[i-1]) ok=0; 
		if(ok){
			puts("1");
			for(int i=1;i<=n;i++) printf("1 ");
		 	puts("");continue;
		}
		if(n%2==0){
			puts("2");
			for(int i=1;i<=n;i++) printf("%d ",i%2+1);
		 	puts("");continue;
		}
		int flag = 0;
		for(int i=1;i<=n;i++) if(a[i]==a[i-1]) flag = i;
		if(flag){
			puts("2");
			for(int i=1;i<=flag-1;i++) printf("%d ",i%2+1);		//注意这里的处理
			for(int i=flag;i<=n;i++) printf("%d ",2-i%2);		//这样才能保证首位不同色
			puts("");
		}
		else {
			puts("3");
			for(int i=1;i<n;i++) printf("%d ",i%2+1);
			puts("3");
		}
	}
	return 0;
}

E. Tree Queries

题意：寻找是否存在一条链，使得所给的 k 个节点，到这条链的距离为0或1；
思路：由于树的性质，到链的距离为零的节点的父节点距离距其也为0，所以我们把这 k 节点都转化成它的父节点，使满足条件的节点到链的距离都为0，然后判断这 k 个节点是否都在同一条链上就🆗了；
判断所有点是否在同一条链上：我们使用递归序把每个节点都转化成区间，然后把这k个节点按深度从小到大排序，当深度大的节点都在深度小的节点的子树里，那么就组成了一条链。我们使用递归序组成的区间来判断是否在其子树里。（子树里的区间一定是根节点的子区间）

#include<bits/stdc++.h>

using namespace std;
typedef long long LL;
typedef pair<int,int> PII;
typedef vector<int> VE;
const int N = 2e5+7;

int n,m;
vector<int> G[N];
int ldf[N],rdf[N],dep[N],fa[N],cnt;  //左右区间端点，深度，父节点，递归序；
int que[N];

void DFS(int u,int f)
{
	fa[u] = f;
	dep[u] = dep[f] + 1;
	ldf[u] = ++cnt;		//左端点
	for(auto v:G[u]){
		if(v!=f) DFS(v,u);
	}
	rdf[u] = cnt;	//右端点
}

bool cmp(int a,int b){		//按深度排序
	return dep[a] < dep[b];
}

int main()
{
	int x,y;
	scanf("%d%d",&n,&m);
	for(int i=1;i<n;i++){
		scanf("%d%d",&x,&y);
		G[x].push_back(y);
		G[y].push_back(x);
	}
	DFS(1,0);
	while(m--){
		scanf("%d",&x);
		for(int i=0;i<x;i++){
			scanf("%d",&que[i]);
			if(que[i]!=1) que[i] = fa[que[i]];  //1的父节点是自己
			else que[i] = 1;
		}
		sort(que,que+x,cmp);	
		int ok = 1;
		for(int i=1;i<x;i++){
			if(ldf[que[i]]<ldf[que[i-1]] || ldf[que[i]] > rdf[que[i-1]]) ok = 0;  //不是子区间
		}
		puts(ok?"YES":"NO");
	}
	return 0;
}

F. Make k Equal

解题之前明确一点题意：要得到 k 个数量的目标数 a ，那么操作中有某个中间状态是：
1、当这个k个数都从左边来挑选时，某个状态：a 的左边的数都变为了 a - 1；
2、同理，都从右边来时，某个状态：a 的右边的数都变为了 a + 1；
3、同时从两边来时，同上综合；
贪心（greedy），首先目标数在数组里，然后枚举数组里的数为目标数，取最小步数即可；

#include<bits/stdc++.h>

using namespace std;
typedef long long LL;
typedef pair<int,int> PII;
typedef vector<int> VE;
const LL INF = 1e18; 
const int N = 2e5+7;

int arr[N];
LL sum[N];
map<int,int> mp; 

int main()
{
	int n,k,num=0;
	cin>>n>>k;
	for(int i=1;i<=n;i++)
		scanf("%d",&arr[i]),mp[arr[i]]++,num = max(num,mp[arr[i]]);
	if(num>=k) {	//同一个数的个数超过>=k
		cout<<0<<endl;return 0;
	}
	sort(arr+1,arr+n+1);
	for(int i=1;i<=n;i++)
		sum[i] = sum[i-1] + arr[i];
	LL ans = INF;
	for(int i=1;i<=n;i++){
		if(i>=k) ans = min(ans, (LL)arr[i]*(i)-sum[i]-(i-k));	//都取左边的数，把多选的i-k个数去掉；
		if(n-i+1>=k) ans = min(ans, sum[n]-sum[i]-(LL)arr[i]*(n-i) - (n-i+1-k)); //同理，把多选的(n-i+1)-k个数去掉
		ans = min(ans, (LL)arr[i]*(i)-sum[i] +  sum[n]-sum[i]-(LL)arr[i]*(n-i) - (n-k));  //去掉多选的n-k个数。
	}
	cout<<ans<<endl;
	return 0;
}