Codeforces Round 916 (Div. 3)补题

最新推荐文章于 2024-06-12 10:00:23 发布

as_sun

最新推荐文章于 2024-06-12 10:00:23 发布

阅读量923

点赞数 21

分类专栏： codeforces题解文章标签：算法

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

版权

codeforces题解专栏收录该内容

46 篇文章 1 订阅

订阅专栏

Problemsolving Log（Problem - A - Codeforces）

题目大意：玩家可以在1分钟内解决A，2分钟内解决B，...。现有一个日志，可以知道玩家每分钟在思考哪个题，据此判断玩家总共解出几道题。

思路：实际上只用统计玩家对于每道题花费了多长时间，是否符合规定的解题时间即可。

#include<bits/stdc++.h>
using namespace std;
int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		int n;
		map<char,int>mp;
		string s;
		cin>>n>>s;
		for(int i=0;i<s.size();i++)
		{
			mp[s[i]]++;
		}
		int flag=0;
		for(auto it:mp)
		{
			char c=it.first;
			int k=it.second;
			if(k>=(c-'A'+1)) 
			{
				flag++;
			}
		}
		printf("%d\n",flag); 
	}
}

Preparing for the Contest（Problem - B - Codeforces）

题目大意：用数字表示题目的难度系数，数字大的题目更难，玩家每解决一个比前一个题目难的题目就会兴奋一次，现有n个题目，玩家总共兴奋了k次，给出一个合适的序列，表示解决题目的顺序。

思路：我们先将数字倒序排列，然后根据兴奋次数，将前k+1个数字逆转即可。

#include<bits/stdc++.h>
using namespace std;
int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		int n,k;
		scanf("%d%d",&n,&k);
		vector<int>a(n);
		for(int i=0;i<n;i++)a[i]=n-i;
		reverse(a.begin(),a.begin()+k+1);
		for(int i=0;i<n;i++) printf("%d ",a[i]);
		printf("\n");
	}
}

Quests（Problem - C - Codeforces）

题目大意：现有n个题目，已知对于第i个题目第一次做出来的收获是a[i],第二次及以后每次做出来的收获是b[i]，想要做第i个题目，必须保证前i-1个题目全部都解决掉，现在可以做k个题目，问最大收获是多少。

思路：我们从头开始假设每次遍历到的题目做完就不做了，然后剩下的次数都用来做当前可以做的题目范围内b[i]最大的题目，这样遍历一遍，找出最大值。

#include<bits/stdc++.h>
using namespace std;
int a[200010],b[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]);
		for(int i=1;i<=n;i++) scanf("%d",&b[i]);
		int mx=0,t=0;
		long long sum=0,ans=0;
		for(int i=1;i<=n;i++)
		{
			mx=max(mx,b[i]);
			sum+=a[i];
			t++;
			ans = max(ans,sum+(k-t)*mx);
			if(t==k) break;
		}
		printf("%lld\n",ans);
	}
}

Three Activities（Problem - D - Codeforces）

题目大意：现有三个活动，我们可知第i天做第1个活动有a[i]个人陪同，做第2个活动有b[i]个人陪同，做第3个活动有c[i]个人陪同，现要求每天只能做一项活动，要求选3天x,y,z，最后使ax+by+cz最大，输出最大值。

思路：这道题有两个量，同一时间只能进行一个活动，一个点是每个活动只进行一次。我们的解决办法是dfs来搜索。实际上再抽象一点就是讨论出决定每个活动的顺序，因为活动与活动之间的天数选择会相互影响，那么我们就指定选择顺序，然后去找在这个顺序下能得到的最大值。另外要注意，dfs的状态一定要清干净。

#include<bits/stdc++.h>
using namespace std;
int vis[200010],st[10];
int ans,flag,n,mx;	
vector<pair<int,int>>p[4];
void dfs(int k)
{
	st[k]=1;
	int v,d,i;
	for(i=0;i<n;i++)
	{
		v=p[k][i].first,d=p[k][i].second;
		if(!vis[d])
		{
			vis[d]=1;
			ans += v;
			flag +=k;
			break;
		}
	}
	if(flag==6)
	{
		
		mx=max(mx,ans);
		//清状态
		vis[d]=0;
		ans-=v;
		flag-=k;
		st[k]=0;
		return;
	}
	for(i=1;i<=3;i++)
	{
		if(!st[i]) 
		{
			dfs(i);	
		}
	}
	//清状态
	vis[d]=0;
	flag-=k;
	ans-=v;
	st[k]=0;
}
int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d",&n);
		mx=0;
		int r;
		for(int i=1;i<=n;i++) cin>>r,p[1].push_back({r,i}),vis[i]=0;
		for(int i=1;i<=n;i++) cin>>r,p[2].push_back({r,i});
		for(int i=1;i<=n;i++) cin>>r,p[3].push_back({r,i});
		sort(p[1].begin(),p[1].end());
		reverse(p[1].begin(),p[1].end());
		sort(p[2].begin(),p[2].end());
		reverse(p[2].begin(),p[2].end());
		sort(p[3].begin(),p[3].end());
		reverse(p[3].begin(),p[3].end());
		for(int i=1;i<=3;i++)
		{
			for(int i=1;i<=n;i++) vis[i]=0;
			st[1]=st[2]=st[3]=0;
			ans=0,flag=0;
			dfs(i);
		}
		printf("%d\n",mx);
		p[1].clear();
		p[2].clear();
		p[3].clear();
	}
}

