Codeforces Global Round 6 [A-D]

Codeforces Global Round 6 [A-D]

A题

题意：

给一组数字，如果这一组数字经过重新排列后可以被60整除，则输出red，否则输出cyan。

位数n：$1\le n\le 418$

原理：

把60质因数分解后发现$60=2\ast 3\ast 2\ast 5=2\ast 3\ast 10$

所以对于一个数，若它可被60整除，则其分别除以10，3，2后为一个整数

• 对于10，只要保证数的末尾有一个0即可
• 对于3，只要保证所有数字的和%3等于0即可
• 对于2，只要保证有一个偶数即可 ( 包括0 )

注意：不是能同时能被10，3，2整除就满足条件，30能同时被10，3，2整除，但不能被60整除。

前面所阐述的是能依次被10，3，2整除

一个数能被3整除，除以2之后仍然能被3整除（因数分解），所以只要保证全部的数位之和为3，倒数第二位为偶数位，最后一位为0即可满足条件（可被60整除）

算法：

扫描一遍字符串，记录总和cnt，记录每个数出现的次数

若0出现次数为0，或者cnt%3不等于0，则输出cyan

若除了作为最低位的0之外不含偶数，则输出cyan

若存在0，cnt%3=0，且除了作为最低位的0之外还有其它偶数，则输出red

复杂度$O(n)$

代码：

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
const int maxm=1e2+10;	
char a[maxm];
int num[12];//统计每个数字出现的次数
void judge(){
	memset(num,0,sizeof(num));//注意每次清空统计
	int len=strlen(a);
	int cnt_3=0;//记录所有数的总和
	for(int i=0;i<len;i++){
		num[a[i]-'0']++;
		cnt_3+=a[i]-'0';
	}
	if(!num[0]||cnt_3%3) {//如果不存在0或者总和不能被3整除
		printf("cyan\n");
		return ;
	}
	for(int i=0;i<5;i++){
		if(!i){
			if(num[i]>1){//如果除了最低位的0之外仍然有0
				printf("red\n");
				return ;
			}
		}else{
			if(num[i*2]){//有偶数存在
				printf("red\n");
				return ;
			}
		}
	}
	printf("cyan\n");//没有除了最低位的0之外的其它偶数
	return ;
}
int main(){
	int T;
	scanf("%d",&T);
	while(T--){
		scanf("%s",a);
		judge();//判断行不行~
	}
}

---

B题

题意：

有无限个骰子，每个筛子的正对两面之和为7（1对6，2对5，3对4），把骰子摞起来放在桌子上（最下面的一面不可见，且只有一摞）。给定一个正整数n，问能不能使骰子露在外面的所有面的点数之和等于n。能则输出YES，不能则输出NO

原理：

一个骰子的总点数为21，被摞在下面的骰子肯定有一对面都被挡起来了，所以除了最上面的一个骰子，其它的骰子露在外面的数总和肯定都是14。所以，只要n=14*x(x为正整数)+a ($a\in [1,6]$)即可

算法：

首先判断n是否小于15，因为若n小于15，在一个骰子的情况下，把6放在最下面，裸露出来的也有15点，怎么样也满足不了

然后n%14，若n%14 $\in [1,6]$ ，则符合条件，否则不行

复杂度$O(1)$

代码：

#include <cstdio>
#include <iostream>
#define ll long long
using namespace std;
ll n;	
int main(){
	int T;
	scanf("%d",&T);
	while(T--){
		scanf("%lld",&n);
		if(n<15) printf("NO\n");//小于15一定不行
		else{
			if(n%14<7&&n%14) printf("YES\n");//%14之后小于7且不为0
			else printf("NO\n");
		}
	}
}

---

C题

题意：

给两个正整数r和c，问能不能构造一个r行c列的矩阵，使每一行，每一列的所有数的gcd最小，且每行每列的gcd都不能相同。如果能，输出矩阵，不能，则输出0

$1\le r,c\le 500$

原理：

对于一个r行c列的矩阵，不妨假设各行各列的所有数的gcd分别为$[1,\cdots ,r+c]$

行的标号为$[1,r]$，列的标号为$[r+1,r+c]$，每个元素为行标号乘以列标号，这样可以保证每行所有数的gcd等于行的标号。因为每一列标号之差都是1，它们的gcd也是1，所以每一行相当于一个等差数列，这样一个数列的gcd必定等于行标号。类似下表。（列的情况同理）

$\cdots$	3	4	5
2	6	8	10

但是有一种情况是例外，只有一行或者一列的时候，比如：

	6
1	6
2	12
3	18
4	24
5	30

