Codeforces Round #793 (Div. 2) 总结-----2022.5.24

04号憨憨

已于 2022-05-25 14:04:37 修改

阅读量202

点赞数 1

分类专栏： Codeforces 文章标签：算法

于 2022-05-24 22:39:30 首次发布

本文链接：https://blog.csdn.net/m0_52766855/article/details/124950677

版权

Codeforces 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

反思

注意细节，提交前检查细节，不要再犯A题崩掉的错误。。。。
考虑问题更加慎重，逻辑要连贯

题目

B. AND Sorting

在这里插入图片描述
B题的大意就是，给定一 $1 e 5$ 数量级的数组(一个 $0$ 开始的排列，保证初始情况一定不严格升序)，若交换 $p_i,p_j$ ，当且仅当 $p_i \& p_j== X$ ， $X$ 为一个恒定值。问最大的 $X$ 值是多少

思考的关键点：由于是一个排列，所以每个元素都有一个唯一确定的最终位置（即严格升序排列的位置）。对于初始情况，不在它应当在的位置的元素，那么交换过程中一定会涉及它，即对于某个目标元素 $p_i$ ,一定会用某个元素 $?$ 去和它交换，那么就要满足： $\quad \& \quad p_i == X$
而根据 $\&$ 运算的性质， $X$ 二进制位 $1$ 的分布一定是所有满足条件的 $p_i$ 的二进制位 $1$ 的分布情况的交集的子集！！！！
那为什么只考虑不在原位的元素呢？？也很容易想，元素越多，交集越小嘛。。。而我们肯定希望交集越大越好。。。。
所以首先求交集： $sum=\sum_{k}^{a[k]\ !=k}a[k] \quad(这里的\sum 是求 \& 运算和)$
为了使 $X$ 最大，那么交集便是子集。。。
代码如下：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<vector>
#include<string>
#include<set>
#include<map>
#include<unordered_map>
#include<queue>

#define me(x,y) memset(x,y,sizeof x)
#define rep(i,x,y) for(i=x;i<=y;++i)
#define repf(i,x,y) for(i=x;i>=y;--i)
#define lowbit(x) -x&x
#define inf 0x3f3f3f3f
#define INF 0x7fffffff

using namespace std;
typedef long long ll;
typedef pair<int,int> PII;

inline int read()
{
	int x=0,f=1;char ch=getchar();
	while (ch<'0'||ch>'9'){if (ch=='-') f=-1;ch=getchar();}
	while (ch>='0'&&ch<='9'){x=x*10+ch-48;ch=getchar();}
	return x*f;
}

const int N =2e5+10;
int n,t;

int q[N];

int main()
{
	int i,j,cnt;
	
	t=read();
	while(t--)
	{
		n=read(),cnt=0;
		rep(i,0,n-1)
		{
			j=read();
			if(j!=i)	q[cnt++]=j;
		}
		rep(i,1,cnt-1)	q[0]&=q[i];
		printf("%d\n",q[0]);
	}
	
	return 0;
}

C. LIS or Reverse LIS?

在这里插入图片描述
C题的大意是，给定一个 $1 e 5$ 数量级的数列，和其反转的数列，记 $L$ 为两者最长严格上升子序列的最小值。通过任意重构数列，使得 $L$ 的值最大。

关键思路：最长严格上升子序列和其反转，最多只有一个公共元素！！！（反证法便可证）
由于可以随意重构数列，所以我们将这个数列离散化，并统计这个数列的每个元素的个数，将元素分成两类：一类是元素个数大于一，另外一类为元素个数等于一。
由贪心思想容易想到：这个公共元素是单一的元素最优！！
设 $s i z$ 为离散化数组的元素个数， $o n e$ 为元素个数为一的个数
所以答案为 $one==0\quad?\quad siz \quad : \quad \lfloor \frac{one+1}{2}\rfloor+siz-one$

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<vector>
#include<string>
#include<set>
#include<map>
#include<unordered_map>
#include<queue>

#define me(x,y) memset(x,y,sizeof x)
#define rep(i,x,y) for(i=x;i<=y;++i)
#define repf(i,x,y) for(i=x;i>=y;--i)
#define lowbit(x) -x&x
#define inf 0x3f3f3f3f
#define INF 0x7fffffff

