CF609

最新推荐文章于 2022-07-13 22:34:53 发布
最新推荐文章于 2022-07-13 22:34:53 发布
阅读量140 收藏
点赞数
分类专栏： 比赛
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenboshuai/article/details/108474449
版权

CF edu3

A. USB Flash Drives

思路

贪心， 用最大的U盘装， 如果装不下就用下一个继续， 统计答案即可。

代码

#include<bits/stdc++.h>

using namespace std;

int n, m;
int a[110];
bool cmp(int a, int b)
{
	return a > b;
}
int main()
{
	cin >> n >> m;
	for(int i = 1; i <= n; i++)
	{
		cin >> a[i];
	}
	sort(a+1, a+n+1, cmp);
	for(int i = 1; i <= n; i++)
	{
		if(m <= a[i])
		{
			cout << i << endl;
			break;
		}
		m -= a[i];
	}
	return 0;
}

大佬用的vector并统计前缀和， 细节看代码


#pragma GCC optimize("O3")

#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include <iostream>
#include <vector>
#include <algorithm>
#include <stack>
#include <string>
#include <assert.h>
#include <queue>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <random>
#include <cmath>

#define ll long long
#define ld long double
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define int long long
using namespace std;

const int INF = 2e9;
const int MOD = 1e9 + 7;
const int MB = 20;

void solve() {
	int n, m;
	cin >> n >> m;
	vector<int> a(n);
	for (int i = 0; i < n; i++) {
		cin >> a[i];
	}
	sort(a.rbegin(), a.rend());
	int summ = 0;
	for (int i = 0; i < n; i++) {
		if (summ + a[i] >= m) {
			cout << i + 1;
			return;
		}
		summ += a[i];
	}
}

signed main() {
	/*
	freopen("search.in", "r", stdin);
	freopen("search.out", "w", stdout);
	*/
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);
	cout.precision(12);
	solve();
}

B. The Best Gift

思路

组合计数题， 我们可以看到一本书可以和其他的书组合， 当且仅当这一本书与它的类型不同， 那么这样的书共有：n本书减去当前这本类型的书的数量。这样我们可以把每种类型里的每本书都这样枚举一遍， 在把答案加起来即可。
注意， 这样的话对于两本不同类型的书（i，j）， 其在i被枚举了一次， 在j被枚举了一次， 重复记了两次， 应减去一次。

代码

#include<bits/stdc++.h>

using namespace std;

int n, m;
int cnt[20];
int a[200010];
long long ans = 0;
int main()
{
	cin >> n >> m;
	for(int i = 1; i <= n; i++)
	{
		cin >> a[i];
		cnt[a[i]]++;
	}
	/*for(int i = 1; i <= m; i++)
	{
		cout << i << ": " << cnt[i] << endl;
	}*/
	for(int i = 1; i <= n; i++)
	{
		ans = ans + (n - cnt[a[i]]);
	//	cout << a[i] << " " << cnt[a[i]] << " ";
	//	cout << ans << endl;
	}
	//cout << ans << endl;
	ans = ans / 2;
	cout << ans << endl;
	return 0;
}

大佬直接把所有种类相同的数一次算， 并且每次及时更新， 这样就不用考虑重复的问题了


#pragma GCC optimize("O3")

#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include <iostream>
#include <vector>
#include <algorithm>
#include <stack>
#include <string>
#include <assert.h>
#include <queue>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <random>
#include <cmath>

#define ll long long
#define ld long double
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define int long long
using namespace std;

const int INF = 2e9;
const int MOD = 1e9 + 7;
const int MB = 20;

void solve() {
	int n, m;
	cin >> n >> m;
	vector<int> a(m);
	for (int i = 0; i < n; i++) {
		int x;
		cin >> x;
		a[x - 1]++;
	}
	int ans = 0;
	int sum = n;
	for (int i = 0; i < m; i++) {
		if (!a[i]) continue;
		ans += a[i] * (sum - a[i]);
		sum -= a[i];
	}
	cout << ans;
}

signed main() {
	/*
	freopen("search.in", "r", stdin);
	freopen("search.out", "w", stdout);
	*/
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);
	cout.precision(12);
	solve();
}

C. Load Balancing

思路

