Codeforces Round #956 (Div. 2) and ByteRace 2024

最新推荐文章于 2024-09-12 19:02:20 发布
最新推荐文章于 2024-09-12 19:02:20 发布
阅读量1k 收藏 29
点赞数 15
分类专栏： Codeforces 文章标签： 算法 c++ 数据结构 概率论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HKUST_ZJH/article/details/140441348
版权

前言

        比赛节奏没把握好，最后时间上出了点问题。

        题目链接：Dashboard - Codeforces Round #956 (Div. 2) and ByteRace 2024 - Codeforces

A. Array Divisibility

        简单构造，容易发现序列 "1,2,3,......,n" 满足条件。

#include<cstdio>
#include<cstring>
using namespace std;

int T,n;

int main()
{
	scanf("%d",&T);
	while (T --)
	{
		scanf("%d",&n);
		for (int i = 1;i <= n;++ i) printf("%d ",i);
		printf("\n");
	}
	return 0;
}

B. Corner Twist

        这可能是本人在 cf 比赛中见过的最难的第二题。

        但与其说难，不如说是脑筋急转弯，弯没转过来就是想不到了。

        首先比较明显的是必要性：由于每次变化，选定矩阵的每一条边所在的行 / 列的变化量 mod 3 都为 0 ，也就是说合法的答案矩阵的每一行和每一列的数字和与原矩阵对应的每一行和每一列的数字和在模 3 的意义下同余。

        接下来证明这个条件的充分性：即要证若 A，B 矩阵满足每一行和每一列的数字和在模 3 的意义下同余，则 A，B 矩阵可以互相转化 。首先可以发现所有选定变化矩阵都可以由最小的 2*2 矩阵叠加产生。那么我们可以从（1,1）开始到（n - 1，m - 1）使得 A 中这个（n - 1）*（m - 1）的矩阵变成和 B 中的相同，再根据必要性可知，剩下的这 （n + m - 1）个数字可以通过其所在的行列的数字和 mod 3 确定，于是乎两个矩阵的所有数字都可以相同，充分性证明完毕。

        这样一来判断就易如反掌了。

#include<cstdio>
#include<cstring>
using namespace std;

#define N 505

int T,n,m,a[N][N],b[N][N];
char s[N];

int main()
{
	scanf("%d",&T);
	while (T --)
	{
		scanf("%d%d",&n,&m);
		for (int i = 1;i <= n;++ i)
		{
			scanf("%s",s + 1);
			for (int j = 1;j <= m;++ j) a[i][j] = s[j] - '0';
		}
		for (int i = 1;i <= n;++ i)
		{
			scanf("%s",s + 1);
			for (int j = 1;j <= m;++ j) b[i][j] = s[j] - '0';
		}
		int tot,num,flag;
		flag = 1;
		for (int i = 1;i <= n;++ i)
		{
			tot = num = 0;
			for (int j = 1;j <= m;++ j) tot += a[i][j],num += b[i][j];
			if(tot % 3 != num % 3) flag = 0;
		}
		for (int j = 1;j <= m;++ j)
		{
			tot = num = 0;
			for (int i = 1;i <= n;++ i) tot += a[i][j],num += b[i][j];
			if(tot % 3 != num % 3) flag = 0;
		}
		if(flag) printf("YES\n");
		else printf("NO\n");
	}
	return 0;
}

C. Have Your Cake and Eat It Too

        直接依题意分 6 种情况讨论就好了，个人认为思考难度比 B 题简单不少。

#include<cstdio>
#include<cstring>
using namespace std;

#define N 200005

int T,n,a[N][5],ans[10];
long long tot,bar;

