Codeforces Round 886 (Div. 4)补题

as_sun

已于 2024-02-14 20:52:00 修改

阅读量996

点赞数 12

文章标签：算法 c++ 开发语言

于 2024-02-10 19:17:43 首次发布

本文链接：https://blog.csdn.net/m0_74120503/article/details/136085446

版权

文章概述了四道Codeforces编程题目，涉及排序、数组操作、寻找符合条件的元素、数据结构如数组和链表的应用，以及如何通过逻辑和算法解决不同类型的题目，如最大值查找和二分查找。

摘要由CSDN通过智能技术生成

To My Critics（Problem - A - Codeforces）

题目大意：现有一个三位数，问能否从中抽取两个数使得和大于等于10.

思路：排个序，取大的两个即可。

#include<bits/stdc++.h>
using namespace std;
int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		int a[4];
		for(int i=0;i<3;i++) scanf("%d",&a[i]);
		sort(a,a+3);
		if(a[1]+a[2]>=10) printf("YES\n");
		else printf("NO\n");
	}
}

Ten Words of Wisdom（Problem - B - Codeforces）

题目大意：现有n个回答，每个回答含的字数是a[i],回答质量为b[i],我们要求出所有长度不超过10的的回答中质量最高的回答。输出回答者的下标。

思路：也很简单，遍历判一下字数，字数符合要求的就判断一下是否需要更新即可。

#include<bits/stdc++.h>
using namespace std;
char s[10][10];
int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		for(int i=0;i<8;i++) scanf("%s",s[i]);
		string a="";
		for(int i=0;i<8;i++)
		{
			for(int j=0;j<8;j++)
			{
				if(s[j][i]!='.') a += s[j][i];
			}
		}
		cout<<a<<endl;
	}
}

Balanced Round（Problem - D - Codeforces）

题目大意：现在有一个数组，我们可以从中删除任何数量的问题，然后按照任何顺序重排剩下的a[]，最后要使得任何两个数之间的差值不超过k，问最少需要删除多少个元素。

思路：我们可以先重排，然后计算出两个数之间的差值，因为牵一发而动全身，所以我们需要找到差值中最长的一段符合要求的长度，然后加1，就是我们保留下来的数，然后剩下的都是要删除的。

#include<bits/stdc++.h>
using namespace std;
int a[200010];
int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		int n,k;
		scanf("%d%d",&n,&k);
		for(int i=1;i<=n;i++) scanf("%d",&a[i]);
		sort(a+1,a+1+n);
		int c=0,mx=0;
		for(int i=1;i<n;i++)
		{
			if(abs(a[i]-a[i+1])<=k) c++;
			else
			{
				mx=max(mx,c);
				c=0;
			}
		}
		mx=max(mx,c);
		printf("%d\n",n-mx-1);
	}
}

Cardboard for Pictures（Problem - E - Codeforces）

题目大意：现有n个边长为s[i]的正方形照片，我们要把它粘在一个正方形纸板上，使得每张照片与边界距离为w，总共用了面积为c的纸板，求出w的值。

思路：这道题显然可以二分来实现。二分w，判断是否合适。

#include<bits/stdc++.h>
using namespace std;
#define int long long
int n,c;
int a[200010];
int check(int mid)
{
	int ans=0;
	for(int i=1;i<=n;i++) 
	{
		ans += (a[i]+2*mid)*(a[i]+2*mid);
		if(ans>c) return 0;
	}
	return 1;
}
signed main()
{
	int t;
	scanf("%lld",&t);
	while(t--)
	{
		scanf("%lld%lld",&n,&c);
		for(int i=1;i<=n;i++) scanf("%lld",&a[i]);
		int l=0,r=1e9;
		while(l<r)
		{
			int mid=(l+r+1)/2;
			if(check(mid)) l=mid;
			else r=mid-1;
		}
		printf("%lld\n",l);
	}
}

We Were Both Children（Problem - F - Codeforces）

题目大意：有n只青蛙，它们每次可以跳跃的长度为a[i],起初它们都在0点，小m和小s要捕捉它们，但是只能在1-n之间的某个点上设置陷阱，问最多能捉住多少只青蛙。

思路：显然是找出一个若干个数的公倍数，同时使这若干个数尽可能地多。我们可以先用map统计每个数的个数，有个很显然的事情，在当前这个数的所有倍数位置放置陷阱都可以捕捉到跳跃长度为这个值的青蛙，那么我们就可以预处理所有位置能捕捉的青蛙数量。这里用到个一个logn找所有倍数的方法。