using namespace std;
typedef long long ll;
typedef pair<int,int> PII;

inline int read()
{
	int x=0,f=1;char ch=getchar();
	while (ch<'0'||ch>'9'){if (ch=='-') f=-1;ch=getchar();}
	while (ch>='0'&&ch<='9'){x=x*10+ch-48;ch=getchar();}
	return x*f;
}

int t,n;
map<int,int>nums;

int main()
{
	int i,j,siz,one;
	
	t=read();
	while(t--)
	{
		n=read();
		vector<int>arr(n,0);
		nums.clear();
		rep(i,0,n-1)	arr[i]=read(),nums[arr[i]]++;
		sort(arr.begin(),arr.end());
		arr.erase(unique(arr.begin(),arr.end()),arr.end());
		siz=arr.size(),one=0;
		rep(i,0,siz-1) if(nums[arr[i]]==1)	++one;
		printf("%d\n",one==0 ? siz : (siz-one+(one+1)/2));
	}
	
	return 0;
}

D. Circular Spanning Tree

在这里插入图片描述
D题完全感觉要靠灵感。。。。
首先考虑，什么情况下肯定构不成树，由于树的一条edge能够为整个树提供 $2$ 个度数，所以树的总度数肯定为偶数，所以在本题中字符串中 $1$ 的个数肯定为偶数。且由于树肯定有叶子节点，所以 $1$ 的个数为大于 $0$ 的偶数。其他情况一定能够构造出来一个树。。。

我们首先考虑，只存在两个 $1$ 的情况，一个是相邻，另外一个是非相邻的，既要考虑破环的方法：

在这里插入图片描述
其他情况：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<vector>
#include<string>
#include<set>
#include<map>
#include<unordered_map>
#include<queue>

#define me(x,y) memset(x,y,sizeof x)
#define rep(i,x,y) for(i=x;i<=y;++i)
#define repf(i,x,y) for(i=x;i>=y;--i)
#define lowbit(x) -x&x
#define inf 0x3f3f3f3f
#define INF 0x7fffffff

using namespace std;
typedef long long ll;
typedef pair<int,int> PII;

inline int read()
{
	int x=0,f=1;char ch=getchar();
	while (ch<'0'||ch>'9'){if (ch=='-') f=-1;ch=getchar();}
	while (ch>='0'&&ch<='9'){x=x*10+ch-48;ch=getchar();}
	return x*f;
}

const int N= 2e5+10;
int n,t;

char str[N];
int q[N],cnt;

inline int get(int x)
{
	return x>n ? x%n : x;
}

int main()
{
	int i;
	
	t=read();
	while(t--)
	{
		n=read();
		scanf("%s",str+1);
		
		//先判断，奇数顶点的个数为非0偶数
		cnt=0;
		rep(i,1,n)	 if(str[i]=='1')	q[cnt++]=i;
		if(!cnt||cnt%2)
		{
			puts("NO");
			continue;
		}
		puts("YES");
		
		if(get(q[0]+1)==q[1])	printf("%d %d\n",get(q[1]),get(q[1]+1));
		else	printf("%d %d\n",get(q[0]+1),get(q[1]+1));
		for(i=2;i<=cnt-1;i+=2)	
			printf("%d %d\n",get(q[i]),get(q[i+1]+1)),printf("%d %d\n",get(q[i]),get(q[i]+1));
		rep(i,1,n)	if(str[i]=='0')	printf("%d %d\n",get(i),get(i+1));
	}
	
	return 0;
}

E. Unordered Swaps

在这里插入图片描述
D题的大意为：给定一个数量级为 $2 e 5$ 的排列，再给定 $m$ 个交换下标的二元组(保证按照某种顺序执行交换，一定能将排列排成一个严格升序的序列，而且满足这种交换方式是数量最小的)，求解一种可行的顺序。。

本题的本质就是 拓扑排序

首先，看到打乱的排列的排序问题，就要想到 $permutation\ circle$ ，就是可以把这个打乱的排列分成一个独立的块来排序，每个块的内部构成一个环。

再来讨论次数最小的问题，对于每个环，若有 $n$ 个元素，则交换的二元组个数一定是 $n - 1$ 个，构成一个树形结构。