int work(int x)
{
	long long pre = 0ll;
	int ind = 0;
	while (ind < n && pre < bar) ++ ind,pre += 1ll * a[ind][x];
	if(ind >= n - 1) return 0;
	ans[x * 2 + 1] = 1,ans[x * 2 + 2] = ind;
	int y = (x + 1) % 3;
	pre = 0ll;
	ans[y * 2 + 1] = ind + 1;
	while (ind < n && pre < bar) ++ ind,pre += 1ll * a[ind][y];
	ans[y * 2 + 2] = ind;
	int z = (y + 1) % 3;
	pre = 0ll;
	ans[z * 2 + 1] = ind + 1,ans[z * 2 + 2] = n;
	while (ind < n) ++ ind,pre += 1ll * a[ind][z];
	if(pre >= bar)
	{
		for (int i = 1;i <= 6;++ i) printf("%d ",ans[i]);
		printf("\n");
		return 1;
	}
	ind = ans[y * 2 + 1] - 1;
	y = (x + 2) % 3;
	pre = 0ll;
	ans[y * 2 + 1] = ind + 1;
	while (ind < n && pre < bar) ++ ind,pre += 1ll * a[ind][y];
	ans[y * 2 + 2] = ind;
	z = (x + 1) % 3;
	pre = 0ll;
	ans[z * 2 + 1] = ind + 1,ans[z * 2 + 2] = n;
	while (ind < n) ++ ind,pre += 1ll * a[ind][z];
	if(pre >= bar)
	{
		for (int i = 1;i <= 6;++ i) printf("%d ",ans[i]);
		printf("\n");
		return 1;
	}
	return 0;
}

int main()
{
	scanf("%d",&T);
	while (T --)
	{
		scanf("%d",&n),tot = bar = 0ll;
		for (int i = 1;i <= n;++ i) scanf("%d",&a[i][0]),tot += 1ll * a[i][0];
		for (int i = 1;i <= n;++ i) scanf("%d",&a[i][1]);
		for (int i = 1;i <= n;++ i) scanf("%d",&a[i][2]);
		bar = (!(tot % 3ll)) ? (tot / 3ll) : (tot / 3ll + 1);
		int now = 0;
		now = work(0);
		if(!now) now = work(1);
		if(!now) now = work(2);
		if(!now) printf("-1\n");
	}
	return 0;
}

D. Swap Dilemma

        容易证明，合法序列的所有操作都可以只交换相邻的某两位来满足条件，于是这道题变成了一个求逆序对数量的问题。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

#define N 200005

int T,n,a[N],b[N],c[N],d[N],t[N],tr[N];
long long tot;

int lowbit(int x) { return x & -x ; }

void add(int x)
{
	for (int i = x;i <= n;i += lowbit(i))
		++ tr[i];
	return;
}

long long ask(int x)
{
	long long tmp = 0ll;
	for (int i = x; i ;i -= lowbit(i))
		tmp += 1ll * tr[i];
	return tmp;
}

int main()
{
	scanf("%d",&T);
	while (T --)
	{
		scanf("%d",&n),tot = 0ll;
		for (int i = 1;i <= n;++ i) scanf("%d",&a[i]),c[i] = a[i],t[a[i]] = i,a[i] = i,tr[i] = 0;
		for (int i = 1;i <= n;++ i) scanf("%d",&b[i]),d[i] = b[i],b[i] = t[b[i]];
		sort(c + 1,c + n + 1);
		sort(d + 1,d + n + 1);
		int flag = 1;
		for (int i = 1;i <= n;++ i)
			if(c[i] != d[i]) flag = 0;
		if(!flag)
		{
			printf("NO\n");
			continue;
		}
		for (int i = 1;i <= n;++ i)
			tot += ask(n) - ask(b[i]),add(b[i]);
		if(tot & 1) printf("NO\n");
		else printf("YES\n");
	}
	return 0;
}

E. I Love Balls

        数学题，求期望。

        球被分成普通球和特殊球，取到特殊球就可以继续再取，那么每一次取得球的组成一定是若干个（可以为 0 个）特殊球 + 一个普通球（最后一次取球除外）。因此可以发现两个人分别取得的普通球的数目是确定的，于是我们可以将普通球和特殊球分别计算期望。

        接下来我们只求 Alice 的期望，Bob 的用总和减去即可得到。

        1. 普通球：

            期望：\frac{\lfloor \frac{n - k + 1}{2} \rfloor }{n - k} \sum_{i = k + 1} ^ {n} v_i

        2. 特殊球：对于特殊球的归属，我们可以先把普通球排成一排，产生 （n - k + 1）个空隙，将 k 个特殊球投到这些空隙里，每个空隙里的特殊球和它右边那个普通球捆绑作为一次选球的组合。于是选特殊球就转换成了选空隙。

            期望：\frac{\lfloor \frac{n - k + 2}{2} \rfloor }{n - k + 1} \sum_{i = 1}^k v_i

        注意取模的时候用费马小定理和乘法逆元。

#include<cstdio>
#include<cstring>
using namespace std;

#define N 500005
#define M 1000000007