#include<bits/stdc++.h>
using namespace std;
int st[200010];
int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		int n;
		scanf("%d",&n);
		map<int,int>mp;
		for(int i=1;i<=n;i++)
		{
			int x;
			scanf("%d",&x);
			mp[x]++;
			st[i]=0;
		}
		for(auto it:mp)
		{
			int v=it.first,c=it.second;
			for(int i=v;i<=n;i+=v) st[i]+=c;
		}
		int mx=0;
		for(int i=1;i<=n;i++) mx=max(mx,st[i]);
		printf("%d\n",mx);
	}
}

The Morning Star（Problem - G - Codeforces）

题目大意：现有一个指南针，只能指向八个方向，现在坐标轴上有一些点，我们将指南针放在一个点上，如果它能指向另一个点的话，它就不会坏。我们要找出有多少点对使它不会坏。(1,2)和(2,1)视为两个点对。

思路：我们来找一下规律，首先规定当前点的坐标为(x,y),它能指向的点(x,k)、(k,y)、(k,x+y-k)、(k,y-x-k),所以我们可以记录每一个x对应了多少点，每一个y对应了多少点，每一个x+y对应多少点，每一个y-x对应了多少点，然后遍历所有点就可以实现。

#include<bits/stdc++.h>
using namespace std;
#define int long long
pair<int,int>q[200010];
signed main()
{
	int t;
	scanf("%lld",&t);
	while(t--)
	{
		int n;
		scanf("%lld",&n);
		map<int,int>mp1,mp2,mp3,mp4;
		for(int i=1;i<=n;i++)
		{
			int x,y;
			scanf("%lld%lld",&x,&y);
			q[i]={x,y};
			mp1[x]++;
			mp2[y]++;
			mp3[x+y]++;
			mp4[y-x]++;
		}
		int ans=0;
		for(int i=1;i<=n;i++)
		{
			int x=q[i].first,y=q[i].second;
			ans += (mp1[x]-1)+(mp2[y]-1)+(mp3[x+y]-1)+(mp4[y-x]-1);
		}
		printf("%lld\n",ans);
	}
}

The Third Letter（Problem - H - Codeforces）

题目大意：现有n个士兵，m个限制，和一个无限长的数轴，每个限制都由三个数组成a,b,d，如果d大于0，那么a在b前面，如果d小于0，那么a在b后面，一个点可以有多个士兵，而且需要满足所有的限定。

思路：很显然如果我们确定某个士兵的位置后，剩下的一部分士兵可以由此确定，那么与它有关系的士兵是哪些呢？显然我们可以通过将将有关系的边连起来进而实现，那么连好后应该可以得到若干的连通块，我们将每一个连通块内的士兵的位置确定好，最后检查一遍是否符合m条规则即可。至于这个建边怎么建呢，我们可以在d为正的时候建一条从a指向b的边，在d为负的时候建一条从b指向a的边。其实具体位置是否会冲突无所谓，我们只要保证不违反m条规则即可。

这里还有一点要注意，因为我们为了避免dfs时死循环，会对访问过的点进行标记，但是如果我们只建立单向的边，就会在5->4的时候出错，因为dfs(4)的时候已经将4标记过了，所以在访问5的时候会直接将4跳过，那么它们之间的关系就不会被表示出来，但是如果我们建立双向边就不会出现这个问题了，另外还有一点要注意，边权是很大的，所以有爆int的可能，我们需要用long long来处理。

#include<bits/stdc++.h>
using namespace std;
#define int long long
struct edge
{
	int a,b,d;
}ed[200010];
int h[200010],e[400010],ne[400010],w[400010],idx;
void add(int a,int b,int d)
{
	w[idx]=d,e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
int st[200010],v[200010];
void dfs(int u)
{
	st[u]=1;
	for(int i=h[u];i!=-1;i=ne[i])
	{
		int j=e[i];
		if(st[j]) continue;
		v[j]=v[u]+w[i];
		dfs(j);
	}
}
signed main()
{
	int t;
	scanf("%lld",&t);
	while(t--)
	{
		int n,m;
		scanf("%lld%lld",&n,&m);
		for(int i=1;i<=n;i++)
		{
			st[i]=0,v[i]=0,h[i]=-1;
		}
		idx=0;
		for(int i=1;i<=m;i++)
		{
			int a,b,d;
			scanf("%lld%lld%lld",&a,&b,&d);
			ed[i]={a,b,d};
			add(a,b,d);
			add(b,a,-d);	
		}
		for(int i=1;i<=n;i++)
		{
			if(!st[i]) dfs(i);
		}
		int flag=1;
		for(int i=1;i<=m;i++)
		{
			int a=ed[i].a,b=ed[i].b,c=ed[i].d;
			if(v[a]+c!=v[b])
			{
				flag=0;
				break;
			}
		}
		if(flag) printf("YES\n");
		else printf("NO\n");
	}
}

结语：愿新的一年所得皆所愿，在自己的领域成为闪闪发光的人！