Codeforces Global Round 1 自闭记

　　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

时间： 2024-11-09 01:53:11

Codeforces Global Round 1 自闭记的相关文章

Codeforces Global Round 1 (A-E题解)

Codeforces Global Round 1 题目链接:https://codeforces.com/contest/1110 A. Parity 题意: 给出{ak},b,k,判断a1*b^(k-1)+a2*b^(k-2)+...+ak*b^0的奇偶性. 题解: 暴力求模2意义下的值就好了. 代码如下: #include <bits/stdc++.h> using namespace std; typedef long long ll; const int N = 2e5+5; int

【手抖康复训练1 】Codeforces Global Round 6

[手抖康复训练1 ]Codeforces Global Round 6 总结:不想复习随意打的一场,比赛开始就是熟悉的N分钟进不去时间,2333,太久没写题的后果就是:A 题手抖过不了样例 B题秒出思路手抖过不了样例,C题秒出思路手抖过不了样例*3 D题 手抖 过的了样例 ,调了1h,赛后发现变量名写错了,改一个字符就能AC... 题目等补完题一起放上来QAQ 原文地址:https://www.cnblogs.com/ttttttttrx/p/12110199.html

Frets On Fire --- 2019 Codeforces Global Round 2 Problem D

原题:https://codeforces.com/contest/1119/problem/D 题意大概是一个n行1e18列的矩阵,其中每行第一个数为s[i],剩下的数每行依次以1的速度递增.就是说,矩阵元素 a[i][j] = s[i] + j .有q个询问,每个询问有两个参数l,r,求矩阵第l列到第r列(所有行)一共出现了几个不同的数. 这道题首先要先想到,两个参数 [l,r] 其实等价于一个参数 [0,r-l] ,也就是说矩阵第0~r-l行出现的数字的个数其实和第l-r行出现的个数是一样

Codeforces Global Round 4 题解

技不如人,肝败吓疯…… 开场差点被 A 题意杀了,幸好仔细再仔细看,终于在第 7 分钟过掉了. 跟榜.wtf 怎么一群人跳题/倒序开题? 立刻紧张,把 BC 迅速切掉,翻到了 100+. 开 D.感觉有点吓人……感觉有点可做? 的确挺可做.再切掉 D,但是此时已经到 300+ 了. 没事,还能翻. 开 E.这……什么玩意? 瞄了一眼 F1,…… 盯着这两题盯到自闭. 最后 rk 1000 左右.我的名字颜色真的是对的吗…… A 看懂题了就是水题.选上所有小于等于第一个党派一半人数的党派,如果不行

Codeforces Global Round 7 题解

A 一种合法构造方式是\(299\cdots 9\) code B 发现每次的\(x_{i-1}\)都是知道的,于是可以直接递推. code C 最终答案所选的数一定是\(n-k+1\)到\(n\)的所有数.把这些数所在的位置记作\(p_1,p_2,\cdots,p_k\). 不难发现每个\(r_i\in [p_i,p_{i+1})\),于是答案就是\(\prod (p_{i+1}-p_i)\). code D 首先把首尾能构成回文的部分删掉,因为这部分一定会出现在答案中. 问题变成了在当前字符

[Codeforces]Codeforces Global Round 1

A - Parity 题意 给定一个$b$进制数,要求输出它在十进制下是奇数还是偶数. 分析 花了我略多的时间,首先题目中给的数字范围很大,不能直接转化为10进制. 分析性质,发现只有奇数乘奇数还是奇数,其他都是偶数. 对奇数进制和偶数进制分类讨论. 偶数进制看最低位的奇偶性,如果是奇数那么这个数就是奇数,不然是偶数. 奇数进制看每一位上奇数的个数,如果是奇数个奇数就是奇数,不然是偶数. 代码 1 #include <bits/stdc++.h> 2 using namespace std;

【 Codeforces Global Round 1 B】Tape

[链接] 我是链接,点我呀:) [题意] x轴上有m个连续的点,从1标号到m. 其中有n个点是特殊点. 让你用k段区间将这n个点覆盖. 要求区间的总长度最小. [题解] 一开始假设我们需要n个胶带(即包含每一个点) 然后因为k<=n 所以可能胶带不够用. 那么就得一个胶带跨过两个点. 怎么选择最好呢? 可以把b[i]-b[i-1]-1处理出来排个序. (优先取较小的花费) 然后取前n-k个累加和sum. 因为每取一个就少用一段胶带. 然后sum+n就是答案了 [代码] import java.i

【Codeforces Global Round 1 C】Meaningless Operations

[链接] 我是链接,点我呀:) [题意] 给你一个a 让你从1..a-1的范围中选择一个b 使得gcd(a^b,a&b)的值最大 [题解] 显然如果a的二进制中有0的话. 那么我们就让选择的b的二进制中对应的位置为1 剩下全为0就好 这样a的二进制全都变成1之后就是答案了(gcd的右边是0). 但是如果a的二进制里面全是1的话. 就没办法这么构造了 这里有两种情况. ①.1的个数是偶数 那么就101010这样构造 另外一个数就是010101 答案就是010101转换成十进制 ②.1的个数是奇数

Codeforces Global Round 1

A. Parity 签. 1 #include <bits/stdc++.h> 2 using namespace std; 3 4 #define N 100010 5 int b, k, a[N]; 6 7 int main() 8 { 9 while (scanf("%d%d", &b, &k) != EOF) 10 { 11 int res = 0; 12 for (int i = 1; i <= k; ++i) scanf("%d&