Codeforces Global Round 1 自闭记

最新推荐文章于 2022-05-03 23:32:56 发布
最新推荐文章于 2022-05-03 23:32:56 发布
阅读量57 收藏
点赞数
原文链接：http://www.cnblogs.com/Gloid/p/10356065.html
版权

　　A：签到。

#include<iostream> 
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;
#define ll long long

char getc(){char c=getchar();while ((c<'A'||c>'Z')&&(c<'a'||c>'z')&&(c<'0'||c>'9')) c=getchar();return c;}
int gcd(int n,int m){return m==0?n:gcd(m,n%m);}
int read()
{
	int x=0,f=1;char c=getchar();
	while (c<'0'||c>'9') {if (c=='-') f=-1;c=getchar();}
	while (c>='0'&&c<='9') x=(x<<1)+(x<<3)+(c^48),c=getchar();
	return x*f;
}
int b,k,a[100010];
signed main()
{
/*#ifndef ONLINE_JUDGE
	freopen("a.in","r",stdin);
	freopen("a.out","w",stdout);
	const char LL[]="%I64d\n";
#endif*/
	b=read(),k=read();b&=1;
	for (int i=1;i<=k;i++) a[i]=read();
	if (b==0)
	{
		if (a[k]&1) cout<<"odd";
		else cout<<"even";
	}
	else
	{
		int s=0;
		for (int i=1;i<=k;i++) s+=a[i];
		if (s&1) cout<<"odd";
		else cout<<"even";
	}
	return 0;
	//NOTICE LONG LONG!!!!!
}

　　B：显然先连接距离较小的点。

#include<iostream> 
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;
#define ll long long
#define N 100010
char getc(){char c=getchar();while ((c<'A'||c>'Z')&&(c<'a'||c>'z')&&(c<'0'||c>'9')) c=getchar();return c;}
int gcd(int n,int m){return m==0?n:gcd(m,n%m);}
int read()
{
	int x=0,f=1;char c=getchar();
	while (c<'0'||c>'9') {if (c=='-') f=-1;c=getchar();}
	while (c>='0'&&c<='9') x=(x<<1)+(x<<3)+(c^48),c=getchar();
	return x*f;
}
int n,m,k,a[N],b[N],ans;
signed main()
{
/*#ifndef ONLINE_JUDGE
	freopen("a.in","r",stdin);
	freopen("a.out","w",stdout);
	const char LL[]="%I64d\n";
#endif*/
	n=read(),m=read(),k=read();
	for (int i=1;i<=n;i++) a[i]=read();
	ans=a[n]-a[1]+1;
	for (int i=2;i<=n;i++) b[i]=a[i]-a[i-1];
	sort(b+2,b+n+1);reverse(b+2,b+n+1);
	for (int i=2;i<=k;i++) ans-=b[i]-1;
	cout<<ans;
	return 0;
	//NOTICE LONG LONG!!!!!
}

　　C：当a!=2k-1时，令k为满足2k-1>a的最小正整数，显然可以令b=2k-1^a使答案成为2k-1，并且显然不可能更优。a=2k-1时直接暴力打表。

#include<iostream> 
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;
#define ll long long
#define N 100010
char getc(){char c=getchar();while ((c<'A'||c>'Z')&&(c<'a'||c>'z')&&(c<'0'||c>'9')) c=getchar();return c;}
int gcd(int n,int m){return m==0?n:gcd(m,n%m);}
int read()
{
	int x=0,f=1;char c=getchar();
	while (c<'0'||c>'9') {if (c=='-') f=-1;c=getchar();}
	while (c>='0'&&c<='9') x=(x<<1)+(x<<3)+(c^48),c=getchar();
	return x*f;
}
int q,ans[1<<25];
signed main()
{
/*#ifndef ONLINE_JUDGE
	freopen("a.in","r",stdin);
	freopen("a.out","w",stdout);
	const char LL[]="%I64d\n";
#endif*/
	q=read();
	for (int i=1;i<=22;i++) 
	{
		for (int j=1;j<(1<<i)-1;j++)
		ans[(1<<i)-1]=max(ans[(1<<i)-1],gcd((1<<i)-1&j,(1<<i)-1^j));
	}
	ans[(1<<23)-1]=178481;
	ans[(1<<24)-1]=5592405;
	ans[(1<<25)-1]=1082401;
	while (q--)
	{
		int x=read();
		if (ans[x]>0) printf("%d\n",ans[x]);
		else
		{
			while (x!=(x&-x)) x^=x&-x;
			printf("%d\n",(x<<1)-1);
		}
	}
	return 0;
	//NOTICE LONG LONG!!!!!
}

