Codeforces Round #768 (Div. 2)

最新推荐文章于 2022-04-29 15:11:10 发布

snowy2002

最新推荐文章于 2022-04-29 15:11:10 发布

阅读量456

点赞数 2

分类专栏： # codeforces 文章标签： c++ 算法

本文链接：https://blog.csdn.net/NEUQ_snowy/article/details/122980178

版权

codeforces 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

A. Min Max Swap

题目大意：给定两个数列 $a$ , $b$ 长度均为n，每次可以交换 $a_i和b_i$ 求交换后两数列中的最大值的乘积的最小值。
有一个显而易见的结论，就是两个数列中一定有一个数列的最大值等于所有元素的最大值，那么我们就可以尽可能使另一个数列的最大值变小，我们不妨令b数列为最大值所在的数列，这样我们只需要使得a数列尽可能小，因此对于每一个 $i$ ,我们只需要将 $a_i=min(a_i,b_i)$ ， $b_i=max(a_i,b_i)$ 即可

    #include<iostream>
    #include<cstring>
    #include<cstdio>
    #include<algorithm>
    #define maxn 1000005
    using namespace std;
     
    int read()
    {
    	int x=1,res=0;
    	char c=getchar();
    	while(c<'0'||c>'9')
    	{
    		if(c=='-')
    		x=-1;
    		c=getchar();
    	}
    	while(c>='0'&&c<='9')
    	{
    		res=res*10+(c-'0');
    		c=getchar();
    	}
    	return res*x;
    }
    int t,n,a[maxn],b[maxn];
     
    int main()
    {
    	t=read();
    	while(t--)
    	{
    		n=read();int max1=0,max2=0;
    		for(int i=1;i<=n;i++)a[i]=read();
    		for(int i=1;i<=n;i++) b[i]=read();
    		for(int i=1;i<=n;i++)
    		{
    			if(a[i]>b[i]) swap(a[i],b[i]);
    			max1=max(max1,a[i]);
    			max2=max(max2,b[i]);
    		}
    		cout<<max1*max2<<endl;
    	}
    	return 0;
    }

B. Fun with Even Subarrays

题目大意：给你一个数列，每次选择两个相邻且长度相等的子段，然后将靠后的数列复制给前面的数列，问最少操作多少次可以使得整个数列中只有一个元素。
容易发现最后的值一定为数组最后一个元素的值，每次我们就可以选择一个所有元素都和最后一个数相等的最长后缀作为后一个数组并且不断向前覆盖，最后答案一定为最优。

    #include<iostream>
    #include<cstring>
    #include<cstdio>
    #include<algorithm>
    #define maxn 1000005
    using namespace std;
     
    int read()
    {
    	int x=1,res=0;
    	char c=getchar();
    	while(c<'0'||c>'9')
    	{
    		if(c=='-')
    		x=-1;
    		c=getchar();
    	}
    	while(c>='0'&&c<='9')
    	{
    		res=res*10+(c-'0');
    		c=getchar();
    	}
    	return res*x;
    }
    int t,n,a[maxn],b[maxn],last,key,ans;
     
    int main()
    {
    	t=read();
    	while(t--)
    	{
    		n=read();last=1;ans=0;
    		for(int i=n;i>=1;i--) a[i]=read();
    		key=a[1];
    		for(int i=2;i<=n;i++)
    		{
    			if(a[i]==key) continue;
    			if(a[i]!=key)
    			{
    				ans++;i=(i-1)*2;
    			}
    		}
    		printf("%d\n",ans);
    	}
    	return 0;
    }

C. And Matching

