Codeforces Round #565 (Div. 3)_codeforces round 565 (div. 3)-优快云博客

本文介绍 CodeForces Div.3 的五道题目(A-E)的解题思路及代码实现，涵盖模拟、组合数学、贪心算法、图论等知识点，适合初学者训练思维和解题速度。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

div3题目一般都是思维题，算法比较少，用来训练思维和解题速度很合适

A题

模拟即可

#include <iostream>
using namespace std;
typedef long long ll;
int main(){
	int q;
	ll n;
	cin >> q;
	while(q--){
		cin >> n;
		int ans = 0;
		while(n != 1){
			if(n % 2 == 0) n /= 2;
			else if(n % 3 == 0) n = n / 3 * 2;
			else if(n % 5 == 0) n = n / 5 * 4;
			else{
				ans = -1;
				break;
			}
			ans++;
		}
		cout << ans << "\n";
	}
	return 0;
}

B题

将数组中的元素两两相加，得到的数替换原来的两个数，如此进行，问数组中最多能有多少3的倍数

题目刚拿到手里可能没什么思路，或许会跟着他模拟，但是转念一想，如果把模3为0、1、2的数都分开，0的是合法解，1和2的将他们两两结合，就又能凑出3，最后剩下单一的部分要么都是1，要么都是2，那么就看剩下全加一起能凑出多少个3

#include <iostream>
using namespace std;
typedef long long ll;
int main(){
	int q, x, y, z, t, n;
	int ans;
	cin >> q;
	while(q--){
		cin >> n;
		x = y = z = 0;
		for(int i=0;i<n;i++){
			cin >> t;
			if(t % 3 == 0) x++;
			else if(t % 3 == 1) y++;
			else z++;
		}
		int tmp = min(y, z);
		ans = x;
		ans += tmp;
		ans += (y - tmp) / 3;
		ans += (z - tmp) / 3;
		cout << ans << "\n";
	}
	return 0;
}

C题

先给我们一个数组4,8,15,16,23,42，紧接着输入一个数组，这个数组可以随意去掉若干元素，问在这个数组的子序列中（不能重复）能凑出若干个上面那个数组最少需要去掉多少个元素，也就是瓜分这个数组为若干个上面的数组。题意不好解释，具体参考原题

我的思路是，输入数组逐个元素读取，用一个map存储每一个元素的数量，比如如果是4，那么mp[4]++，要是读入一个8，那么mp[4]–，mp[8]++，如果mp[4]是0，那么说明这个8是多余的，需要去掉，以此类推，最后得到mp[42]的值就是能凑出子序列的个数，用元素总个数减去这个子序列中元素个数即为答案

#include <iostream>
#include <map>
using namespace std;
typedef long long ll;
map<int, int> mp;
int main(){
	int q, x, y, z, t, n;
	int ans;
	mp.clear();
	cin >> q;
	for(int i=0;i<q;i++){
		cin >> x;
		if(x == 4){
			mp[4]++;
		}else if(x == 8){
			if(mp[4] > 0){
				mp[4]--;
				mp[8]++;
			}
		}else if(x == 15){
			if(mp[8] > 0){
				mp[8]--;
				mp[15]++;
			}
		}else if(x == 16){
			if(mp[15] > 0){
				mp[15]--;
				mp[16]++;
			}
		}else if(x == 23){
			if(mp[16] > 0){
				mp[16]--;
				mp[23]++;
			}
		}else if(x == 42){
			if(mp[23] > 0){
				mp[23]--;
				mp[42]++;
			}
		}

	}
	ans = q - 6 * mp[42];
	cout << ans;	
	return 0;
}

D题

说有两个数组，一个叫a，另一个叫b，这两个数组长度是相同的，b由a演化而来，也就是先有a再有b，对于a中的每一个元素，有以下两种情况

是质数，设这个质数为a_i，那么从2开始，从小到大第a_i个质数就加入到b中
不是质数，那么这个合数的最大因数就加入到b中
现在将a和b中所有元素混在一起打乱，组成一个新的数组，现在给我们这个数组，复原a数组，先后顺序不影响答案

从最大数往最小数找，如果最大数是一个质数，那么这个质数一定在b中，质数下标在a中，因为质数的大小一定大于它的下标，以此类推；如果最大数是一个合数，那么这个数一定在a中，它的最大因子一定在b中，因为这个数已经最大，不可能成为比它小的数的因数，这样考虑问题就很简单了，我还是用map存储

#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
using namespace std;
typedef long long ll;
const int MAXN = 1e7 + 100;
map<int, int, greater<int> > mp;
map<int, int, greater<int> >::iterator it;
int p[MAXN];
int vis[MAXN];
int Prime(){
	int tot = 0;
	for(int i=2;i<=2750131;i++){
		if(!vis[i]) p[tot++] = i;
		for(int j=0;j<tot&&p[j]*i<=2750131;j++){
			vis[i*p[j]] = 1;
			if(i % p[j] == 0) break;
		}
	}
	return tot;
}
vector<int> ans;
int main(){
	int n, x;
	int tot = Prime();
	cin >> n;
	for(int i=0;i<2*n;i++){
		cin >> x;
		mp[x]++;
	}
	for(it=mp.begin();it!=mp.end();it++){
		while(it->second){
			it->second--;
			int pos = lower_bound(p, p + tot, it->first) - p;
			if(p[pos] == it->first){
//				ans.emplace_back(pos + 1);
				cout << pos + 1 << " ";
				mp[pos + 1]--;
			}else{
				for(int j=2;j*j<=it->first;j++){
					if(it->first % j == 0){
						cout << it->first << " ";
						mp[it->first / j] --;
						break;
					}
				}
			}
		}
	}
	return 0;
}

E题

给我们一个图，寻找这个图里面的关键点，使得这些关键点能够到达整个图，保证有解，要求关键点数量小于n/2向下取整，n表示顶点数

从1这个节点出发，根据其他节点到达它的最短距离可以将所有节点分成两部分，一部分是距离为奇数，另一部分是距离为偶数，显然，奇数节点一定能够到达偶数节点，偶数节点也能够到达奇数节点，而且这两部分节点至少有一部分的数量小于n/2，所以输出小的那一部分即可

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int INF = 0x3f3f3f3f;
vector<vector<int> > vs;
vector<int> dis;
void bfs(int u, int n){
	dis = vector<int> (n + 100, INF);
	dis[u] = 0;
	queue<int> q;
	q.push(u);
	while(!q.empty()){
		int s = q.front();
		q.pop();
		for(auto to : vs[s]){
			if(dis[to] == INF){
				dis[to] = dis[s] + 1;
				q.push(to);
			}
		}
	}
}
int main(){
	int t, n, m, u, v;
	cin >> t;
	while(t--){
		cin >> n >> m;
		vs = vector<vector<int> > (n + 100);
		for(int i=0;i<m;i++){
			cin >> u >> v;
			vs[u].emplace_back(v);
			vs[v].emplace_back(u);
		}
		bfs(1, n);
		vector<int> odd, even;
		for(int i=1;i<=n;i++){
			if(dis[i] & 1) odd.emplace_back(i);
			else even.push_back(i);
		}
		if(odd.size() > even.size()){
			cout << even.size() << "\n";
			for(auto to : even) cout << to << " ";
		}else {
			cout << odd.size() << "\n";
			for(auto to : odd) cout << to << " ";
		}
		cout << "\n";
	}
	return 0;
}