对于每个环的内部，交换二元组的执行顺序根据环的指向，遵循某种 $D A G$ 序(不遵循反证)，如下图所示：
在这里插入图片描述
在 $D A G$ 中： $2\rightarrow 1$ $3\rightarrow 2$ $4\rightarrow 1$
接下来求拓扑序即可。。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<vector>
#include<string>
#include<set>
#include<map>
#include<unordered_map>
#include<queue>

#define me(x,y) memset(x,y,sizeof x)
#define rep(i,x,y) for(i=x;i<=y;++i)
#define repf(i,x,y) for(i=x;i>=y;--i)
#define lowbit(x) -x&x
#define inf 0x3f3f3f3f
#define INF 0x7fffffff

using namespace std;
typedef long long ll;
typedef pair<int,int> PII;

inline int read()
{
	int x=0,f=1;char ch=getchar();
	while (ch<'0'||ch>'9'){if (ch=='-') f=-1;ch=getchar();}
	while (ch>='0'&&ch<='9'){x=x*10+ch-48;ch=getchar();}
	return x*f;
}

struct edge
{
	int to;
	int nxt;
};

const int N= 2e5+10;
int n,m,cnt,cnt_;

int a[N],cir[N],ht[N],nums[N],deg[N],q[N];
int head[N],head_[N];
edge table[2*N],table_[2*N];
bool st[N];
PII tp[N];

map<PII,int> memo; 

inline void add(int& u,int& v)			//邻接表1，用于存储每个位置于交换的位置 
{
	table[++cnt].nxt=head[u];
	head[u]=cnt;
	table[cnt].to=v; 
}

inline void add_(int& u,int& v)			//邻接表2，DAG 
{
	table_[++cnt_].nxt=head_[u];
	head_[u]=cnt_;
	table_[cnt_].to=v;	
} 

int main()
{
	int i,j,k,u,v,e,beg,idx,ptr,hh,tt;
	
	n=read(),m=read();
	rep(i,1,n)	a[i]=read();	
	rep(i,1,m)
	{
		u=read(),v=read(),nums[u]++,nums[v]++;
		add(u,v),add(v,u);
		memo[PII{min(u,v),max(u,v)}]=i;
	} 
	
	rep(i,1,n)
	{
		if(st[i])	continue;
		if(i==a[i])	continue;
		
		beg=j=i,idx=0;
		do
		{
			j=a[j];
			cir[idx++]=j;
		}
		while(j!=beg);
		
		rep(j,0,idx-1)	ht[cir[j]]=j,st[cir[j]]=true;
		
		if(idx==2)	continue;
		
		rep(j,0,idx-1)
		{
			if(nums[cir[j]]>1)
			{
				u=cir[j],ptr=0;
				for(e=head[u];e;e=table[e].nxt)
				{
					v=table[e].to;
					tp[ptr++]={(ht[v]>j ? ht[v] : ht[v]+idx),memo[PII{min(u,v),max(u,v)}]}; 
				}
				sort(tp,tp+ptr);
				rep(k,0,ptr-2)	add_(tp[k].second,tp[k+1].second),deg[tp[k+1].second]++;
					//printf("---%d %d\n",tp[k].second,tp[k+1].second);
			}
		}
	//	puts("-------------------");
	}
	
	hh=0,tt=-1;
	rep(i,1,m) if(!deg[i])	q[++tt]=i;
	while(hh<=tt)
	{
		//u=q[hh++];
		printf("%d ",u=q[hh++]);	
		for(e=head_[u];e;e=table_[e].nxt)
		{
			v=table_[e].to;
		//	printf("%d ",v);
			deg[v]--;
			if(!deg[v])	q[++tt]=v;
		} 
	}	
	
	return 0;
}

04号憨憨

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Codeforces Round #793 (Div. 2) 总结-----2022.5.24

反思注意细节，提交前检查细节，不要再犯A题崩掉的错误。。。。考虑问题更加慎重，逻辑要连贯题目B. AND SortingB题的大意就是，给定一 1e51e51e5 数量级的数组(一个000 开始的排列，保证初始情况一定不严格升序)，若交换 pi,pjp_i,p_jpi,pj，当且仅当 pi&pj==Xp_i \& p_j== Xpi&pj==X，XXX 为一个恒定值。问最大的 XXX 值是多少思考的关键点：由于是一个排列，所以每个元素都有一个唯一确定的最
复制链接

扫一扫