int T,n,k;
long long epk,epv,a[N],sumk,sumv,ansA,ansE;

long long ksm(long long x,long long p)
{
	long long tmp = 1ll;
	while (p)
	{
		if(p & 1) tmp = tmp * x % M;
		x = x * x % M;
		p >>= 1;
	}
	return tmp;
}

int main()
{
	scanf("%d",&T);
	while (T --)
	{
		scanf("%d%d",&n,&k),sumk = sumv = 0ll;
		for (int i = 1;i <= n;++ i)
		{
			scanf("%lld",&a[i]);
			if(i <= k) sumk = (sumk + a[i]) % M;
			else sumv = (sumv + a[i]) % M;
		}
		if((n - k + 2) & 1) epk = 1ll * sumk % M * ksm(2ll,M - 2ll) % M;
		else epk = 1ll * ((n - k + 2) / 2) % M * sumk % M * ksm((long long)(n - k + 1),M - 2ll) % M;
		n -= k;
		if((n + 1) & 1) epv = sumv * ksm(2ll,M - 2ll) % M;
		else epv = 1ll * (n + 1) * sumv % M * ksm(2ll * n,M - 2ll);
		ansA = (epk + epv) % M;
		ansE = (sumk + sumv - ansA + M) % M;
		printf("%lld %lld\n",ansA,ansE);
	}
	return 0;
}

F. array-value

        看到找第 k 小，自然想到可能是二分答案。

        二分异或值，求出异或值小于等于这个值的子数组数目，若数目大于等于 k 则记录答案，r = mid - 1 继续找。那么关键是如何快速求出这些子数组的数目。

        异或题自然想到 trie 树，从第一位开始一个个加进 trie，对于当前的 a_i 要找到 trie 中最大的一个 j 使得 a_i xor a_j 小于等于这个二分值。用每次得到的这个 j 更新 mx （mx 表示的是最近的可以满足条件的子数组的左端点，即 [mx,i] 范围内的子数组满足条件，那么很显然对于当前的右端点 i ，左端点在 [1,mx] 范围内都可以满足条件），那么当前的右端点 i 的贡献就是 mx（初始值为0）。

        在 trie 上找小于等于二分的这个异或值时有个技巧，记二分的这个值为 bar ，我们 ++ bar，这样我们要找的就是小于这个新的 bar 的东西了，这么做会方便不少，程序更加简洁。

#include<cstdio>
#include<cstring>
using namespace std;

#define N 100005

int T,n,m,tr[N * 50][2],vis[N * 50][2],id[N * 50][2],cnt;
long long a[N],k,ans;

int max(int x,int y) { return x > y ? x : y ; }

void insert(long long x,int y)
{
	int now = 0;
	for (int i = 30;i >= 0;-- i)
	{
		int tmp = (x >> i) & 1ll;
		if(vis[now][tmp] == cnt) id[now][tmp] = max(id[now][tmp],y),now = tr[now][tmp];
		else vis[now][tmp] = cnt,tr[now][tmp] = ++ m,id[now][tmp] = y,now = tr[now][tmp];
	}
	return;
}

int ask(long long x,long long y)
{
	int now,t;
	now = t = 0,++ y;
	for (int i = 30;i >= 0;-- i)
	{
		int tmp = (x >> i) & 1ll;
		int bar = (y >> i) & 1ll;
		if(bar)
		{
			if(vis[now][tmp] == cnt) t = max(t,id[now][tmp]);
			if(vis[now][tmp ^ 1] == cnt) now = tr[now][tmp ^ 1];
			else return t;
		}
		else
		{
			if(vis[now][tmp] == cnt) now = tr[now][tmp];
			else return t;
		}
	}
	return t;
}

int check(long long x)
{
	++ cnt,m = 0;
	insert(a[1],1);
	int mx = 0;
	long long tmp = 0ll;
	for (int i = 2;i <= n;++ i)
	{
		mx = max(mx,ask(a[i],x));
		tmp += 1ll * mx;
		insert(a[i],i);
	}
	return (tmp >= k);
}

int main()
{
	memset(tr,0,sizeof tr);
	memset(vis,0,sizeof vis);
	scanf("%d",&T),cnt = 0;
	while (T --)
	{
		scanf("%d%lld",&n,&k),ans = 0ll;
		for (int i = 1;i <= n;++ i) scanf("%lld",&a[i]);
		long long l = 0ll;
		long long r = (1ll << 30);
		while (l <= r)
		{
			long long mid = (l + r) >> 1;
			if(check(mid)) ans = mid,r = mid - 1ll;
			else l = mid + 1ll;
		}
		printf("%lld\n",ans);
	}
	return 0;
}