Game with Marbles (Easy Version)（Problem - E1 - Codeforces）

题目大意：现在有n种求，对于A和B，她们手中每个球分别有a[i]和b[i]个，现在进行一个游戏，A先开始，选择一种球，将手中的这种球扔掉一个，同时B需要扔掉手中所有的此类球，最后求出所有种类球a[i]-b[i]的和。A想使结果更大，B想使结果更小，问两人都采取最佳策略，最后的结果是多少。（easy veesion：n<=6）

思路：博弈论问题，现在就是要找最优策略，我们先求出原来每种球的y=a[i]-b[i]的值，然后求出A对每种球操作后得到的值ga[i]以及前后的差值ca[i]=ga[i]-y,以及b对每种球操作后的值gb[i]以及前后差值cb[i]=gb[i]-y,A肯定要选择ca[i]大同时cb[i]小的（cb[i]一般为负，操作后gb[i]小于等于0）的进行操作，B肯定选择cb[i]小，ca[i]大的进行操作,难免会出现相等的情况，那么对于这两种情况还要讨论两种不同的排序方式，太过麻烦，我们不如直接以ca[i]-cb[i]作为标准进行排序，直接就可以得出结果。

#include<bits/stdc++.h>
using namespace std;
#define int long long
int a[200010],b[200010];
struct zb
{
	int ca,cb,ga,gb,y;
}c[200010];
bool cmp(zb x,zb y)
{
	return x.y>y.y;
}
signed main()
{
	int t;
	scanf("%lld",&t);
	while(t--)
	{
		int n;
		scanf("%lld",&n);
		for(int i=1;i<=n;i++) scanf("%lld",&a[i]);
		for(int i=1;i<=n;i++) scanf("%lld",&b[i]);
		for(int i=1;i<=n;i++)
		{
			int y=a[i]-b[i];
			int ca=(a[i]-1)-y;
			int cb=(1-b[i])-y;
			int ga=a[i]-1,gb=1-b[i];
			int dis=ca-cb;
			c[i]={ca,cb,ga,gb,dis};
		}
		sort(c+1,c+1+n,cmp);
		int sum=0;
		for(int i=1;i<=n;i++)
		{
			int d;
			if(i%2) 
			{
				sum += c[i].ga;
			}
			else 
			{
				sum += c[i].gb;
			}
		}
		printf("%lld\n",sum);
	}
}

Game with Marbles (Hard Version)（Problem - E2 - Codeforces）

题目大意：跟上一个其实差不多，只是数据范围扩大了而已。

思路：我们上面讨论的策略实际上已经很完备了，那么就没什么说的了，直接把数据范围扩大即可。这种题目最重要的就是找出最优策略，每个人都会采取当前局势下，对自己利益最大化的方式进行操作，我们要找出策略，并尽量简化讨论，将两者操作的共同点找出来。

#include<bits/stdc++.h>
using namespace std;
#define int long long
int a[200010],b[200010];
struct zb
{
	int ca,cb,ga,gb,y;
}c[200010];
bool cmp(zb x,zb y)
{
	return x.y>y.y;
}
signed main()
{
	int t;
	scanf("%lld",&t);
	while(t--)
	{
		int n;
		scanf("%lld",&n);
		for(int i=1;i<=n;i++) scanf("%lld",&a[i]);
		for(int i=1;i<=n;i++) scanf("%lld",&b[i]);
		for(int i=1;i<=n;i++)
		{
			int y=a[i]-b[i];
			int ca=(a[i]-1)-y;
			int cb=(1-b[i])-y;
			int ga=a[i]-1,gb=1-b[i];
			int dis=ca-cb;
			c[i]={ca,cb,ga,gb,dis};
		}
		sort(c+1,c+1+n,cmp);
		int sum=0;
		for(int i=1;i<=n;i++)
		{
			int d;
			if(i%2) 
			{
				sum += c[i].ga;
			}
			else 
			{
				sum += c[i].gb;
			}
		}
		printf("%lld\n",sum);
	}
}