最优策略就是把所有数都变成他们的平均数，如果为小数， 那么就有总和除以n个平均数， 剩下的都是平均数加一。遇到这种情况的话， 我们可以给原数组排一下序, 这样就能保证他们到达平均数的距离最小了。
统计的话其实你就统计比要变成目标小的数变成目标的和， 这样比目标大的数也会相应的变化。

#include<bits/stdc++.h>

using namespace std;

int n;
int a[100010];
int sum;
int main()
{
	cin >> n;
	for(int i = 1; i <= n; i++)
	{
		cin >> a[i];	
		sum += a[i];
	}
	if(sum % n == 0)
	{
		int cnt = sum / n;
		int pos = 0;
		int impos = 0;
		for(int i = 1; i <= n; i++)
		{
			if(a[i] < cnt)
			{
				pos += cnt - a[i];
			}
			else if(a[i] > cnt)
			{
				impos += a[i] - cnt;
			}
			
		}
		cout << min(pos, impos) + abs(pos - impos) << endl;
	}
	else
	{
		int x = sum / n;
		int y = x+1;
		int cntb = sum % n;
		int cnta = n - cntb;
		int ans = 0;
		sort(a+1, a+n+1);
		int pos = 0;
		int impos = 0;
		for(int i = 1; i <= cnta; i++)
		{
			if(a[i] < x)
			{
				pos += x - a[i];
			}
			else if(a[i] > x)
			{
				impos += a[i] - x;
			}
		}
		for(int i = cnta+1; i <= n; i++)
		{
			if(a[i] < y)
			{
				pos += y - a[i];
			}
			else if(a[i] > y)
			{
				impos += a[i] - y;
			}
		}
		cout << min(pos, impos) + abs(pos - impos) << endl;
	}
	return 0;
}

大佬直接硬算平均数， 剩下的余数就是变成比平均数+1的数的个数， 我们可以让比他大的数变， 这样的话距离就会比原来变成平均数少1.


#pragma GCC optimize("O3")

#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include <iostream>
#include <vector>
#include <algorithm>
#include <stack>
#include <string>
#include <assert.h>
#include <queue>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <random>
#include <cmath>

#define ll long long
#define ld long double
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define int long long
using namespace std;

const int INF = 2e9;
const int MOD = 1e9 + 7;
const int MB = 20;

void solve() {
	int n;
	cin >> n;
	vector<int> a(n);
	int sum = 0;
	for (int i = 0; i < n; i++) {
		cin >> a[i];
		sum += a[i];
	}
	int x = sum / n;
	int count = sum % n;
	sort(a.rbegin(), a.rend());
	int ans = 0;
	for (int i = 0; i < n; i++) {
		if (a[i] > x) {
			if (count > 0) ans += (a[i] - x - 1);
			else ans += (a[i] - x);
			count--;
		}
	}
	cout << ans;
}

signed main() {
	/*
	freopen("search.in", "r", stdin);
	freopen("search.out", "w", stdout);
	*/
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);
	cout.precision(12);
	solve();
}

D. Gadgets for dollars and pounds

思路

显然， 如果天数越多， 我们买完的可能性就越大， 所以是满足单调的。 我们可以二分，二分能否在k天买完。
这样的话， 我们可以找前k天最小的汇率， 然后把每个物品乘以当天汇率转换成卢布， 并按照价钱排序， 只需判断用s卢布是否能买完前k个物品的价钱和即可。

代码

#include<bits/stdc++.h>

using namespace std;