单个数的gcd是它本身，但是这个时候的最大gcd并不是30，而是下面这样:

	1
2	2
3	3
4	4
5	5
6	6

也就是说，要使行和列的数的乘积尽量地小，所以在r<c的情况下，应该先从行编号，在r>c的情况下，应该先从列编号

算法：

先判断r和c的关系

• r>c，则列的编号为$[1,c]$，行的编号为$[c+1,c+r]$
• r<c，则行的编号为$[1,r]$，列的编号为$[r+1,r+c]$
• r=c，两种都可以，但是r=c=1的时候，行和列的gcd都为1，此时违反了规则

复杂度O(r*c)

代码：

#include <cstdio>
#include <iostream>
using namespace std;
const int maxm=5e2+10;
int r,c;
int a[maxm][maxm];
int main(){
	scanf("%d%d",&r,&c);
	if(r==c&&r==1){//r=c=1,不行
		printf("0\n");
	}else{
		bool flag=r>c?1:0;//看先从行开始还是先从列开始编号
		for(int i=1;i<=r;i++){
			for(int j=1;j<=c;j++){
				if(flag) printf("%d ",(i+c)*j);//从列开始,该元素为(i+c)*j
				else printf("%d ",i*(j+r));    //从行开始,该元素为i*(j+r)
			}
			printf("\n");//每行末换行~
		}
	}
}

---

D题

题意：

有n个人，他们之前相互欠债

给m行表示他们的欠债关系：x y z

表示 x 应该还给 y z 元钱

现在想让你尽量简化他们之间的欠债关系

输出：简化后还有 a 个关系，之后的 a 行，每行输出一个 x y z ，表示 x 应该还给 y z 元钱

$1\le n\le 10^5$

原理：

最简单的当然是没有中间商赚差价啦~

如果①–5-->②–5-->③，这样肯定不如①–5-->③简单。

所以我们关心的就只有每个人应该还多少钱或者每个人应该拿到多少钱

对于 X ，他只要从其他人那里拿到他应该拿到的钱或者给其他人还他欠的总钱数就可以了

类似找钱的时候，假如我要付11元，可以直接付11元，也可以付20元找零9元，当然是11元更简单~

算法：

录入的时候先计算出来每个人应该还或者应该拿到多少钱

然后把应该还钱的人弄到一个队列里，把应该拿钱的人弄到另一个队列里

一直让还钱的人还钱，直到任意一个队列为空停止

细节处理见代码~

复杂度$O(n)$

代码：

#include <queue>
#include <vector>
#include <cstdio>
#include <iostream>
#define ll long long//不开long long见祖宗
using namespace std;
const int maxm=1e5+10;
int n,m;
ll det[maxm];//统计每个人应该还/拿的钱
struct node{
	int num;//人的号码
	ll d;   //钱
	node(){}
	node(int num,ll d):num(num),d(d){}
};
struct ans{
	int x,y;//x还给y
	ll d;   //还d元
	ans(){}
	ans(int x,int y,ll d):x(x),y(y),d(d){}
};
queue<node> out,in;//还钱队列和拿钱队列
vector<ans> v;     //答案vector
int main(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++){
		int x,y,z;
		scanf("%d%d%d",&x,&y,&z);//x给y还z元
		det[x]-=z;
		det[y]+=z;
	}
	for(int i=1;i<=n;i++){
		if(!det[i]) continue;//收支平衡
		else if(det[i]<0) out.push(node(i,-det[i]));//欠债还钱,到out队列里
		else in.push(node(i,det[i]));//被欠拿钱,到in队列里
	}
	while(!out.empty()&&!in.empty()){//其中一个队列为空,停止
		node now=in.front();//now是拿钱的
		in.pop();
		node tmp=out.front();//tmp是还钱的
		out.pop();
		if(tmp.d>=now.d){//可以还上
			v.push_back(ans(tmp.num,now.num,now.d));//统计答案
			tmp.d-=now.d;//还了之后还有多少钱
			if(!tmp.d) continue;//正好还完,就不用管
			else out.push(node(tmp.num,tmp.d));
            //还了这个之后还欠钱,到队列里接着还
		}else{//还不上
			v.push_back(ans(tmp.num,now.num,tmp.d));//统计答案
			now.d-=tmp.d;//拿钱之后还应该拿多少钱
			in.push(node(now.num,now.d));//到队列里接着拿钱
		}
	}
	printf("%d\n",(int)v.size());//输出有多少个关系
	for(int i=0;i<(int)v.size();i++)
		printf("%d %d %lld\n",v[i].x,v[i].y,v[i].d);//输出x应该还y d元钱
}