题目大意：给定n，n一定是2的整数次幂，然后将0~n-1的数两两进行与运算，并将结果求和，问能不能使得结果为k，并输出方案。
容易发现如果n>4时一定有解，而且进一步我们发现 $i$ 和 $n - 1 - i$ 进行配对结果为0，这样就可以构造出k=0的方案，然后我们再考虑k!=0时的情况
1.当k!=n-1时，我们在上面配对的基础上将k和n-1配对，0和n-k-1配对。
2.k=n-1时，令n-1配对n-2，n-3配对1，0配对2即可

    #include<iostream>
    #include<cstring>
    #include<cstdio>
    #include<vector>
    #include<algorithm>
    #include<map>
    #include<cmath>
    #define maxn 1000005
    using namespace std;
     
    int read()
    {
    	int x=1,res=0;
    	char c=getchar();
    	while(c<'0'||c>'9')
    	{
    		if(c=='-')
    		x=-1;
    		c=getchar();
    	}
    	while(c>='0'&&c<='9')
    	{
    		res=res*10+(c-'0');
    		c=getchar();
    	}
    	return res*x;
    }
    int n,k;
    void solve()
    {
    	n=read();k=read();
    	if(n==4&&k==3) puts("-1");
    	else if(k==n-1)
    	{
    		printf("%d %d\n%d %d\n%d %d\n",n-1,n-2,n-3,1,0,2);
    		for(int i=3;i<n/2;i++)
    		printf("%d %d\n",i,n-i-1);
    	}
    	else if(k==0)
    	{
    		for(int i=0;i<n/2;i++)
    		printf("%d %d\n",i,n-i-1);
    	}
    	else {
    		printf("%d %d\n%d %d\n",n-1,k,n-1-k,0);
    		for(int i=1;i<n/2;i++)
    		{
    			if(i==k||i==n-1-k) continue;
    			printf("%d %d\n",i,n-i-1);
    		}
    	}
    }
     
    int main()
    {
    	int t=read();
    	while(t--)
    		solve();
    	return 0;
    }

D. Range and Partition

题目大意：给你一个数列，要求将数列分成k段，并且选定一个值域 $[x, y]$ 使得每一段中在值域中的数要严格多于不在值域中的数，求最小的符合题意的值域即最小化y-x的划分方案。
有一点显而易见，就是值域越大，在其中的数就一定越多，因此不难想到二分值域，接下来问题转化为给定一个长度为mid的值域，问存不存在一种划分方案符合题意，我们可以枚举所有长度为mid的值域，分别判断，但是难题就在如何快速高效的判断，首先如果要符合题意，每一段中在值域中的数的个数就要比不在其中的数的个数至少多1，也就是说首先要有k个数在值域中，剩下的n-k个数至少要有一半的数在值域中，也就是说，在值域中的数的个数至少为： $k + (n - k + 1) / 2$ ，另外如果在值域中的数的个数比不在其中的数多k个，那就一定存在一种方案使得可以符合题意(只需要让每个区间在值域的数比不在的数多1)，因此我们只需要判断整个数列在 $[x, y]$ 区间中的数的个数是否超过 $k + (n - k + 1) / 2$ 即可。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<algorithm>
#include<map>
#include<cmath>
#include<queue>
#define clean(x) memset(x,0,sizeof(x))
#define maxn 1000005
using namespace std;