　　E：https://www.cnblogs.com/Gloid/p/10060025.html 作为一个做过所谓原题的选手看了1h这个题感到十分自闭。事实上第一眼就想到了这个原题，发现并不一样之后就去梦游了。毕竟当时也不是用前缀和的做法做的，而是自己想了半天搞了个做法还觉得挺nb，反应不过来也挺正常。但现在感觉我这做法好像也能类似的搬过来？自闭了啊？

　　比较差分集合是否相同即可，因为每次操作相当于交换差分数组中相邻两数。注意特判首尾。

#include<iostream> 
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;
#define ll long long
#define N 100010
char getc(){char c=getchar();while ((c<'A'||c>'Z')&&(c<'a'||c>'z')&&(c<'0'||c>'9')) c=getchar();return c;}
int gcd(int n,int m){return m==0?n:gcd(m,n%m);}
int read()
{
	int x=0,f=1;char c=getchar();
	while (c<'0'||c>'9') {if (c=='-') f=-1;c=getchar();}
	while (c>='0'&&c<='9') x=(x<<1)+(x<<3)+(c^48),c=getchar();
	return x*f;
}
int n,q[N<<4],head,tail,cnt;
ll a[N],b[N];
bool flag[N];
signed main()
{
/*#ifndef ONLINE_JUDGE
	freopen("a.in","r",stdin);
	freopen("a.out","w",stdout);
	const char LL[]="%I64d\n";
#endif*/
	n=read();
	for (int i=1;i<=n;i++) a[i]=read();
	for (int i=1;i<=n;i++) b[i]=read();
	if (a[1]!=b[1]||a[n]!=b[n]) {cout<<"No";return 0;}
	for (int i=n;i>=1;i--) a[i]-=a[i-1];
	for (int i=n;i>=1;i--) b[i]-=b[i-1];
	sort(a+1,a+n+1);
	sort(b+1,b+n+1);
	for (int i=1;i<=n;i++) if (a[i]!=b[i]) {cout<<"No";return 0;}
	cout<<"Yes";
	return 0;
	//NOTICE LONG LONG!!!!!
}

　　D：注意到一定存在最优方案使得同种顺子最多出两次。然后就是普及组dp了。我这种弱智怎么可能注意的到啊。

#include<iostream> 
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<vector> 
using namespace std;
#define ll long long
#define N 1000010
char getc(){char c=getchar();while ((c<'A'||c>'Z')&&(c<'a'||c>'z')&&(c<'0'||c>'9')) c=getchar();return c;}
int gcd(int n,int m){return m==0?n:gcd(m,n%m);}
int read()
{
	int x=0,f=1;char c=getchar();
	while (c<'0'||c>'9') {if (c=='-') f=-1;c=getchar();}
	while (c>='0'&&c<='9') x=(x<<1)+(x<<3)+(c^48),c=getchar();
	return x*f;
}
int n,m,u,a[N],f[N][3][3];
signed main()
{
#ifndef ONLINE_JUDGE
	freopen("a.in","r",stdin);
	freopen("a.out","w",stdout);
	const char LL[]="%I64d\n";
#endif
	n=read(),m=read();
	for (int i=1;i<=n;i++) a[read()]++;
	memset(f,200,sizeof(f));
	f[0][0][0]=0;
	for (int i=1;i<=m+2;i++)
		for (int j=0;j<=2;j++)
			for (int k=0;k<=2;k++)
				for (int x=0;x<=2;x++)
				if (k<=a[i]&&j+k<=a[i-1]&&j+k+x<=a[i-2])
				f[i][j][k]=max(f[i][j][k],f[i-1][x][j]+x+(a[i-2]-j-k-x)/3);
	cout<<f[m+2][0][0];
	return 0;
	//NOTICE LONG LONG!!!!!
}