int n, m, k ,s;
int a[200010];
int b[200010];
typedef long long ll;
struct object
{
	int type;
	int v;
}ob[200010];
struct haha
{
	long long v = 0;
	int id;
}now[200010];
bool cmp(haha x, haha y)
{
	return x.v < y.v;
}
int pnow;
int ansa, ansb;
bool check(int day)
{
	pnow = 0;
	 ansa = 0;
	 ansb = 0;
	int min_a = 1000010, min_b = 1000010;
	for(int i = 1; i <= day; i++)
	{
		if(min_a > a[i])
		ansa = i;
		min_a = min(min_a, a[i]);
		if(min_b > b[i])
		ansb = i;
		min_b = min(min_b, b[i]);
	}
	//cout << min_a << " " << min_b << endl;
	for(int i = 1; i <= m; i++)
	{
		if(ob[i].type == 1)
		{
			now[++pnow].v = (ll)ob[i].v * min_a;
			now[pnow].id = i;
		}
		else
		{
			now[++pnow].v = (ll)ob[i].v * min_b;
			now[pnow].id = i;
		}
	}
	sort(now+1, now+pnow+1, cmp);
	/*for(int i = 1; i <= pnow; i++)
	{
		cout << now[i] << " ";
	}
	cout << endl;*/
	long long sum = 0;
	for(int i = 1; i <= k; i++)
	{
		sum += now[i].v;
	}
	if(sum <= s)
	{
		return true;
	}
	else
	{
		return false;
	}
}
int main()
{
	cin >> n >> m >> k >> s;
	for(int i = 1; i <= n; i++)
	{
		cin >> a[i];
	}
	for(int i = 1; i <= n; i++)
	{
		cin >> b[i];
	}
	for(int i = 1; i <= m; i++)
	{
		cin >> ob[i].type >> ob[i].v;
	}
	int l = 1;
	int r = n;
	int ans = -1;
	while(l <= r)
	{
		int mid = (l + r) >> 1;
		//cout << l << " " << mid << " " << r << endl; 
		if(check(mid))
		{
			ans = mid;
			r = mid - 1;
		}
		else
		{
			l = mid + 1;
		}
	}
	cout << ans << endl;
	if(ans == -1)
	{
		return 0;
	}
	check(ans);
	for(int i = 1; i <= k; i++)
	{
		int p = now[i].id;
		if(ob[p].type == 1)
		{
			cout << p << " " << ansa << endl;
		}
		else
		{
			cout << p << " " << ansb << endl;
		}
	}
	return 0;
}

大佬思路相同， 只不过开了个pair方便输出罢了


#pragma GCC optimize("O3")

#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include <iostream>
#include <vector>
#include <algorithm>
#include <stack>
#include <string>
#include <assert.h>
#include <queue>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <random>
#include <cmath>

#define ll long long
#define ld long double
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define int long long
using namespace std;

const int INF = 2e9;
const int MOD = 1e9 + 7;
const int MB = 20;

bool check(int mid, vector<int>& a, vector<int>& b, vector<pair<int, int>>& c, int k, int s) {
	int mn1 = INF;
	int mn2 = INF;
	for (int i = 0; i <= mid; i++) mn1 = min(mn1, a[i]);
	for (int i = 0; i <= mid; i++) mn2 = min(mn2, b[i]);
	vector<int> w;
	for (int i = 0; i < c.size(); i++) {
		if (c[i].first == 1) w.pb(mn1 * c[i].second);
		else w.pb(mn2 * c[i].second);
	}
	sort(w.begin(), w.end());
	for (int i = 0; i < w.size(); i++) {
		if (w[i] > s) return false;
		s -= w[i];
		if (i + 1 == k) return true;
	}
}

void solve() {
	int n, m, k, s;
	cin >> n >> m >> k >> s;
	vector<int> a(n), b(n);
	for (int i = 0; i < n; i++) {
		cin >> a[i];
	}
	for (int i = 0; i < n; i++) {
		cin >> b[i];
	}

	vector<pair<int, int>> c(m);
	for (int i = 0; i < m; i++) {
		cin >> c[i].first >> c[i].second;
	}

	int l = -1;
	int r = n;
	while (r - l > 1) {
		int mid = (r + l) >> 1;
		if (check(mid, a, b, c, k, s)) r = mid;
		else l = mid;
	}
	if (r == n) {
		cout << -1;
		return;
	}
	
	int mn1 = INF;
	int mn2 = INF;
	int num1 = 0;
	int num2 = 0;
	for (int i = 0; i <= r; i++) {
		if (mn1 > a[i]) {
			mn1 = a[i];
			num1 = i + 1;
		}
	}
	for (int i = 0; i <= r; i++) {
		if (mn2 > b[i]) {
			mn2 = b[i];
			num2 = i + 1;
		}
	}

	vector<pair<int, pair<int, int>>> w;
	for (int i = 0; i < c.size(); i++) {
		if (c[i].first == 1) w.pb({ mn1 * c[i].second, {i + 1, 1} });
		else w.pb({ mn2 * c[i].second, {i + 1, 2} });
	}
	sort(w.begin(), w.end());
	vector<pair<int, int>> ans;
	for (int i = 0; i < k; i++) {
		if (w[i].second.second == 1) {
			ans.pb({ w[i].second.first, num1 });
		}
		else {
			ans.pb({ w[i].second.first, num2 });
		}
	}

	cout << r + 1 << '\n';
	for (auto& p : ans) {
		cout << p.first << " " << p.second << '\n';
	}
}

