比赛记录:Codeforces Round 874 (Div. 3) A~G

已于 2023-12-29 23:37:45 修改
阅读量834 收藏 2
点赞数
分类专栏： c++算法 # 各类比赛 文章标签： 算法 c++
于 2023-05-22 16:53:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yingjiayu12/article/details/130805114
版权

传送门:CF

前题提要:赛时A出了5道题,并且都是一遍过的,F题也已经找到了解决方法,但是没时间完成了.以为应该能上分,但是没想到赛后E题被hack掉了…绝了.然后打完这场 d i v 3 div3 div3后立马阳了,加上一大堆烦心事(包括但不限于各类考试).就导致现在才写出这篇题解.

A题:A. Musical Puzzle

我们发现这道题就是求长度为2的不同的字符串的个数.因为只要有一种字符串我们合成了,那么对于接下来的合成来说,只要碰到该字符串,我们只要使用直接合成过的字符串即可

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define root 1,n,1
#define ls rt<<1
#define rs rt<<1|1
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
#define maxn 1000000
const double eps=1e-8;
#define	int_INF 0x3f3f3f3f
#define ll_INF 0x3f3f3f3f3f3f3f3f
int main() {
	int T=read();
	while(T--) {
		int n=read();map<string,int>mp;
		string s;cin>>s;
		int ans=0;
		for(int i=1;i<s.length();i++) {
			string ss;ss.push_back(s[i-1]);ss.push_back(s[i]);
			if(mp[ss]) {
				continue;
			}
			else {
				mp[ss]=1;
				ans++;
			}
		}
		cout<<ans<<endl;
	}
	return 0;
}

B题:B. Restore the Weather