　　F：对dfs序建线段树维护当前点到每个点的距离（非叶子设为inf），询问按dfs序离线，然后整棵树dfs一遍并维护距离即可，这个维护仅仅是线段树上的区间加和区间减。我觉得比D简单多了！算了云选手没资格说话。

#include<iostream> 
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
#define ll long long
#define N 500010
#define inf 100000000000000000ll
char getc(){char c=getchar();while ((c<'A'||c>'Z')&&(c<'a'||c>'z')&&(c<'0'||c>'9')) c=getchar();return c;}
int gcd(int n,int m){return m==0?n:gcd(m,n%m);}
int read()
{
	int x=0,f=1;char c=getchar();
	while (c<'0'||c>'9') {if (c=='-') f=-1;c=getchar();}
	while (c>='0'&&c<='9') x=(x<<1)+(x<<3)+(c^48),c=getchar();
	return x*f;
}
int n,m,fa[N],p[N],len[N],dfn[N],id[N],L[N<<2],R[N<<2],size[N],t,cnt,cur;
ll deep[N],ans[N],tree[N<<2],lazy[N<<2];
struct data
{
	int to,len;
	bool operator <(const data&a) const
	{
		return to<a.to;
	}
};
vector<data> edge[N];
struct data2
{
	int x,l,r,i;
	bool operator <(const data2&a) const
	{
		return dfn[x]<dfn[a.x];
	}
}q[N];
void addedge(int x,int y,int z){edge[x].push_back((data){y,z});}
void dfs(int k)
{
	dfn[k]=++cnt;id[cnt]=k;size[k]=1;
	for (int i=0;i<edge[k].size();i++)
	{
		deep[edge[k][i].to]=deep[k]+edge[k][i].len;
		dfs(edge[k][i].to);
		size[k]+=size[edge[k][i].to];
	}
	if (edge[k].size()) deep[k]=inf;
}
void up(int k){tree[k]=min(tree[k<<1],tree[k<<1|1]);}
void build(int k,int l,int r)
{
	L[k]=l,R[k]=r;
	if (l==r)
	{
		tree[k]=deep[id[l]];
		return;
	}
	int mid=l+r>>1;
	build(k<<1,l,mid);
	build(k<<1|1,mid+1,r);
	up(k);
}
void update(int k,ll x){tree[k]+=x;lazy[k]+=x;}
void down(int k){update(k<<1,lazy[k]),update(k<<1|1,lazy[k]),lazy[k]=0;}
void add(int k,int l,int r,int x)
{
	if (l>r) return;
	if (L[k]==l&&R[k]==r) {update(k,x);return;}
	if (lazy[k]) down(k);
	int mid=L[k]+R[k]>>1;
	if (r<=mid) add(k<<1,l,r,x);
	else if (l>mid) add(k<<1|1,l,r,x);
	else add(k<<1,l,mid,x),add(k<<1|1,mid+1,r,x);
	up(k);
}
ll query(int k,int l,int r)
{
	if (L[k]==l&&R[k]==r) return tree[k];
	if (lazy[k]) down(k);
	int mid=L[k]+R[k]>>1;
	if (r<=mid) return query(k<<1,l,r);
	else if (l>mid) return query(k<<1|1,l,r);
	else return min(query(k<<1,l,mid),query(k<<1|1,mid+1,r));
}
void work(int k)
{
	while (k==q[cur+1].x) cur++,ans[q[cur].i]=query(1,q[cur].l,q[cur].r);
	for (int i=0;i<edge[k].size();i++)
	{
		int to=edge[k][i].to;
		add(1,dfn[to],dfn[to]+size[to]-1,-edge[k][i].len);
		add(1,1,dfn[to]-1,edge[k][i].len);
		add(1,dfn[to]+size[to],n,edge[k][i].len);
		work(to);
		add(1,dfn[to],dfn[to]+size[to]-1,edge[k][i].len);
		add(1,1,dfn[to]-1,-edge[k][i].len);
		add(1,dfn[to]+size[to],n,-edge[k][i].len);
	}
}
signed main()
{
#ifndef ONLINE_JUDGE
	freopen("a.in","r",stdin);
	freopen("a.out","w",stdout);
#endif
	n=read(),m=read();
	for (int i=2;i<=n;i++)
	{
		fa[i]=read();len[i]=read();
		addedge(fa[i],i,len[i]);
	}
	for (int i=1;i<=n;i++) sort(edge[i].begin(),edge[i].end());
	dfs(1);
	for (int i=1;i<=m;i++) q[i].x=read(),q[i].l=read(),q[i].r=read(),q[i].i=i;
	sort(q+1,q+m+1);
	build(1,1,n);
	work(1);
	for (int i=1;i<=m;i++) printf("%I64d\n",ans[i]);
	return 0;
	//NOTICE LONG LONG!!!!!
}

