Codeforce Ozon Tech Challenge 2020 (Div.1 + Div.2）2020.3.3题解（ABCDE）

最新推荐文章于 2024-07-22 12:12:21 发布

V4yne.

最新推荐文章于 2024-07-22 12:12:21 发布

阅读量286

点赞数

分类专栏： codeforce 题解

本文链接：https://blog.csdn.net/qq_43083173/article/details/104655545

版权

题解同时被 2 个专栏收录

10 篇文章 0 订阅

订阅专栏

codeforce

4 篇文章 0 订阅

订阅专栏

A题：
思路：签到题，没啥好说，给的两个数组里的每个数字都是彼此不相同的，要求和两两不同，显然对两个数组分别排序输出即可。
代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=2e5+50;
int t,n,m;
int arr[maxn];
int brr[maxn];
int main()
{
	ios::sync_with_stdio(false);
	cin>>t;
	while(t--)
	{
		cin>>n;
		for(int i=1;i<=n;i++) cin>>arr[i];
		for(int i=1;i<=n;i++) cin>>brr[i];
		sort(arr+1,arr+1+n);
		sort(brr+1,brr+1+n);
		for(int i=1;i<=n;i++)
		{
			if(i==1) cout<<arr[i];
			else cout<<" "<<arr[i];
		}
		cout<<endl;
		for(int i=1;i<=n;i++)
		{
			if(i==1) cout<<brr[i];
			else cout<<" "<<brr[i];
		}
		cout<<endl;
	 } 
	return 0;
}

B题：
思路：要求删除最少次数使得最终的序列没有"()"，其实很容易想到每次从最左和最右开始删除，左边找到一个(，右边就要找到一个)，所以l从0开始，r从s.size()-1开始模拟即可。我写的是反复寻找然后存入vector中再每次排序输出，其实想一想最多也就删除0次或者1次罢了，所以可以写的更简便的。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=1050;
int t,n,m;
string s;
vector<int> ans[1050];
int vis[1050];
int main()
{
	cin>>s;
	int cnt=0;
	while(1)
	{
		int flag=1;
		int l=0;int r=s.size()-1;
		while(1)
		{
			while(l<s.size())
		{
			if(vis[l]==1)
			{
				l++;continue;
			}
			if(s[l]==')')
			{
				l++;continue;
			}
			break;
		}
		while(r>=0)
		{
			if(vis[r]==1)
			{
				r--;continue;
			}
			if(s[r]=='(')
			{
				r--;continue;
			}
			break;
		}
		if(l<r)
		{
			if(flag==1)
			{
				cnt++;flag=0;
			}
			ans[cnt].push_back(l+1);ans[cnt].push_back(r+1);
			vis[l]=1;vis[r]=1;
		}
		else break;
		}
		if(flag==1) break;
	}
	cout<<cnt<<endl;
	for(int i=1;i<=cnt;i++)
	{
		sort(ans[i].begin(),ans[i].end());
		cout<<ans[i].size()<<endl;
		for(int j=0;j<ans[i].size();j++)
		{
			if(j==0) cout<<ans[i][j];
			else cout<<" "<<ans[i][j];
		}
		cout<<endl;
	}
	return 0;
}

C题：
思路：看到这个题目一开始很懵逼，不知道怎么写，然后看到这个m的范围是1000，就明白了。类似于抽屉原理一样，一共三个抽屉要放进去四个苹果，那么一定有一个抽屉里面是大于1个苹果的。
对m取模的结果为0-m-1，m个，如果n大于m，那么一定会有一个模数的次数出现大于1，此时相减后为0，乘出来结果一定为0，其实只要相乘项大于m就一定会输出0，但是时间原因写n>m直接判断输出0也好。
n小于等于m时可以暴力计算，最多（m*m)/2的复杂度。
代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=2e5+50;
ll t,n,m;
ll arr[maxn];
int main()
{
	ios::sync_with_stdio(false);
	cin>>n>>m;
	for(int i=1;i<=n;i++)
	{
		cin>>arr[i];
	}
	if(n>m)
	{
		cout<<0<<endl;return 0;
	}
	else
	{
		ll fin=1;
		for(int i=1;i<=n;i++)
		{
			for(int j=i+1;j<=n;j++)
			{
				ll z=abs(arr[j]-arr[i]);
				fin=fin*z;
				fin=fin%m;
			}
		}
		cout<<fin<<endl;
	}
	return 0;
}