int read()
{
	int x=1,res=0;
	char c=getchar();
	while(c<'0'||c>'9')
	{
		if(c=='-')
		x=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9')
	{
		res=res*10+(c-'0');
		c=getchar();
	}
	return res*x;
}
int tot,x,y,a[maxn],n,k;
map<int,int>f;

int check(int mid)
{
	int ans=0;
	for(int i=mid;i<=n;i++)
	{
		ans=max(ans,f[i]-f[i-mid]);
		if(ans>=tot){
			x=i-mid+1;y=i;
			return 1;
		}
	}
	return 0;
}

void solve()
{
	n=read();k=read();
	f.clear();tot=k+(n-k+1)/2;
	for(int i=1;i<=n;i++)
	{
		int aa=read();
		a[i]=aa;
		f[aa]++;
	}
	for(int i=1;i<=n;i++)
		f[i]=f[i-1]+f[i];
	int l=1,r=n;
	while(l<=r)
	{
		int mid=(l+r)>>1;
		if(check(mid)) r=mid-1;
		else l=mid+1;
	}
	printf("%d %d\n",x,y);
	int last=1,cnt=0,len=0;
	for(int j=1;j<=k;j++)
	{
		if(j==k)
		{
			printf("%d %d\n",last,n);
			break;
		}
		cnt=0;len=0;
		for(int i=last;i<=n;i++)
		{
			len++;
			if(x<=a[i]&&a[i]<=y) cnt++;
			if(cnt>len/2){
				printf("%d %d\n",last,i);
				last=i+1;
				break;
			}
		}
	}
	
}

int main()
{
	int t=read();
	while(t--) 
		solve();
	return 0;
}

E. Paint the Middle

题目大意：给定一个序列，每次可以选择两个相同的且为被标记的数之间的任意一个数，并将其打上标记，问最多可以将多少数打上标记。
首先比较显然的一点就是对于某一个数，我们选取它第一次出现的位置和最后一次出现的位置并把这一段区间记为这个数包含的区间，因为这样一定比取小的区间包含的数多，有了这个结论我们就可以转化为一个类似于线段覆盖的问题，我们可以先将线段按照左端点排序，每次选择左端点最小的线段，然后找到能够和上次选出的线段有交集且右端点最大的线段，显然当两个线段合并时，一定会有一个点无法标记，因此合并时要将总数减去1，当没有线段与当前线段有交集时，我们就需要再选取一条左端点最小的线段，然后统计答案即可。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<algorithm>
#include<map>
#include<cmath>
#include<queue>
#define clean(x) memset(x,0,sizeof(x))
#define maxn 1000005
using namespace std;

int read()
{
	int x=1,res=0;
	char c=getchar();
	while(c<'0'||c>'9')
	{
		if(c=='-')
		x=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9')
	{
		res=res*10+(c-'0');
		c=getchar();
	}
	return res*x;
}
struct node{
	int l,r;
}g[maxn];
int a[maxn],ans,r,maxx;
priority_queue<node>q;
bool operator<(node a,node b){
	return a.l>b.l;
}
int main()
{
	int n=read();
	for(int i=1;i<=n;i++) a[i]=read();
	for(int i=1;i<=n;i++)
	if(!g[a[i]].l) g[a[i]].l=i;
	for(int i=n;i>=1;i--)
	if(!g[a[i]].r) g[a[i]].r=i;
	for(int i=1;i<=n;i++)
		if(g[i].r-g[i].l>1)
			q.push(g[i]);
	if(!q.size()) {
		cout<<0<<endl;
		return 0;
	}
	ans+=q.top().r-q.top().l-1;r=q.top().r;
	while(q.size())
	{
		node u=q.top();
		if(u.l>r){
			ans+=u.r-u.l-1;
			r=u.r;
			q.pop();
			continue;
		}
		while(q.size())
		{
			node u=q.top();
			if(u.l>r) break;
			maxx=max(maxx,u.r);
			q.pop();
		}
		ans+=max(0,maxx-r-1);
		r=maxx;
	}
	cout<<ans;
	return 0;
}

snowy2002

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Codeforces Round #768 (Div. 2)

A. Min Max Swap题目大意：给定两个数列aaa,bbb长度均为n，每次可以交换ai和bia_i和b_iai和bi求交换后两数列中的最大值的乘积的最小值。有一个显而易见的结论，就是两个数列中一定有一个数列的最大值等于所有元素的最大值，那么我们就可以尽可能使另一个数列的最大值变小，我们不妨令b数列为最大值所在的数列，这样我们只需要使得a数列尽可能小，因此对于每一个iii,我们只需要将ai=min(ai,bi)a_i=min(a_i,b_i)ai=min(ai,bi)，bi=max(ai
复制链接

扫一扫