　　div1+div2的场从来没进过前400，自闭了。

　　result：rank 420 rating +22

 

转载于:https://www.cnblogs.com/Gloid/p/10356065.html

weixin_30666753
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Codeforces Round #526 Div. 1 自闭记
weixin_30740295的博客
12-11 59
　　日常猝死。 　　A：f[i]表示子树内包含根且可以继续向上延伸的路径的最大价值，统计答案考虑合并两条路径即可。 #include<iostream> #include<cstdio> #include<cmath> #include<cstdlib> #include<cstring> #include<...
codeforce打自闭了
woshixuxiran的博客
02-17 395
打自闭了，存一堆恶劣情绪在这儿，以后再来安慰这时候的自己。明天反正老老实实补题、看题、写报告。
Codeforces Round #703 (Div. 2) （自闭场）
godhandsjoker的博客
02-19 2512
A. Shifting Stacks 这题我能记很久，直接给我打自闭了，从开赛一直到了最后，我就一个菜鸡 题意非常简单，给你n个数，让你把他们构造成递增的，然后只能从后往前，你直接想就行了，直接构造0 1 2 3 4 5 6 7 8 9…n如果可以的话，就是yes，不可以的话就是no 然后上我第一遍的代码 #include <bits/stdc++.h> #define int long long #define BUFF ios::sync_with_stdio(false), cin.t
Codeforces 1073A——防自闭
hao_zong_yin的博客
11-02 341
#include &lt;bits/stdc++.h&gt; using namespace std; const int maxn = 1010; int n; char s[maxn]; int cnt[26]; int main() { scanf("%d", &amp;n); scanf("%s", s); bool ans = false; for (i...
Codeforces 1073B——防自闭
hao_zong_yin的博客
11-02 328
#include &lt;bits/stdc++.h&gt; using namespace std; const int maxn = 2e5 + 10; int n, a[maxn], b[maxn], pos[maxn], vis[maxn]; int main() { scanf("%d", &amp;n); for (int i = 1; i &lt;= n; i++)...
Codeforces Global Round 20记录
nth2000的博客
05-03 550
C-Unequal Array（GOOD） 思路
Codeforces Global Round 15
小德子的博客
07-27 269
题目列表A、Subsequence PermutationB、Running for GoldC、Maximize the Intersections A、Subsequence Permutation 题目链接：Subsequence Permutation 题意：你有一个序列a，你现在可以选择a中一个不连续的子序列b，对子序列按照字典序排序后依次放回序列a，使得a序列是按照字典序顺序的，要求求出b序列的最小长度。 思路：我们可以很容易的想到，如果按照字典序排序的a序列变成了了c，那么b序列的最小值，便
Codeforces Global Round 3
weixin_30904593的博客
06-02 112
A 签到，开long long（不开也pp不了） #include<bits/stdc++.h> using namespace std; long long a,b,ans; int main() { cin>>a>>b>>ans;ans*=2; if(a==b)ans+=a*2; els...
Codeforces Global Round 4 题解
angzuo8655的博客
07-21 116
技不如人，肝败吓疯…… 开场差点被 A 题意杀了，幸好仔细再仔细看，终于在第 7 分钟过掉了。 跟榜。wtf 怎么一群人跳题/倒序开题？ 立刻紧张，把 BC 迅速切掉，翻到了 100+。 开 D。感觉有点吓人……感觉有点可做？ 的确挺可做。再切掉 D，但是此时已经到 300+ 了。 没事，还能翻。 开 E。这……什么玩意？ 瞄了一眼 F1，…… 盯着这两题盯到自闭。 ...
Codeforces global round 10_Codeforces_
10-01
Codeforces全球第十轮比赛是编程竞赛平台Codeforces举办的一场线上编程比赛，旨在挑战参赛者的算法设计、逻辑思维和编程技巧。在这个比赛中，参赛者通常需要解决一系列算法问题，涵盖数据结构、图论、动态规划、数学...
Codeforces Global Round 7 C. Permutation Partitions
01-03
给定一个 1−n 上的全排列，将这个全排列分成不相交的 k 段，定义该划分的value为各段最大值的和，求该全排列所有可能划分中 value的最大值和满足value最大的划分情况的个数 解题思路 求k个区间的最大值之和的最大值...
Codeforces Global Round 7 A. Bad Ugly Numbers
01-03
A. Bad Ugly Numbers 题目链接-A. Bad Ugly Numbers 题目大意 输出一个位数为n的数s，且该数每一位数字都不能被s整除 解题思路 贪心 如果n为1，那么无论s是哪个数字都...const int dir[4][2]={-1,0,1,0,0,-1,0,1}; c
Codeforces Global Round 13 A-E题解
我是谁 --- 卡比兽
03-02 309
A 01序列，一个操作对某一位取反，一个操作问你当前第k大是多少 维护一个当前最后一个1所在排名 #include <cstdio> using namespace std; const int MAX_N = 100025; int arr[MAX_N]; int main() { int n,m,sum = 0; scanf("%d%d",&n,&m); for(int i = 1;i<=n;++i) { scanf("%
2024-2030全球与中国硅胶婴儿用品市场现状及未来发展趋势 Sample-Li Jinpan.pdf
09-05
QYResearch是全球知名的大型咨询公司，行业涵盖各高科技行业产业链细分市场，横跨如半导体产业链（半导体设备及零部件、半导体材料、集成电路、制造、封测、分立器件、传感器、光电器件）、光伏产业链（设备、硅料/硅片、电池片、组件、辅料支架、逆变器、电站终端）、新能源汽车产业链（动力电池及材料、电驱电控、汽车半导体/电子、整车、充电桩）、通信产业链（通信系统设备、终端设备、电子元器件、射频前端、光模块、4G/5G/6G、宽带、IoT、数字经济、AI）、先进材料产业链（金属材料、高分子材料、陶瓷材料、纳米材料等）、机械制造产业链（数控机床、工程机械、电气机械、3C自动化、工业机器人、激光、工控、无人机）、食品药品、医疗器械、农业等。
用于非线性模型预测控制 (NMPC) 的并行优化工具包.7z
09-05
用于非线性模型预测控制 (NMPC) 的并行优化工具包.7z
Flow-Guided-Feature-Aggregation研究基于视频的目标检测FGFA框架.zip
最新发布
09-05
目标检测（Object Detection）是计算机视觉领域的一个核心问题，其主要任务是找出图像中所有感兴趣的目标（物体），并确定它们的类别和位置。以下是对目标检测的详细阐述： 一、基本概念 目标检测的任务是解决“在哪里？是什么？”的问题，即定位出图像中目标的位置并识别出目标的类别。由于各类物体具有不同的外观、形状和姿态，加上成像时光照、遮挡等因素的干扰，目标检测一直是计算机视觉领域最具挑战性的任务之一。 二、核心问题 目标检测涉及以下几个核心问题： 分类问题：判断图像中的目标属于哪个类别。 定位问题：确定目标在图像中的具体位置。 大小问题：目标可能具有不同的大小。 形状问题：目标可能具有不同的形状。 三、算法分类 基于深度学习的目标检测算法主要分为两大类： Two-stage算法：先进行区域生成（Region Proposal），生成有可能包含待检物体的预选框（Region Proposal），再通过卷积神经网络进行样本分类。常见的Two-stage算法包括R-CNN、Fast R-CNN、Faster R-CNN等。 One-stage算法：不用生成区域提议，直接在网络中提取特征来预测物体分类和位置。常见的One-stage算法包括YOLO系列（YOLOv1、YOLOv2、YOLOv3、YOLOv4、YOLOv5等）、SSD和RetinaNet等。 四、算法原理 以YOLO系列为例，YOLO将目标检测视为回归问题，将输入图像一次性划分为多个区域，直接在输出层预测边界框和类别概率。YOLO采用卷积网络来提取特征，使用全连接层来得到预测值。其网络结构通常包含多个卷积层和全连接层，通过卷积层提取图像特征，通过全连接层输出预测结果。 五、应用领域 目标检测技术已经广泛应用于各个领域，为人们的生活带来了极大的便利。以下是一些主要的应用领域： 安全监控：在商场、银行
习题集计算机原理习题集
09-05
【习题集】计算机原理习题集 计算机原理习题集 习题 一 1．微型计算机的发展经历了哪几个时代？每个时代有哪些主要特点？ 2．简述Pentium4 微处理器的处理能力。 3．冯·诺依曼计算机的结构特点是什么？ 4．典型微机有哪三大总线？它们传送的是什么信息？ 5．什么叫微处理器？什么叫微型计算机？什么叫微型计算机系统？这三者有什么区别和联系？ 6．微处理器内部一般由哪些部分组成？各部分的主要功能是什么？ 7．试用示意图说明内存单元的地址和内存单元的内容，二者有何联系和区别？ 8．高级语言、汇编语言、机器语言有何区别？各有何特点？ 9．评价微型计算机性能的主要指标有哪些？试举例说明现在市场主流机型微型计算机的性能参数。 10．现代微型计算机的主板通常由哪些部分组成？主板上的总线扩展插槽有何用途？ 习题 二 1．8086CPU从功能上分为哪两个工作部件？每个工作部件的功能、组成和特点分别是什么？ 2．8086CPU中有几个通用寄存器，有几个变址寄存器，有几个地址指针寄存器？它们中通常哪几个寄存器可作为地址寄存器使用？ 3．8086CPU的标志寄存器中有哪些标志位？它们的含义和作用是什么？
基于Spring Boot框架的尚融宝网络借贷平台.zip
09-05
基于Spring Boot框架的尚融宝网络借贷平台 项目介绍 尚融宝是一个网络借贷信息中介服务平台，致力为高成长人群提供专业的线上信贷及出借撮合服务。行业案例包括人人贷、拍拍贷等。 技术架构 前端 Node.js: Js运行环境 ES6: Js模块化版本 Axios: Ajax请求工具 Vue.js: 前端框架 ElementUI: 前端组件库 Vueelementadmin: 后台管理系统UI集成方案 NuxtJS: 前端服务器 后端 SpringBoot: 微服务开发框架 SpringCloud: 微服务组件库 SpringCloud Alibaba: 阿里微服务组件库 MyBatis Plus: 持久层框架 Swagger2: API接口文档生成工具 LogBack: 日志系统 alibabaeasyExcel: Excel读写框架 Redis: 缓存中间件 MySQL: 关系型数据库 SpringTask: 定时任务 RabbitMQ: 消息中间件 项目结构 前端 srbadmin: 管理平台 srbsi
codeforces global round 16
03-16
好的，Codeforces 全球赛第 16 场已于 2022 年 7 月 31 日举行。这是一场由 Codeforces 组织的在线编程比赛，涉及算法和数据结构等方面的知识，吸引了来自全球各地的编程爱好者参加。 比赛包括 6 个问题，难度从 A ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值