D题：
思路：这是一道交互题，给定一棵树，不知道树上哪个点是根，然后每次我们输入两个点，系统告知它们的lca，最多可以询问n/2（向下取整）次，让我们判断出是哪个点是根。
我的思路比较难写，我是每次找当前树上的直径端点进行询问，如果询问结果是端点之一，那么这个就是根，如果不是，那么就把当前找到的树的直径上的所有的点都打上vis标记，下次寻找直径时不去访问vis被标记的点（因为vis标记的点不会是root了）。
代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=2e5+50;
int t,n,m;
int fa[1005];
int du[1005];
vector<int>edge[1005];
int vis[1005];
int son[1005];int d[1005];
void dfs(int x,int fa)
{
	son[x]=x;
	for(int i=0;i<edge[x].size();i++)
	{
		int y=edge[x][i];
		if(vis[y]) continue;
		if(y==fa) continue;
		dfs(y,x);
		if(d[y]+1>d[x])
		{
			d[x]=d[y]+1;
			son[x]=son[y];
		}
	}
    return;
}
int flag; 
void dfs2(int x,int fa,int z)
{
	vis[x]=1;
	if(x==z)
	{
		flag=1;
		return;
	}
	for(int i=0;i<edge[x].size();i++)
	{
		int y=edge[x][i];
		if(vis[y]) continue;
		if(y==fa) continue;
		dfs2(y,x,z);
		if(flag==0) vis[y]=0;
		if(flag==1) break;
	}
	return;
 } 
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n-1;i++)
	{
		int a,b;scanf("%d%d",&a,&b);
		du[a]++;du[b]++;
		edge[a].push_back(b);
		edge[b].push_back(a);
	}
	int beg,end;
	dfs(1,0);beg=son[1];
	for(int i=1;i<=n;i++)
	{
		d[i]=0;
	}
	dfs(beg,0);end=son[beg];
	while(1)
	{
		int cnt;
	    printf("? %d %d\n",beg,end);
	    fflush(stdout);
	    scanf("%d",&cnt);
//	   cout<<beg<<"--"<<end<<"--"<<cnt<<endl;
	    if(cnt==beg||cnt==end)
	    {
	    	printf("! %d\n",cnt);
	    	fflush(stdout);
	    	break;
		}
		else
		{
			flag=0;
			dfs2(beg,0,end);
			vis[cnt]=0;
			for(int i=1;i<=n;i++)
	{
		d[i]=0;
	}
			dfs(cnt,0);beg=son[cnt];
			for(int i=1;i<=n;i++)
	{
		d[i]=0;
	}
			dfs(beg,0);end=son[beg];
			if(beg==end)
			{
				printf("! %d\n",cnt);
	    	fflush(stdout);
	    	break;
			}
		}
	}
    return 0;
/*	flag=0;
	dfs2(beg,0,end);
	int cnt;
	printf("? %d %d\n",beg,end);
	fflush(stdout);
	scanf("%d",&cnt);
	int now=-1;
	for(int i=0;i<edge[cnt].size();i++)
	{
		if(vis[edge[cnt][i]]==0)
		{
			now=edge[cnt][i];break;
		}
	}
	if(now==-1)
	{
		printf("! %d\n",cnt);
		fflush(stdout);
	}
	else
	{
		printf("? %d %d\n",cnt,now);
		fflush(stdout);
		int fin;scanf("%d",&fin);
		printf("! %d\n",fin);
		fflush(stdout);
	}
	return 0;*/
}

E题：
思路：这题如果发现了1234…n这么填时满足三元组的数量最多，那么这题就很好写，感觉这题比d简单orz。我们注意到在ans[i]填上i 时增加的三元组数量是 ( i-1)/2 ，所以我们可以进行模拟，一开始就一直按顺序填，直到增加的对数大于需要的就再处理一下，然后多余的位置可以从1e8开始每次加上1e5之类的较大的不会和之前的数字组成三元组的数字。
代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=5050;
int t,n,m;
int ans[maxn];
int main()
{
	ios::sync_with_stdio(false);
	cin>>n>>m;
	if(m>0&&n<3)
	{
		cout<<"-1"<<endl;return 0;
	}
	int i=0;
	int flag=1;
	while(1)
	{
		i++;
		if(m&&i>n)
		{
			flag=0;break;
		}
		if(m>=(i-1)/2)
		{
			ans[i]=i;m-=(i-1)/2;
			continue;
		}
		if(m)
		{
			ans[i]=(i-m)+(i-m-1);
			m=0;
			continue;
		}
		if(!m)
		{
			break;
		}
	}
	i--;
	if(!flag)
	{
		cout<<"-1"<<endl;return 0;
	}
	ll cnt=1e8+50;
	for(int j=i+1;j<=n;j++)
	{
		ans[j]=cnt;
		cnt+=100009;
	}
	for(int i=1;i<=n;i++)
	{
		if(i==1) cout<<ans[i];
		else cout<<" "<<ans[i];
	}
	return 0;
}