Codeforces Round #640 (Div. 4)

CF出div.4了,我的青春结束了.(题解详见注释)

A. Sum of Round Numbers

#include<bits/stdc++.h>//这一题的题意就是把一个数拆成除第一位以外都是0的数,个位数保留
//比如 115 = 100 + 10 + 5,   4142 = 1000 + 100 + 40 + 2 
using namespace std;

int main(){
	int a[100];//存放每一个拆出来的数字 
	int t,num,s;
	cin>>t;
	while(t--){
		memset(a,0,sizeof(a));//初始清零 
		scanf("%d",&num);
		s = 0;// s 表示拆分的次数 
		while(num > 0){
			int k = 1;
			while(num / k > 0)k *= 10;//这里是求出位数(这里写的有点问题导致最后算出来的位数会多一位) 
			a[s] = num / (k / 10) * (k / 10);//所以这里把 k 除 10 去掉一位  
//			num / (k / 10) * (k / 10) 得出最大的所求数字 比如 4142 这里求出的是4000 
			num -= num / (k / 10) * (k / 10);//让num 减去4000  得到 142 
			if(num)s++;//如果num 不是 0 代表没拆完 s就增加 
			
		}
		printf("%d\n",s + 1); //拆了 s 次 得到的就是 s + 1 个数字 
		for(int i = 0;i <= s;i++){
			printf("%d",a[i]);
			if(i != s)printf(" ");//注意最后一个数字之后没有空格 
		}
		printf("\n");
	} 
	return 0;
}

B. Same Parity Summands

#include<bits/stdc++.h>//题意: 把一个大小为 n 的数字 拆成 k 个数字 要保证这 k 个 数字同奇偶 
//这道题我使用了大量的条件判断 所以看起来有点冗杂 
typedef long long ll;
using namespace std;
int main(){
	int t;
	cin>>t;
	while(t--){
		ll n;//其实不用开ll 
		int k;
		cin>>n>>k;
		if(n < k)printf("NO\n");// 第一个特殊情况 k > n 这里不可能有解 
		else if(n % 2 == 1 && k % 2 == 0)printf("NO\n");//第二个特殊情况 n为奇 k 为偶数 可知
		//偶数个数字无论都是奇数还是都是偶数  相加肯定是偶数 所以这种情况也无解 
		else{//都不符合 就进入一般情况判断 
		//我的做法: 先让 n / k 这样就可以把 所求k个数字都当成 n / k 如
		//果 n 比这些数字的和大的话 就把 多出来的加到最后一个数字上去 
		//这时候 如果最后一个数字和前面的n / k 同奇偶,那么有解输出, 一奇一偶 则无解 
			int term1 = n / k,term2 = n / k;//term1 为 n / k term2 为最后一个数字 这里暂时等于term1 
			if(k % 2 == 1){//这一要做一个判断 如果 k是奇数
				if(n % 2 == 0 && term1 % 2 == 1){//n 是偶数 那么如果有解必定是k 个偶数相加 所以这里如果term1是奇数
				//就要把term1 变成偶数 一般是减去1  
					if(term1 == 1)term1++,term2++;//如果term1 就是1 减去1就是0 显然不行 所以这里让term1 加上1 
					else term1--,term2--;//这里就是一般的减去1 的情况 
				}
				if(n % 2 == 1 && term1 % 2 == 0)term1--,term2--;//n 是奇数 那么有解的话term1 一定要是奇数 如果是偶数就减去1 
			}
			term2 += n - term1 * k;//处理好term1 之后 就要把多出来的加到最后一个数字term2上 
			if((term1 + term2) % 2 == 1 || term2 <= 0)printf("NO\n");//如果term1和term2 一奇一偶 或者在
			//if(term1 == 1)term1++,term2++;这一步里面 算出来的 term1 * k > n 然后
			// term2 += n - term1 * k; 这一步term2 实际上是减小了而且小于1的话 就是无解 
			else{
				printf("YES\n");
				for(int i = 1;i < k;i++)printf("%d ",term1);
				printf("%d\n",term2);	//有解输出 注意最后无空格且需换行 
			}
		}
	}
	return 0;
}

C. K-th Not Divisible by n