signed main() {
	/*
	freopen("search.in", "r", stdin);
	freopen("search.out", "w", stdout);
	*/
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);
	cout.precision(12);
	solve();
}

E. Minimum spanning tree for each edge

这题我WA了， 但我知道思路
这个题和非严格最小生成树很像
首先，如果i这条边在最小生成树里面的话， 直接输出最小生成树的权值即可。
否则， 我们考虑这个边的端点u，v。如果我们想加入一条边， 那么必然要删去另一条边。（树只有n-1条边）
能不能乱删呢。

显然是不能的。
中间省略若干条边
中间省略若干条边
u
v
lca
root
uson
vson

如果我们断掉其中一条边而添边(u, v)， 那么显然 只能删u， v，lca这个环上得边，否则就会形成环。
那这么多边删哪条呢？因为要求最小， 所以删这个环上除(u,v)外最大的边即可。
实现：先用kruscal求出最小生成树， 在枚举每条非树边， 求他们的lca， 并维护一个点到它lca上路径的最大值 （倍增）。那么，答案就是原最小生成树减去u，v到lca的最大边并加上（u, v)即可。

来一发 题解

chenbo真shuai
关注
专栏目录
【AI】llama-fs的 安装与运行
突围
05-30 310
llama-fs
【MotionCap】The detected CUDA version (11.3) mismatches the version that was used to compile
最新发布
突围
06-28 195
MotionCap
CF 609F，线段树上二分 + set维护
weixin_30678821的博客
09-22 117
(｡･∀･)ﾉﾞ嗨大家好，sb我又回来切题了（因为不切大概就要弱死了） 题目大意：在数轴上给定n只青蛙，每只青蛙有一个舌头长度，每只青蛙能吃落在他右边不超过舌头长的蚊子，吃了蚊子蛇头能长长，多只青蛙能吃到则取最左边的一只。 解：原来我的想法是线段树维护区间最小值然后set维护一下看舌头伸长后能吃哪些蚊子。但是由于距离需要离散化，所以导致这个做法细节会非常爆炸。看了一下题解，非常巧妙，维护区间青...
CF609A USB Flash Drives
HybridCOW_HORSE的博客
07-13 226
⚜️我的更新时间会有所改变，每月篇，感谢各位长期以来的支持！ 💠💠💠💠💠💠💠💠💠💠💠💠💠💠💠💠💠💠💠💠💠
CF609E
jzh8178919的博客
12-01 136
传送门 主要就是最小生成树+增边删边 对于一棵树，增加任意一条边便会生成一个环，删去环内权值最大的一条边就是最优解。 #include<bits/stdc++.h> using namespace std; typedef long long ll; ll read(){ ll a=0,b=getchar(),c=1; while(!isdigit(b))c=b=='-'?-1:1...
CF620
chenboshuai的博客
09-15 275
比赛考到的知识点：数学、数字拆位、贪心、map运用， 暴力枚举、异或和、前缀思想、定序枚举
使用cf_nise_installer安装使用CloudFoundry笔记
restkuan的专栏
10-31 6082
在学习使用CloudFoundry过程中做的一些笔记，只做稍微整理。对CF不了解的可以看看热闹，对CF了解的希望对你有用。 这也是一个踩坑、添坑的过程，当然我也不能保证自己做的是完成正确，我也有可能挖坑给你，请牢记！ 由于各种原因，如公司规定、个人认知能力有限，说得不到位或者给你挖了坑，请谅解。 项目所在：https://github.com/yudai/cf_nise_installe
form窗口上放一个label,如何能找到这个label在哪个文件中使用
awulei的专栏
10-11 5120
欢迎大家前往 "腾讯云+社区" ，获取更多腾讯海量技术实践干货哦~ 本文由 "liuxuewen " 发表于 "云+社区专栏" 在本文中，我们将研究深度学习和机器学习之间的差异。我们将逐一了解它们，然后讨论他们在各个方面的不同之处。除了深度学习和机器学习的比较外，我们还将研究他们未来的趋势和走向。 http://baobao.baidu.com/article/b38f781a9b4c89b7f0...
回顾RHCE——DNS(bind)服务器
weixin_50570068的博客
12-08 748
DNS服务器 #一、DNS简单介绍 DNS系统 DNS服务器类型 #二、安装Bind服务程序及配置 安装Bind服务 配置文件解析 #三、解析实验 正向解析实验 反向解析实验 一、DNS介绍 DNS系统 DNS（Domain Name System，域名系统，是一个分层的分布式数据库能够使用户更方便的访问互联网，而不用去记住能够被机器直接读取的IP数串。通过主机名，最终得到该主机名对应的IP地址的过程叫做域名解析（或主机名解析）。 DNS服务器类型 ①主DNS服务器：数据修改 ②辅助DNS
洛谷 2 月月赛 I & 加油武汉
chenboshuai的博客
02-15 1618
加 油 武 汉！！！ E SIR 模型 题目描述 我们将这个模型简化一下，初始有感染者 I 人和易感者 S 人，对于每一天当前有 Ii个感染者，Si个易感者，Ri个恢复者，则每天会有 ⌈βSiIi⌉\lceil \beta S_iI_i \rceil⌈βSi​Ii​⌉人被感染（由易感者变成感染者），有⌈γIi⌉\lceil \gamma I_i \rceil⌈γIi​⌉ 人被治愈（由感染者变成恢复...
NOI Online 入门组
chenboshuai的博客
03-17 645
一共三道题， 三道我都不会， 入门组？？？？？？ 所谓的“入门组”题目 1. 文具订购 题目链接：普及难度 题目描述 小明的班上共有n元班费， 同学们准备集体用这些班费购买3种物品： 1.圆规， 每个7元 2.笔，每只4元 3.笔记本，每本3元 小明负责订购文具， 设圆规， 笔， 笔记本的订购数量分别为a, b, c, 他订购的原则依次 如下： 1.n元钱必须正好用光， 即7a+4b+3c=n7a...
NOI Online #2入门组
chenboshuai的博客
05-04 543
NOI Online #2入门组 A 未了 题目描述 由于触犯天神，Sisyphus 将要接受惩罚。 宙斯命令Sisyphus推一块儿巨石上长度为L的山坡。Sisyphus匀速向上推的速度为每年v的长度（由于是匀速， 故经过1/2年将能向上推v/2的长度）。然而， 宙斯并不希望Sisyphus太快到达山顶。宙斯可以施展n个魔法， 若他施展第i个魔法， 那么Sisphus第一次到达位置ai时， ...
CF622
chenboshuai的博客
09-15 529
比赛考到的知识点：数学， 数列， 规律、 模拟、数组运用， 指针、vector、推公式， 构造， 枚举输出、 树形dp、贪心、dfs遍历
CodeForces 1307 A-E
chenboshuai的博客
02-23 497
CF 1307 A-E A Cow and Haybles 题目链接 题目描述 有n个数， 每次可以选相邻的两个数i， j： 使得ai+1, aj-1, 问经过这样d次操作后， a1最大是多少。 题目思路 首先明白题意， 是任意的两个数+1， -1， 而且又要使得a1最大， 所以， 我们可以在这d次时间内， 尽量让a1 每次都加1， 那么相邻的a2-1, 那么如果a2 等于0了呢， 那就让a3...
【LGR-070】洛谷 3 月月赛 I & EE Round 1 Div.2
chenboshuai的博客
03-24 476
【LGR-070】洛谷 3 月月赛 I & EE Round 1 Div.2 A 苏联人 入门 题目描述 你在打EE Round 1， 发现第一题非常无聊， 于是你不打了， 去下国际象棋了。 结果你发现， 由于某种神秘力量的影响， 你的棋子只剩下若干黑色的战车， 若干黑色的主教， 和一只白色的国王了。 由于你很无聊， 所以你把一些棋子放在了8×88 \times 88×8的棋...
Mdoi R2 洛谷4月月赛I
chenboshuai的博客
04-19 428
Mdoi R2 洛谷4月月赛I A Car
洛谷1月月赛2 & CSGRound 3
chenboshuai的博客
01-31 411
简要题解
CF612
chenboshuai的博客
09-12 349
比赛考到的算法：暴力， 桶计数， map灵活运用， 栈的运用， 扫描线
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值