Programming Competition（Problem - F - Codeforces）

题目大意：有一个公司，1为公司负责人，每个员工有个直属的上级，同时她直属上级的上级也是她的上级，现在要对员工进行分组，两人一组，每个员工不能和她的上级分在一组里面，问最多能分多少组。

思路：我们可以发现，抛开第一个点，可以得到若干个连通块，虽然连通块内部每个点可以和它的非领导节点相连，但是显然连通块之间相连更加无可争议，也更好处理，因为不用考虑点与点之间的关系。这时候我们就遇到了第一个点，一个点的子树数量的统计，这个实际上用深搜的思路就可以实现。然后我们就要考虑，联通块之间相互匹配，会不会有剩下的所有点都在一个连通块内部，这种情况也不能随便处理。那么怎么样会出现这种情况呢?显然就是最多的那棵子树的数量多余其他所有的点的和，那么其他所有的点都耗尽了，这棵树中还是有点会被剩下，那么对于被剩下的点，我们怎么处理呢？实际上我们可以记录它其中有多少点已经匹配了，再去找它的子连通块进行匹配，如此递归下去，就能解决。另外为了尽可能地减少递归，我们假设已经配对地点全在最大子树中，这样就可以减少最大子树的点数，因为只有最大的子树的点数可能超过总数的一半，所以不用担心最大子树的点数减掉已经配对的点后，变成不是最大的，反正剩下的点数也少于总点数的一半，并没有什么影响。而且我们讨论一下最大点数不减去k与其他点数和进行比较的情况会发现不会对比较产生什么影响。原最大的小于其他的和，那么大家相互之间配一配，k均摊开即可（减k后仍然是小于的）；若等于，也是可以相互配，把k均摊开（减k后小于）；若大于，减后要么可以均摊要么就仍大于还是得进行递归，所以没什么影响。

#include<bits/stdc++.h>
using namespace std;
int h[200010],ne[200010],e[200010],z[200010],vis[200010],idx;
void add(int a,int b)
{
	e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}
void zs(int k)
{
	z[k]=1;
	for(int i=h[k];i!=-1;i=ne[i])
	{
		int j=e[i];
		if(!vis[j])//这里其实可以不加判断，因为有向图是不会倒回去的
		{	
			zs(j);
			z[k] += z[j];
		}
	}
}
int tj(int v,int k)//k是以v为根的子树中已经配对的点的数量
{
	int all=0,mx=-1;
	for(int i=h[v];i!=-1;i=ne[i])
	{
		int j=e[i];
		all += z[j];
		if(mx==-1||z[mx]<z[j]) mx=j;
	}
	if(all==0) return 0;
	if(z[mx]-k<=all-z[mx]) return (all-k)/2;//假设已经配对的点，全部都在最大子树内，因为我们实际上想让最大子树小于总数的一半
	int add=all-z[mx];
	return add+tj(mx,max(0,k+add-1));
	/*根节点是不会被统计进all里面的，所以我们这里要把根节点刨掉，从高往低配对，根节点肯定被配对了，所以实际被统计的部分的
	配对的点数是要减1的，当然要防止出现负数的情况，也就是k和add都是0，这种情况出现在根节点只有一个出度时*/	
}
int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		int n;
		scanf("%d",&n);
		idx=0;
		for(int i=1;i<=n;i++) h[i]=-1,vis[i]=0;
		for(int i=2;i<=n;i++)
		{
			int x;
			scanf("%d",&x);
			add(x,i);
		}
		zs(1);
		cout<<tj(1,0)<<endl;
	}
}

as_sun

关注

21
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
Codeforces Round 916 (Div. 3)补题

另外为了尽可能地减少递归，我们假设已经配对地点全在最大子树中，这样就可以减少最大子树的点数，因为只有最大的子树的点数可能超过总数的一半，所以不用担心最大子树的点数减掉已经配对的点后，变成不是最大的，反正剩下的点数也少于总点数的一半，并没有什么影响。题目大意：现在有n种求，对于A和B，她们手中每个球分别有a[i]和b[i]个，现在进行一个游戏，A先开始，选择一种球，将手中的这种球扔掉一个，同时B需要扔掉手中所有的此类球，最后求出所有种类球a[i]-b[i]的和。另外要注意，dfs的状态一定要清干净。
复制链接

扫一扫