#include<bits/stdc++.h>// 题意: 给你一个数字n 有无穷多个数字不能被n整除
//比如n = 3 不能被整除的数字有:1,2,4,5,7,8,10,11.....  需要你求出第k个不能被整除的数字是多少
//这题题意很显然了,但是如果正常的穷举去做的话 写都不用写都知道是超时的 (别问我怎么知道的) 所以需要一点技巧 
//代码很简单 技巧我下面解释: 
//先不用管数字n,在正整数集合里面 第k个数字就是k 现在 我们把这k个数字里面能够被n整除的数字去掉 
//去掉了多少个??  不用怀疑是 n / k  那么现在 第 k - n / k 个数字就是 k 
//现在要求第 k 个数字是多少? 聪明的你一定会换个元  第 k 个数字就是 k + n / k !(有瑕疵) 
typedef long long ll;
using namespace std;
int main(){
	int t;
	cin>>t;
	while(t--){
		int n,k,ans,term;//ans 就是最后要求的第k位数字 
		cin>>n>>k;
		ans = k;
		term = k / n;
		ans += term;
		while(ans / n > term){//这个循环呢 就是为了处理当 (k,k + n / k] 这个区间里面有新的数能被n整除的情况 
			int x = ans / n - term;
			term = ans / n;
			ans += x;
		}//聪明的读者 不难看懂哦 
		cout<<ans<<endl;
	}
	return 0;
}

D. Alice, Bob and Candies

#include<bits/stdc++.h>//题意: 话说这一天alice和bob 闲得慌 他们发现房间里有一排糖果堆,每一堆里面
//都有一些糖果 现在他们规定 alice从左边吃糖果 bob从右边吃糖果 一次吃一堆 Alice先吃一堆 bob要吃的糖果数量至少比Alice多1
//然后Alice bob轮流吃 且每次每个人吃的都要要对方吃的糖果数量多 最后某个人吃完了剩下所有糖果 就结束
//最后要求出 他们轮流了多少次 (Alice-bob-Alice-bob 算四次) 和每个人总共吃到的糖果数量 
using namespace std;//这题要用到小小的技巧: stl之动态数组vector (因为两头吃 所以要对数组的头尾进行操作 或许双向队列也行?) 
int main(){
	int t;
	cin>>t;
	while(t--){
		int n,term,alice,bob,mid,round,move,a,b;
		// Alice 和bob代表他们吃的糖果的总数 a和b代表他们在一个回合内吃到的糖果数量 
		//round表示 是谁的轮次 round = 1 代表Alice吃  round = -1 代表 bob吃 
		//mid 代表前一个人吃的糖果数量 下一个人吃的糖果一定要比这个多 move就代表了他们轮流了多少次 
		vector<int>cane;
		alice = 0,bob = 0,mid = 0,round = 1,move = 0;
		cin>>n;
		for(int i = 1;i <= n;i++){
			cin>>term;
			cane.push_back(term);
		}// 普通的输入数据 
		while(!cane.empty()){
			a = 0,b = 0;
			if(round == 1){//Alice的回合 
				do{
					a += cane[0];//吃掉一堆糖果 
					cane.erase(cane.begin());//这一堆糖果消失了 
				}while(!cane.empty() && a <= mid);//如果糖果还有 而且这一回合吃的暂时比前一个人吃的数量少 那么继续吃
				//这里用 do-while 结构 保证至少能吃一次保底 
				mid = a;// 这一回合 Alice 吃完了 吃了a个 糖果 那么把a 赋值给mid 
				alice += mid;//Alice吃的总数就要加上这个mid  或者写成a 也一样 
				round = -round;//round 变成 - 1下一次就是bob 吃了 
			}
			else{//同上 
				do{
					b += cane[cane.size() - 1];
					cane.pop_back();
				}while(!cane.empty() && b <= mid);
				mid = b;
				bob += mid;
				round = -round;
			}
			move++;//最后每一次循环不管是谁在吃 反正轮流的次数加1 
		}
		cout<<move<<" "<<alice<<" "<<bob<<endl;
	}
	return 0;
}

明明是最简单的div.4 我还是只能做四道题的说…

E. Special Elements
第一次尝试: Runtime error on test 3
代码如下:

#include<bits/stdc++.h>
using namespace std;
const int N = 8000 + 5;
int book[N],arr[N];
int main(){
	int t,n,ans,sum;
	scanf("%d",&t);
	while(t--){
		ans = 0;
		scanf("%d",&n);
		memset(book,0,sizeof(book));
		
		for(int i = 1;i <= n;i++)scanf("%d",&arr[i]);
		
		for(int k = 2;k <= n;k++){
			for(int i = 1;i <= n - k + 1;i++){
				sum = 0;
				for(int j = i;j <= i + k - 1;j++)sum += arr[j];
				book[sum]++;
			}
		}
		
		for(int i = 1;i <= n;i++)if(book[arr[i]] != 0)ans++;
		printf("%d\n",ans);
	}
	return 0;
}