总结

        这个月做下来感觉思维有进步，但是在这次比赛 B 题缺乏了 “大胆假设，小心求证” 的心理而浪费了特别多的时间。像 E、F 这些难度的题是可以自己独立思考出来的，只是比赛时由于解题速度，切掉的难度暂时可能有点大 （但只要前面的题快点做出来还是有希望的）。

        总的来说状态越来越好了，应该差不多恢复到了之前的水平，思维能力也会比之前更强，但是和大佬相比仍有很大提升空间，继续加油。

HKUST_ZJH
关注
专栏目录
Codeforces Round #956 (Div. 2) and ByteRace 2024（A~D题解）
2301_80475191的博客
07-08 1333
这次比赛也是比较吃亏的，做题顺序出错了，先做的第三个，错在第三个数据点之后，才做的第二个（因为当时有个地方没检查出来）所以这次比赛还是一如既往地打拉了那么就来发一下题解吧题意：对于1
Codeforces Round #956 (Div. 2) (A-D) python
wyzkeyy的博客
07-08 590
久违的写出了4题，希望python重测不要tle┌( ´_ゝ` )┐。
Codeforces Round #956 (Div. 2)A-C解题报告
xhg420的博客
07-15 257
题目类型：构造。解题思路：每个数都是自己因数的倍数，所以直接构造a[i]=i。
Codeforces Round 956 (Div. 2) 部分题解A~C
ZZZioz的博客
07-08 779
给定操作，可以选择一个矩形的一条对角线上的两个端点，让他们加1/2；另一条对角线的端点值加2/1，然后对这些值取模3。考虑网格的边上的值，边上的值的变化会受到其他的影响，所以我们优先去找如何让边上的值相等即可。所有j的aj之和可以被k整除，其中j是k的倍数，k的取值为1~n。问如何分配蛋糕，使三个人获得的蛋糕价值均高于蛋糕价值和的三分之一。给定a和b两个网格，网格中只存在0、1、2三种值。三个人吃蛋糕，每个人对蛋糕不同位置有自己的估价。正扫一遍，反扫一遍，然后比较数组即可。分类讨论：三个人拿蛋糕的顺序。
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
Codeforces Round #833 (Div. 2) 思路
m0_75212691的博客
11-22 249
Codeforces Round #833 (Div. 2) 思路
Codeforces Round #627 (Div. 3) C. Frog Jumps（思维）
01-20
传送门 题意： 开始位置在0，问能否跳到n+1位置 每步只能跳d 在1——n每个位置有方向，L,R，求d的最小值 思路： 只用找相邻两个R之间的最大值即可 代码： #include #include ...typedef long long l
Codeforces Round #627 (Div. 3) B. Yet Another Palindrome Problem
01-03
就是把所有相等的数放到一个vector里，如果他出现大于2次，看最远的间距是否大于2即可，找到一个就可以 代码： #include #include #include #include #include #include #include #include #include #include #...
题解 Codeforces Round #814 (Div. 1/2)
im_zyINF的博客
08-17 370
Codeforces
算法刷题：300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组、1143. 最长公共子序列
最新发布
qq_61936886的博客
09-12 479
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;2.递推公式：当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
算法知识点——常用输入输出数据的方式
5233的博客
09-12 275
除了换行之外，还会清空缓存区，而清空缓存区这件事情会耗时很久，因此为了提高速度，一般直接：cout << “\n”;2、n组输入输出(n不确定）1、n组输入输出(n确定）3、 复杂的输入输出。
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1164
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
算法基础-约数
qq_65186476的博客
09-11 306
试除法求约数、约数个数、约数之和、最大公约数
【Hot100】LeetCode—64. 最小路径和
weixin_44382896的博客
09-12 456
64. 最小路径和。
codeforces round #772 (div. 2)
03-16
好的，Codeforces Round #772 (Div. 2) 是一场由Codeforces主办的在线编程竞赛。 该比赛的比赛链接为：https://codeforces.com/contest/772。 该比赛分为两个级别：Div.1和Div.2。 Div. 1级别通常比Div. 2级别更...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值