有一说一这道题思维上还真有点难度.当时在赛场上把我卡了一下.感觉思维难度相当于 d i v 2 B div2B div2B了.
这道题的突破口在于猜想(bushi.毕竟是CF嘛,结论猜就完了.其实不难猜出应该a中越小的与b中越小的搭配应该是最优的.这个想证明也不难证.假设数列a中有 A , B A,B A,B两个元素,并且 A < B A<B A<B.数列b中有 C , D C,D C,D两个元素,并且 C , D C,D C,D,我们发现总共只有下列几种情况:
在这里插入图片描述
对于所有情况,我们都会发现 m a x ( a b s ( A − C ) , a b s ( B − D ) ) < m a x ( a b s ( A − D ) , a b s ( B − C ) ) max(abs(A-C),abs(B-D))<max(abs(A-D),abs(B-C)) max(abs(A−C),abs(B−D))<max(abs(A−D),abs(B−C)).所以就是小的搭配小的是最优的.
所以我们计算出每一个元素在a数组中的排第几位,然后输出其在b数组中应该的位置即可.

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define root 1,n,1
#define ls rt<<1
#define rs rt<<1|1
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
#define maxn 1000000
const double eps=1e-8;
#define	int_INF 0x3f3f3f3f
#define ll_INF 0x3f3f3f3f3f3f3f3f
int b[maxn];
struct Node{
	int num,id;
	bool operator < (const Node &rhs) const {
		return num<rhs.num;
	}
}a[maxn];
int paiming[maxn];
int main() {
	int T=read();
	while(T--) {
		int n=read();int k=read();
		vector<int>v;
		for(int i=1;i<=n;i++) {
			a[i].num=read();
			a[i].id=i;
			v.push_back(a[i].num);
		}
		sort(a+1,a+n+1);
		for(int i=1;i<=n;i++) {
			paiming[a[i].id]=i;
			b[i]=read();
		}
		sort(b+1,b+n+1);
		for(int i=1;i<=n;i++) {
			cout<<b[paiming[i]]<<" ";
		}
		cout<<endl;
	}
	return 0;
}

C题:C. Vlad Building Beautiful Array

感觉本题比B题要简单.看完题面,首先想到的想法应该是分类讨论.讨论最后的构造数组中应该全是奇数或者全是偶数.
对于全是偶数的情况,十分简单.对于每一个 a i a_i ai​,假设当前数是偶数,那么显然我们可以直接选取,但是假设此时我们至少存在一个奇数.我们发现此时无论如何也无法构造出了.为什么呢,因为只要存在奇数,显然我们可以找到最小的那一个奇数,对于这个最小的奇数来说,我们没法找到比它更小的奇数了(因为它本身就是最小).所以此时无法构造.
对于全部都是奇数的情况.我们记录一下最小的那一个数.如果最小的那一个数是奇数的话,我们显然都是可行的.如果最小的那一个数是偶数的话,那么对于这个偶数来说,我们依旧无法将这个最小的偶数转化为奇数.

ps:关于本题的代码,我在写题解时突然发现之前赛时写的代码看似逻辑全无,但是仔细考虑了一下逻辑竟然又是正确的(毕竟赛时过了),难道这就是直觉吗…,所以我就把这个逻辑全无的代码放上来了,供大家把玩一下.经典的实现方式我相信在上述的讲解过程中已经不难写出了

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define root 1,n,1
#define ls rt<<1
#define rs rt<<1|1
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
#define maxn 1000000
const double eps=1e-8;
#define	int_INF 0x3f3f3f3f
#define ll_INF 0x3f3f3f3f3f3f3f3f
int a[maxn];
int main() {
	int T=read();
	while(T--) {
		int n=read();
		int minn1=int_INF;
		for(int i=1;i<=n;i++) {
			a[i]=read();
			minn1=min(minn1,a[i]);
		}
		int flag1=0;int flag2=0;
		for(int i=1;i<=n;i++) {
			if(a[i]%2==1) {
				continue;
			}
			else {
				if(minn1<a[i]) {
					continue;
				}
				else {
					flag1=1;
					break;
				}
			}
		}
		for(int i=1;i<=n;i++) {
			if(a[i]%2==1) {
				flag2=1;
				break;
			}
			else {
				continue;
			}
		}
		if(!(flag1&&flag2)) cout<<"YES"<<endl;
		else cout<<"NO"<<endl;
	}
	return 0;
}

D题:D. Flipper

对于我来说,本题唯一坑点是数字可能存在两位数,所以在实现过程中是不能用string来存储数字的
把玩一下题意不难发现无论第一位是什么数字,经过操作之后该位置的数字必定会被放到后面去.所以我们首先需要找到的是除第一位以外的最大的那一个数的位置(记为 p o s pos pos),那么显然的,我们此时需要将其放到第一位的位置上去.对比一下我们能进行的操作,我们发现我们的 [ p o s , n ] [pos,n] [pos,n]的所有数字都将放到首位.

然后我们需要考虑的是pos前面的数字是否在哪一处区间进行了翻转操作.诶此时我们显然可以枚举翻转区间的左端点,然后对于每一次枚举的操作,我们都将那个区间翻转然后在后面加上前缀,记录最大的字典序即可

此处需要注意的是当我们的最大值后缀的长度为1时,我们可以仅对该位置的数字进行翻转,这样就比上述的枚举方案多了一种情况了,这个需要注意.

对于枚举的时候如何方便的判断字典序的最大值.可以考虑使用vector.因为可能有多位数的原因,我们不能使用string了.注意vector也是可以翻转的.并且vector自身是重载了运算符的,也就是当两个vector进行比较时,就是以存的数字的字典序进行比较的.vector真是太优越啦

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define root 1,n,1
#define ls rt<<1
#define rs rt<<1|1
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
#define maxn 1000000
const double eps=1e-8;
#define	int_INF 0x3f3f3f3f
#define ll_INF 0x3f3f3f3f3f3f3f3f
int p[maxn];
int main() {
	int T=read();
	while(T--) {
		int n=read();
		for(int i=1;i<=n;i++) p[i]=read();
		if(n==1) {
			cout<<p[1]<<endl;
			continue;
		}
		int maxx=-int_INF;
		if(p[1]!=n) maxx=n;
		else maxx=n-1;
		int pos;
		for(int i=n;i>=2;i--) {
			if(p[i]==maxx) {
				pos=i;
				break;
			}
		}
		vector<int>ans;
		for(int i=pos;i<=n;i++) ans.push_back(p[i]);
		vector<int>v;
		for(int i=1;i<pos;i++) v.push_back(p[i]);
		vector<int>maxx2;int cnt=(pos==n?0:1);
		for(int i=v.size()-cnt;i>=0;i--) {
			vector<int>v2;
			for(int j=i;j<v.size();j++) {
				v2.push_back(v[j]);
			}
			reverse(v2.begin(),v2.end());
			vector<int>v3;
			for(int j=0;j<v2.size();j++) v3.push_back(v2[j]);
			for(int j=0;j<i;j++) {
				v3.push_back(v[j]);
			}
			maxx2=max(maxx2,v3);
		}
		for(int i=0;i<ans.size();i++) {
			cout<<ans[i]<<" ";
		}
		for(int i=0;i<maxx2.size();i++) {
			cout<<maxx2[i]<<" ";
		}
		cout<<endl;
	}
}

E题:E. Round Dance

这道题赛后被狠狠的hack掉了,真是醉了,只能怪这道题的赛时数据有点弱了,我被hack的那一种情况显然应该是存在的,但是测试点中并不存在.

看完题意之后不难发现应该是一道图论题.对于每一个数的邻居.考虑对他们俩连一条单向边.最后不难发现应该存在这样几种情况:
在这里插入图片描述

先简单解释一下为什么E情况是不存在的:因为假设这种情况存在的话,那么中间的那一个点将会有三个邻居,这样显然是不满足题意的.
先规定一下:我们将一个联通块在本题中称之为链,当且仅当该联通块能与其他同为链的联通块进行相连(也就是首尾两个位置的数并没有规定邻居).我们将一个联通块称之为环,当且仅当该联通块不能与其他联通块相连(也就是首尾两个位置的数已经被规定了邻居).
那么我们显然会发现,ACDF皆为链,只有B这种情况为环.当时我被hack了就是没有考虑F这种情况…
那么我们想得到最小答案,显然是将所有的链连成一块,然后加上环的个数.
我们想得到最大答案,显然就是环的个数+链的个数.
对于链的个数,显然我们可以使用拓扑排序来求,但是由于D的原因,我们又需要判断是否存在二元环,因为F的存在,我们有需要记录当前拓扑序属于第几个联通块.具体实现方式建议结合代码食用,使用文字不太能讲的明白

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define root 1,n,1
#define ls rt<<1
#define rs rt<<1|1
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
#define maxn 1000000
const double eps=1e-8;
#define	int_INF 0x3f3f3f3f
#define ll_INF 0x3f3f3f3f3f3f3f3f
int a[maxn];int vis[maxn];
vector<int>edge[maxn];int flag=1;int in[maxn];int cnt=0;
map<int,map<int,int> >mp;
void DFS(int u) {
	for(int i=0;i<edge[u].size();i++) {
		int v=edge[u][i];
		if(vis[v]) {
			if(vis[v]==cnt) {
				if(mp[u][v]==mp[v][u]) continue;//判断是否是因为二元环而重复,二元环将被当做链
				else {
					flag=0;return ;//如果不是那就是环了
				}
			}
			else {
				flag=-1;return ;//这里用来判断是否是F这种情况,也就是遍历到了一个之前遍历过的点,那么显然当前点应该是属于之前那个联通块的,此时不能重复累加
			}
		} 
		if(flag!=1) return ;
		vis[v]=cnt;
		DFS(v);
	}
}
int main() {
	int T=read();
	while(T--) {
		int n=read();mp.clear();
		for(int i=1;i<=n;i++) {
			edge[i].clear();
			vis[i]=0;in[i]=0;
		}
		for(int i=1;i<=n;i++) {
			a[i]=read();
			in[a[i]]++;
			edge[i].push_back(a[i]);
			mp[i][a[i]]=1;
		}
		int cnt1=0,cnt2=0;
		for(int i=1;i<=n;i++) {
			if(in[i]==0) {
				flag=1;
				++cnt;
				vis[i]=cnt;
				DFS(i);
				if(flag==1) cnt1++;
			}
		}
		for(int i=1;i<=n;i++) {
			if(vis[i]==0) {
				++cnt;
				flag=1;vis[i]=cnt;
				DFS(i);
				if(flag==1) cnt1++;
				else cnt2++;
			}
		}
		cout<<cnt2+(cnt1?1:0)<<" "<<cnt1+cnt2<<endl;
	}
	return 0;
}

F题:F. Ira and Flamenco

发现我们需要选取 m m m个不同的数字,并且还要保证没两个数的差要小于 m m m.那么很显然,我们找的这 m m m个数字应该是连续的.也就是 k , k + 1 , k + 2... k + m − 1 k,k+1,k+2...k+m-1 k,k+1,k+2...k+m−1这样陈列的.
发现位置不同算不同的情况,所以考虑对原数列进行离散化.统计每一个数字出现的次数,然后对于最终的选取方案乘上相应的倍数即可.并且我们也可以对原数列进行排序,这些操作显然都不会对最终的答案产生任何影响.
然后这道题就十分简单了.我们考虑使用双指针,每一次都找到一段合法的连续数字区间(此时可以不需要考虑区间的长度,当然考虑也没关系,但是由于我是用不考虑的方法做的,所以我接下来也是基于不考虑的方法来讲解的),对于当前区间,假设我们的长度刚好是 m m m,那么显然当前选取方案就是区间内所有数字的个数的乘积.假设我们的长度小于 m m m,那么显然我们这段区间不满足,直接枚举下一段区间.假设我们的长度大于 m m m,那么我们将从刚开始的 [ l , l + m − 1 ] [l,l+m-1] [l,l+m−1]开始逐个记录每一个满足区间的值.当我们区间移动时,我们当前区间的贡献应该是上一个区间的贡献除移除的左端点的贡献乘上加入的右端点的贡献.因为需要取模,所以需要使用逆元.

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define root 1,n,1
#define ls rt<<1
#define rs rt<<1|1
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
#define maxn 1000000
#define int long long
const int mod=1e9+7;
const double eps=1e-8;
#define	int_INF 0x3f3f3f3f
#define ll_INF 0x3f3f3f3f3f3f3f3f
int n,m;int in_fac[maxn];
int qpow(int a,int b) {
	int ans=1;
	while(b) {
		if(b&1) ans=(ans*a)%mod;
		b>>=1;
		a=(a*a)%mod;
	}
	return ans;
}
int a[maxn];map<int,int>mp;
vector<int>v;
signed main() {
	int T=read();
	while(T--) {
		n=read();m=read();mp.clear();v.clear();
		for(int i=1;i<=n;i++) {
			a[i]=read();
			v.push_back(a[i]);
			mp[a[i]]++;
		}
		if(m==1) {
			cout<<n<<endl;
			continue;
		}
		sort(v.begin(),v.end());
		v.erase(unique(v.begin(),v.end()),v.end());
		int l=0,r=0;int ans=0;
		while(r<v.size()) {
			if(r+1<v.size()&&v[r+1]-v[r]==1) r++;
			else {
				if(r-l+1>m) {
					int sum=1;
					for(int i=l;i<=l+m-1;i++) {
						sum=(sum*mp[v[i]])%mod;
					}
					ans=(ans+sum)%mod;
					while(l+m<=r) {
						l++;
						int R=l+m-1;
						sum=sum*mp[v[R]]%mod;
						sum=sum*qpow(mp[v[l-1]],mod-2)%mod;
						ans=(ans+sum)%mod;
					}
					l=r+1;r=l;
				}
				else if(r-l+1==m){
					int sum=1;
					while(l<=r) {
						sum=(sum*mp[v[l]])%mod;
						l++;
					}
					r=l;
					ans=(ans+sum)%mod;
				}
				else {
					l=r+1;r=l;
				}
			}
		}
		cout<<ans<<endl;
	}	
	return 0;
}

G题:G. Ksyusha and Chinchilla

本题是阳了的那天补的.做的时候迷迷糊糊.

其实本题的规律应该不是很难找.很容易发现对于一个节点 u u u来说,如果它同时有大小为一的儿子和大小为2的儿子,此时我们肯定是无法构造的.因为1,2都需要u来进行消除.又或者它同时有超过2个的大小为1的儿子或者超过一个的大小为2的儿子,也是无法构造的.

此时我们应该想到了一个基本的构造方案.所以我们考虑从下往上进行构造.在构造的过程中,我们一旦发现存在上述情况就直接退出,然后输出 − 1 -1 −1.为了讨论方便起见,不妨另当前的这棵树是满足题意的.诶,写到这发现想要继续讨论下去,需要插播一条证明:下面来证明一下对于一个可满足题意的树来说,当每一个节点u的大小为3的倍数时,此时我们的u子树可以自行消除,不需要其他节点
可以使用反证法来证明,如果当前u子树需要其他节点.那么我们此时的总结点数就是3的倍数加上1或2(更大的显然没必要,因为最大只需要2).又因为对于一个可满足的树来说,我们每一次消除,减少的是3,所以总的节点数应该是3的倍数,这样就与这个事实矛盾了.又因为该子树是不是不可满足的,又是三的倍数,所以不需要其他节点.证毕.
此时我们考虑将所有子树的大小对3取模,对于模后结果为0的儿子v,我们直接加入<u,v>这条边即可.
对于模后结果为1的子树,我们将其当做一个大小为1的儿子(注意这里为什么能这么等价,因为我们递归到现在都是可满足的,所以这个子树中模后结果为3的任何一个更小的子树都是可删除的).对于模后结果为2的子树,我们将其当做一个大小为2的儿子即可.

还需要注意的一点细节是我们的根节点也是需要消除的,这个在dfs中是没办法保证的,但是我们可以通过n%3==0来保证

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define root 1,n,1
#define ls rt<<1
#define rs rt<<1|1
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
#define maxn 1000000
const double eps=1e-8;
#define	int_INF 0x3f3f3f3f
#define ll_INF 0x3f3f3f3f3f3f3f3f
vector<int>edge[maxn];int Size[maxn];
map<int,map<int,int> >mp;
int flag=1;vector<int>Ans;
void dfs(int u,int per_u) {
	Size[u]=1;int cnt1=0,cnt2=0;
	for(int i=0;i<edge[u].size();i++) {
		int v=edge[u][i];
		if(v==per_u) continue;
		dfs(v,u);Size[u]+=Size[v];
		if(Size[v]%3==0) Ans.push_back(mp[u][v]);
		else if(Size[v]%3==1) cnt1++;
		else cnt2++;
	}
	if(cnt1&&cnt2) flag=false;
	if(cnt1>2) flag=false;
	if(cnt2>1) flag=false;
}
int main() {
	int T=read();
	while(T--) {
		int n=read();mp.clear();Ans.clear();
		flag=1;
		for(int i=1;i<=n;i++) {
			edge[i].clear();Size[i]=0;
		}
		for(int i=1;i<=n-1;i++) {
			int u=read(),v=read();
			mp[u][v]=mp[v][u]=i;
			edge[u].push_back(v);
			edge[v].push_back(u);
		}
		if(n==3) {
			cout<<0<<endl<<endl;
			continue;
		}
		if(n<=2) {
			cout<<"-1"<<endl;
			continue;
		}
		dfs(1,0);
		if(flag==true&&n%3==0){
			cout<<Ans.size()<<endl;
			for(int i=0;i<Ans.size();i++) {
				cout<<Ans[i]<<" ";
			}
			cout<<endl;
		} 
		else {
			cout<<"-1"<<endl;
		}
	}
	return 0;
}












今日迷思:
有些事情对周围的人都不太好表达,自己选择一直憋着也挺难受的.反正这篇博客应该是不会被熟人看到的,就选择在这里倾诉一下了.
就在写这篇博客的今天,我决定和我的室友决裂了.这个室友可以说是我刚入大学时就准备一起打三年ACM的队友.我们一起在大一就拿了邀请赛的铜牌(虽然只是铜,但是在一个ACM弱校中感觉已经是难能可贵了).但是我们之间发生一些已经无法经过交涉能解决的事情了.就像"一起同过窗"中的一样.我甚至不如剧中的肖海洋,简直可以称作为一个joker.而且是在某人的见证下一步步成为joker的.更令人绝望的是假设我今日没有知道真正的事实,可能会一直成为joker下去.简直是无法在忍受了。但是我们之间又有着各种共同的交集.首先是室友,平时一起的事情就比较多,同时也有各种相同的朋友,相同的导师…这些都挺让我绝望的.最烦的是还有一个大创和ACM在,大创还已经申报上去了.继续大创是不可能了,我在那个大创队伍中呆一秒钟都简直想紫砂.刚刚经过磨练过的ACM队伍也要被拆散了(一个团队竞赛中两个队员存在敌对关系显然是不可能提升的).我感觉唯一的解决方案可能就是我退出大创队伍,然后让他退出我们的ACM队伍中了.虽然这样子我们队伍会元气大伤，那也总要比一直尴尬下去要好。

五月28号的湘潭邀请赛可能是我们的散伙赛了。希望能带他们拿一个银牌，就拿这个银牌来了断全部琐事吧。

加训加训!

yingjiayu12
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Codeforces Round #628 (Div. 2) A~~D
01-03
A #include using namespace std; typedef long long ll; int main(){ int t; cin>>t; while(t--){ ll x; cin>>x; cout<<1>>t; while(t--){ st.clear(); ll n; cin >>n; ll re
Educational Codeforces Round 83 (Rated for Div. 2) D
01-20
今天CF被D恶心到了，写个题解重新整理下思路，（20开始想，25写完暴力代码，1.30才过，优化后的。。 核心思路就是在暴力的基础上进行组合数等差加速。 C(n-2,i-1)*C(j-1,n-2)*(i-1) __ j: n-1 -> m ...
比赛记录:Codeforces Round 870 (Div. 2) A~D
yingjiayu12的博客
05-06 931
比赛记录:Codeforces Round 870 (Div. 2) A~D
Codeforces Round 874 (Div. 3)A-F
LEVIATHANq的博客
05-20 647
思路:这个数组里面所有数值连在一起不是环就是链，如果找最大值就是判断环和链的个数，这个可以用并查集，如果是找最小值的话，就是找最大的环，但是数组中的这些小环是不可能拆开组成最大环的，而链可以一起组成最大环，所以找完最大环后，还有把这些小环的个数加上。再将每一个brr[i]的值填入对应的arr[i]的second中.因为idex组成的3 2 1 是fa的一个排列，所以这是一个环，代码中排断环，我是用异或，即将fa和idex一起异或，得出的数要是0，说明就是个环，否则是个链。思路:太麻烦了，不想说。
比赛记录:Codeforces Round 871 (Div. 4) A~H
yingjiayu12的博客
05-07 570
比赛记录:Codeforces Round 871 (Div. 4) A~H
Codeforces Round 935 (Div. 3) （A~G）
weixin_61825750的博客
03-20 1186
题意：三种人安排住宿,a只能跟自己住,b只能三个人住,c能1~3个人，问最终最少房间数思路：a单独安排,b放一起,不足三个人的用c补,然后c按照3人一房间尽可能分配题意：装置A每a分钟放一次烟花,装置B每b分钟放一次烟花,烟花能存在m分钟,求空中同时存在最多多少烟花.思路：两只烟花必然能同时放,然后再看接下来m分钟能放多少只烟花,这样必然最优题意：给定01串,要求从中间某个位置分开,其中左侧0的数量大于等于1的数量,右侧1的数量大于等于0的数量,求满足条件的最靠近中心的位置。思路：直接模拟。
Educational Codeforces Round 104 Div. 2 A~E
狙击美佐的博客
02-16 1435
Educational Codeforces Round 104 Div. 2 A B C D EA-ArenaCodeB - Cat CycleCodeC - Minimum TiesCodeD - Pythagorean TriplesCodeE - Cheap Dinner 传送门：https://codeforces.com/contest/1487 A-Arena 输出n−最小数的个数。输出n-最小数的个数。输出n−最小数的个数。 Code #include "bits/stdc++.h" us
Codeforces Round 874 (Div. 3)
指针不指南吗的博客
05-21 1089
div 3 的前三道签到题，我太菜了
Codeforces Round #847 (Div. 3) A ~ E
游者的博客
01-29 994
这题还有一个很有意思的地方就是unordered_map哈希表应该是赛后被hack了，如果用hash表这题会T，要用map。
Codeforces Round 871 (Div. 4) A ~ G
weixin_57202646的博客
05-09 715
【代码】Codeforces Round 871 (Div. 4) A ~ G。
Codeforces Round 881 (Div. 3)A~E
m0_62349134的博客
06-21 475
Codeforces Round 881 (Div. 3) A~E 题解
Codeforces Round 855 (Div. 3)（A~F）
m0_62289613的博客
03-03 1444
Codeforces Round 855 (Div. 3)（A~F）
Codeforces Round #627 (Div. 3) B. Yet Another Palindrome Problem
01-03
一个长度为n的数组，为删除一些数后，剩下的数能否构成长度大于3的回文数组 思路： 只要能找到两个相等的数，且他们的间距大于2即可 o(n^2)的暴力就能过 比赛时写了一个o(n)的 就是把所有相等的数放到一个vector里，...
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
Codeforces Round #627 (Div. 3) C. Frog Jumps（思维）
01-20
传送门 题意： 开始位置在0，问能否跳到n+1位置 每步只能跳d 在1——n每个位置有方向，L,R，求d的最小值 思路： 只用找相邻两个R之间的最大值即可 ...#define rep(i,a,b) for(int i=a;i=b;i--) typedef long long l
Leecode---347：输出前k个高频元素（使用unordered_map）
qq_41920323的博客
05-30 335
unordered_map实现输出前k个高频元素
算法每日一题（python,2024.05.24) day.6
L613Z的博客
05-27 601
数字比较型可以用双指针法寻找数字相同（或构成其他关系）的俩个数值（或其他类型），涉及到与数值有关的列表问题可以思考到sort()排序方法加以辅助。
Java多线程（04）—— 保证线程安全的方法与线程安全的集合类
2201_75456895的博客
05-30 1201
其含义为：CAS(M, A, B);M 表示内存，A 和 B 分别表示一个寄存器；如果 M 的值和 A 的值相同，则把 M 和 B 的值交换，如果不同，则无事发生；因为，因此可以基于 CAS 指令，不进行加锁，来编写线程安全代码；CAS 指令操作经过操作系统，JVM 的层层封装，最后 Java 标准库，提供了一些工具类，其中最主要工具类就是由于原子类内部用的是 CAS 实现，所以性能要比加锁实现高很多；在包下；
leetcode74搜索二维矩阵
最新发布
谜底的博客
06-01 435
输入：matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3。给你一个整数 target ，如果 target 在矩阵中，返回 true；否则，返回 false。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值