此时接触到了前缀和

第二次尝试:Accepted

#include<bits/stdc++.h>//前缀和 桶排序 
using namespace std;
const int N = 8000 + 5;
int book[N],arr[N],pre[N],vis[N];//book 字典数组 运用桶排的原理 统计某个数出现的次数
// pre 是前缀和数组 vis 是判断访问数组 访问过就赋 1 
int main(){
	int t,n,ans,sum,term;
	scanf("%d",&t);
	while(t--){
		ans = 0;
		scanf("%d",&n);
		memset(book,0,sizeof(book));
		memset(pre,0,sizeof(pre));
		memset(vis,0,sizeof(vis));
		
		for(int i = 1;i <= n;i++){
			scanf("%d",&arr[i]);
			book[arr[i]]++;
			pre[i] = arr[i] + pre[i - 1];
		}
		
		for(int i = 1;i <= n;i++){
			for(int j = i + 1;j <= n;j++){
				term = pre[j] - pre[i - 1];
				if(term <= n && book[term] && !vis[term])ans += book[term],vis[term] = 1;
			}
		}
		printf("%d\n",ans);
	}
	return 0;
}

F. Binary String Reconstruction
构造一次AC了
代码如下:

#include<bits/stdc++.h>///构造一次过了!!!!!!!!!!!!!!! 
using namespace std;
const int N = 8000 + 5;
int arr[N]; 

int main(){
	int t,a,b,c; 
	scanf("%d",&t);
	while(t--){
		int term = 1;
		scanf("%d %d %d",&a,&b,&c);
		if(b == 0){
			if(a == 0){
				for(int i = 1;i <= c + 1;i++)printf("1");
				printf("\n");
				continue;
			}
			else{
				for(int i = 1;i <= a + 1;i++)printf("0");
				printf("\n");
				continue;
			}
		}
		else{
			for(int i = 1;i <= a + 1;i++)printf("0");
			for(int i = 1;i <= c + 1;i++)printf("1");
			for(int i = 1;i < b;i++){
				if(term == 1)printf("0");
				else printf("1");
				term = -term;
			}
			printf("\n");
		}	
	} 
	return 0;
}

G - Special Permutation

第一次尝试:Time limit exceeded on test 2
代码如下

int main(){
	int t,n,flag1,flag2; 
	scanf("%d",&t);
	while(t--){
		scanf("%d",&n); 
		for(int i = 1;i <= n;i++)arr[i] = i;
		
		do{
			flag1 = 1;
			flag2 = 0;
			for(int i = 1;i < n;i++)if(abs(arr[i + 1] - arr[i]) > 4 || abs(arr[i + 1] - arr[i]) < 2)flag1 = 0;
			if(flag1){
				flag2 = 1;
				for(int i = 1;i <= n;i++)printf("%d ",arr[i]);
				printf("\n");
				break;
			}
		}while(next_permutation(arr + 1,arr + n + 1));
		if(!flag2)printf("-1\n");
	} 
	return 0;
}

了解了构造法

第二次尝试:Accepted
代码如下:

#include<bits/stdc++.h>
using namespace std;
const int N = 8000 + 5;
int arr[N]; 
int main(){
	int t,n; 
	scanf("%d",&t);
	while(t--){
		int term;
		
		scanf("%d",&n); 
		//for(int i = 1;i <= n;i++)arr[i] = i;
		
		if(n < 4){
			printf("-1\n");
			continue;
		}
		else if(n % 2 == 1){
			term = 1;
			for(int i = 1;i <= (n + 1) / 2;i++)arr[i] = i * 2 - 1;
			for(int i = n;i >= (n + 3) / 2;i--)arr[i] = 2 * term,term++;
			swap(arr[(n + 3) / 2],arr[(n + 5) / 2]);
		}
		else{
			term = n / 2;
			for(int i = 1;i <= n / 2;i++)arr[i] = 2 * term - 1,term--;
			for(int i = n / 2 + 1;i <= n;i++)arr[i] = 2 * (i - n / 2);
			swap(arr[n / 2 + 1],arr[n / 2 + 2]);
		}
		if(n >= 4)for(int i = 1;i <= n;i++)printf("%d ",arr[i]);
		printf("\n");
	} 
	return 0;//过啦!!!! 
}

第一次完整地完成了一次CF!!!