Codeforces Round 965 (Div. 2)

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

前言

        有人在过七夕，我在打 cf ，还有某人独自一人在学校机房，凌晨一点骑上共享单车回宿舍欣赏沿途的秋风扫落叶。

        Standings：2166

        题目链接：Dashboard - Codeforces Round 965 (Div. 2) - Codeforces

A. Find K Distinct Points with Fixed Center

        题意：

        给一个点（x,y），要求构造 k 个点使得这 k 个点的中心是（x,y）。

        思路：

        分奇偶讨论，两两对应即可。

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

int T,x,y,k;

int main()
{
	scanf("%d",&T);
	while (T --)
	{
		scanf("%d%d%d",&x,&y,&k);
		if(k & 1)
		{
			printf("%d %d\n",x,y);
			for (int i = 1;i <= k / 2;++ i) printf("%d %d\n%d %d\n",x + i,y + i,x - i,y - i);
		}
		else
		{
			for (int i = 1;i <= k / 2;++ i) printf("%d %d\n%d %d\n",x + i,y + i,x - i,y - i);
		}
	}
	return 0;
}

B. Minimize Equal Sum Subarrays

        题意：

        给你一个 1 ~ n 的排列 p ，你需要构造出一个新的 1 ~ n 的排列 q ，使得满足条件的 （i , j）对的数目最小：

        p_i+p_{i+1}+...+p_j=q_i+q_{i+1}+...+q_j

        思路：

        只要使每一位的前缀和不一样即可，其实整体往右挪一位就是答案。

        比赛时打得太丑，才知道 vector 的 erase 复杂度是 O（n）的，过 B 的时候就已经心态崩了

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

#define N 200005

int T,n,fst;
long long sum[N],a[N],b[N],pre[N],las[N],now;

int main()
{
	scanf("%d",&T);
	while (T --)
	{
		scanf("%d",&n),sum[0] = now = 0ll;
		for (int i = 1,x;i <= n;++ i)
			scanf("%lld",&a[i]),sum[i] = sum[i - 1] + a[i],b[i] = 0,pre[i] = i - 1,las[i] = i + 1;
		fst = 1;
		for (int i = 1;i <= n;++ i)
		{
			if(i == n || (now + a[fst] != sum[i]))
			{
				b[i] = a[fst];
				now += b[i];
				fst = las[a[fst]];
			}
			else
			{
				b[i] = a[las[fst]];
				now += b[i];
				las[fst] = las[las[fst]];
			}
		}
		for (int i = 1;i <= n;++ i) printf("%lld ",b[i]);
		printf("\n");
	}
	return 0;
}

C. Perform Operations to Maximize Score

        题意：

        给一个序列 a 和一个 01 串 b ，可以进行 k 次操作，每次操作可以让 b 中为 1 的某一位对应的 a 加上一，求 k 次操作之后以下值的最大值 ：

        max_{i=1}^n(a_i + median(c_i))

        其中 c_i 表示序列 a 挖去 a_i 之后的序列，median 表示中位数。

        思路：

        可以分 b_i = 0 和 b_i = 1 讨论。

        1.  b_i = 1 的情况：显然让 k 次操作都加在 a_i 上最优，O（n）扫一遍即可。

        2.  b_i = 0 的情况：发现最大的那个 a_i 能得到最大的贡献，于是我们只用考虑挖去最大的 a_i 后的序列，让它的中位数尽可能大即可。我们可以二分中位数的值，再判断是否合法即可。

        好在是压线调出来了，以致于没有掉大分。。。

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

#define N 200005

int T,n,mid,m;
long long k,ans,mx1,mx2;

struct Node
{
	int val,b;
}a[N],c[N];

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

int cmp(Node x,Node y) { return x.val < y.val ; }

int check(int x)
{
	int tmp = m - mid + 1;
	int fl = m;
	for (int i = m; i ;-- i)
		if(c[i].val >= x) -- tmp,fl = i - 1;
		else break;
	if(tmp <= 0) return 1;
	int now = k;
	for (int i = fl; i ;-- i)
	{
		if(c[i].b) now -= x - c[i].val,-- tmp;
		if(now <= 0 || tmp <= 0) break;
	}
	if(now < 0) return 0;
	if(tmp <= 0) return 1;
	return 0;
}

int main()
{
	scanf("%d",&T);
	while (T --)
	{
		scanf("%d%lld",&n,&k),ans = a[n + 1].val = 0ll;
		mid = n / 2;
		for (int i = 1;i <= n;++ i)
		{
			scanf("%lld",&a[i].val);
			if(a[i].val >= mx1) mx2 = mx1,mx1 = a[i].val;
		}
		for (int i = 1;i <= n;++ i) scanf("%d",&a[i].b);
		sort(a + 1,a + n + 1,cmp);
		int bz = 0;
		for (int i = 1;i <= n;++ i)
			if(a[i].b)
			{
				int tp;
				if(i <= mid) tp = a[mid + 1].val;
				else tp = a[mid].val;
				ans = max(ans,a[i].val + k + tp);
			}
			else
			{
				bz = i;
			}
		if(bz)
		{
			m = 0;
			for (int i = 1;i <= n;++ i)
				if(i != bz) c[++ m].b = a[i].b,c[m].val = a[i].val;
			ans = max(ans,a[bz].val + c[mid].val);
			int l = c[mid].val;
			int r = 1e9;
			while (l <= r)
			{
				int md = (l + r) >> 1;
				if(check(md)) l = md + 1,ans = max(ans,a[bz].val + md);
				else r = md - 1;
			}
		}
		printf("%lld\n",ans);
	}
	return 0;
}

D. Determine Winning Islands in Race

        题意：

        给 n 座岛屿，第 i 座和第 i + 1 座之间有一座桥（基础桥），除此之外还有若干座桥（附加桥），所有桥都是单向的且由标号小的岛屿指向标号大的岛屿。最初，Elsie 在 1 号岛屿，Bessie 在 s 号岛屿，他们都需要前往 n 号岛屿；Bessie 只能走基础桥，而 Elsie 可以走附加桥。

        由 Bessie 率先开始，每一轮这个人都可以走一条存在的桥，然后他原先所在的岛屿立刻坍塌，这意味着所有与原先岛屿相连的桥也同时坍塌；如果当前无路可走，则这个人终止在这个岛屿。

        两个人都采取最优策略，对于每个 s\in[1,n-1] ，判断 Bessie 能否到达 n 号岛屿。

        思路：

        假设有一座 u -> v 的桥，若 E 可以通过这段桥超过 B ，则必须要满足一下条件：

        1. u < s

        2. v - s > t （t 是 A 到达 v 所用的最快时间）

        即  s \in [u+1,v-t-1]

        用 BFS 求出 A 到每个点的最短时间，再用差分数组统计贡献即可。

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

#define N 200005

int T,n,m,cnt,st[N],dis[N],vis[N],dif[N];

struct Edge
{
	int next,to;
}ed[N << 1];

queue<int> q;

void add(int u,int v)
{
	ed[++ cnt].next = st[u];
	ed[cnt].to = v;
	st[u] = cnt;
	return;
}

void bfs()
{
	while (!q.empty()) q.pop();	
	q.push(1),vis[1] = 1;
	while (!q.empty())
	{
		int x = q.front();
		q.pop(),vis[x] = 0;
		for (int i = st[x]; ~i ;i = ed[i].next)
		{
			int rec = ed[i].to;
			if(dis[x] + 1 < dis[rec])
			{
				dis[rec] = dis[x] + 1;
				if(!vis[rec]) q.push(rec),vis[rec] = 1;
			}
			int l = x + 1;
			int r = rec - (dis[x] + 1) - 1;
			if(l <= r) ++ dif[l],-- dif[r + 1];
		}
	}
	return;
}

int main()
{
	scanf("%d",&T);
	while (T --)
	{
		scanf("%d%d",&n,&m),cnt = 0;
		for (int i = 1;i <= n;++ i) st[i] = -1,dis[i] = n + 1,vis[i] = dif[i] = 0;
		dis[1] = dif[0] = 0;
		for (int i = 1;i < n;++ i) add(i,i + 1);
		for (int i = 1,u,v;i <= m;++ i) scanf("%d%d",&u,&v),add(u,v);
		bfs();
		for (int i = 1;i < n;++ i) dif[i] += dif[i - 1],printf("%d",(dif[i]) ? 0 : 1);
		printf("\n");
	}
	return 0;
}

E1. Eliminating Balls With Merging (Easy Version)

        题意：

        给一行小球，每个小球上面都标有一个分值，小球可以通过向左右吃掉分值小于等于自己的球，并加上所吃小球的分值。问有多少个小球有可能成为最后剩下的那个小球。

        思路：

        Easy Version 我们可以利用贪心，按分值从大到小将球排序，从大球到小球进行处理。我们用单调栈记录一下每个小球左右两边第一个比它大的小球，分别记作 l 和 r 。容易发现，如果 l 或者 r 能成功留下，且当前小球可以吃掉它，那么当前小球一定可以成功留下，反之不行。

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

#define N 200005

int T,n,k,l[N],r[N],f[N],mx,ans;
long long a[N],pre[N];

struct Node
{
	long long val,id;
}b[N];

stack<int> q;

int cmp(Node x,Node y) { return x.val > y.val ; }

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

int main()
{
	scanf("%d",&T);
	while (T --)
	{
		scanf("%d%d",&n,&k),pre[0] = f[0] = f[n + 1] = mx = ans = 0;
		for (int i = 1;i <= n;++ i)
		{
			scanf("%lld",&a[i]);
			b[i].id = i,b[i].val = a[i],f[i] = 0,mx = max(mx,a[i]),pre[i] = pre[i - 1] + a[i];
		}
		for (int i = 1;i <= n;++ i) f[i] = (a[i] == mx);
		sort(b + 1,b + n + 1,cmp);
		while (!q.empty()) q.pop();
		q.push(0),a[0] = 1e9 + 1ll;
		for (int i = 1;i <= n;++ i)
		{
			while (!q.empty() && a[i] >= a[q.top()]) q.pop();
			l[i] = q.top();
			q.push(i);
		}
		while (!q.empty()) q.pop();
		q.push(n + 1),a[n + 1] = 1e9 + 1ll;
		for (int i = n; i ;-- i)
		{
			while (!q.empty() && a[i] >= a[q.top()]) q.pop();
			r[i] = q.top();
			q.push(i);
		}
		for (int i = 1;i <= n;++ i)
		{
			if(b[i].val == mx) continue;
			int now = b[i].id;
			long long sum = pre[r[now] - 1] - pre[l[now]];
			if(sum >= a[l[now]]) f[now] |= f[l[now]];
			if(sum >= a[r[now]]) f[now] |= f[r[now]];
		}
		for (int i = 1;i <= n;++ i) ans += f[i];
		printf("%d\n",ans);
	}
	return 0;
}

E2. Eliminating Balls With Merging (Hard Version)

        题意：

        Hard Version 唯一的区别就是给出一个 x ，对于所有 i\in[x,n] ，都要统计子序列 1 ~ i 的 Easy Version 的问题。

        思路：

        按 Easy Version 的做法肯定会超时，我们试试 “返璞归真” ，回归最原始易得的想法。

        对于某个球 i 要是想留下来，就一定要把 1 ~ i - 1 都吃掉，那么我们可以计算想要把 1 ~ i - 1 都吃掉，至少需要往右吃到的位置 minr ；再根据已经把 1 ~ i - 1 都吃掉的情况下，至多往右吃到的位置 maxr 。那么球 i 对答案的贡献区间就是 [minr , maxr] ，用差分数组标记即可。

        对于求 minr 和 maxr 的过程，可以用 ST 表 + 二分 做，循环判断向左最多吃到哪，和向右最优吃到哪，如果吃不动就跳出。这样是不会超时的，因为每次吃到卡住的地方都说明那个位置的分值比你目前拥有的一段区间的分值之和要大，也就是说每一次扩散都会让你手上的值至少翻倍，因此这一过程的复杂度是 log(最大分值) 的。

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

#define N 200005

int T,n,p,lg[N],dif[N];
long long a[N],pre[N],f[N][22];

stack<long long> st;

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

void RMQ()
{
	for (int i = 1;i <= lg[n];++ i)
		for (int j = 1;j + (1 << i) - 1 <= n;++ j)
			f[j][i] = max(f[j][i - 1],f[j + (1 << (i - 1))][i - 1]);
	return;
}

int getMINR(int x)
{
	int tl,tr;
	tl = tr = x;
	while (tl > 1)
	{
		int ml = 1;
		int mr = tl - 1;
		int now = tl;
		long long sum = pre[tr] - pre[tl - 1];
		int mid,len;
		while (ml <= mr)
		{
			mid = (ml + mr) >> 1;
			len = tl - mid;
			long long mx = max(f[mid][lg[len]],f[tl - (1 << lg[len])][lg[len]]);
			if(sum >= mx) now = mid,mr = mid - 1;
			else ml = mid + 1;
		}
		if(tl > 1 && tl == now)
		{
			ml = tr + 1;
			mr = n;
			now = tr;
			sum = pre[tr] - pre[tl - 1];
			while (ml <= mr)
			{
				mid = (ml + mr) >> 1;
				len = mid - tr;
				long long mx = max(f[tr + 1][lg[len]],f[mid - (1 << lg[len]) + 1][lg[len]]);
				if(sum >= mx && sum + pre[mid] - pre[tr] >= a[tl - 1]) now = mid,mr = mid - 1;
				else if (sum >= mx) now = mid,ml = mid + 1;
				else mr = mid - 1;
			}
			if(now == tr)
			{
				tr = -1;
				break;
			}
			else tr = now;
		}
		else tl = now;
	}
	return tr;
}

int getMAXR(int x)
{
	while (x < n)
	{
		int ml = x + 1;
		int mr = n;
		int now = x;
		long long sum = pre[x];
		while (ml <= mr)
		{
			int mid = (ml + mr) >> 1;
			int len = mid - x;
			long long mx = max(f[x + 1][lg[len]],f[mid - (1 << lg[len]) + 1][lg[len]]);
			if(sum >= mx) now = mid,ml = mid + 1;
			else mr = mid - 1;
		}
		if(now == x) break;
		x = now;
	}
	return x;
}

int main()
{
	lg[1] = 0;
	for (int i = 2;i <= 200000;++ i) lg[i] = lg[i >> 1] + 1;
	scanf("%d",&T);
	while (T --)
	{
		scanf("%d%d",&n,&p),pre[0] = 0ll,a[0] = a[n + 1] = 1e9 + 1,dif[0] = 0;
		for (int i = 1;i <= n;++ i)
			scanf("%lld",&a[i]),f[i][0] = a[i],pre[i] = pre[i - 1] + a[i],dif[i] = 0;
		RMQ();
		for (int i = 1;i <= n;++ i)
		{
			int mnr = getMINR(i);
			if(mnr == -1) continue;
			int mxr = getMAXR(i);
			++ dif[mnr],-- dif[mxr + 1];
		}
		for (int i = 1;i <= n;++ i)
		{
			dif[i] += dif[i - 1];
			if(i >= p) printf("%d ",dif[i]);
		}
		printf("\n");
	}
	return 0;
}

总结

        感觉总是会卡在前三题，导致后面一些能做的大分题没时间写，看来得多练练 ABC 了。

HKUST_ZJH
关注
专栏目录
codeforces round 961 (div. 2)
07-25
### Codeforces Round 961 (Div. 2) A题解析 #### 题目背景 Codeforces Round 961 (Div. 2) 是一场针对中级水平程序员的编程竞赛，通常会包含几个不同难度级别的题目。A题作为入门级题目，旨在测试参赛者的基础算法...
Educational Codeforces Round 83 (Rated for Div. 2) D
01-20
C(n-2,i-1)*C(j-1,n-2)*(i-1) __ j: n-1 -> m 我们发现内层循环，每次只是j加一，我们就可以只用一次组合数剩下的用差量表示 对于外层循环同理 只有(i-1) * C(n-2,i-1) i会每次加一。我们也只算一次剩下的用差量...
Codeforces Round 965 (Div. 2)(A-C)
2301_76888784的博客
08-11 1085
A，B都是构造，像是构造专场能上分真开心，最后C题差一点没搞出来，外界大脑得以拿下。
Codeforces Round 965 (Div. 2) 8.10
2301_81692739的博客
08-11 820
看题得认真，不能迷糊，不然太费时间。
Codeforces Round 965 (Div. 2) ABCE1
2301_80105412的博客
08-11 1286
Codeforces Round 965 (Div. 2) ABCE1
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 961 (Div. 2)：深度解析与实战技巧.pdf
07-25
### Codeforces Round 961 (Div. 2)：深度解析与实战技巧 #### 引言 Codeforces 是一个国际知名的在线编程竞赛平台，它汇聚了来自世界各地的编程爱好者和专业人士。每一轮比赛都旨在测试参赛者的算法思维、编程...
codeforces round 962 (div. 3).docx
07-29
Codeforces Round 962 (Div. 3) 是一场编程竞赛，其中包含了多个编程题目，每个题目都有其独特的挑战和解题思路。以下是对该竞赛中部分题目的简要介绍及解题思路概述： A题: Legs 题意： 一只鸡有2条腿，一头奶牛有...
Codeforces Round 965 (Div. 2) A~E1
Code_Shark的博客
08-18 811
给你三个整数xc​yc​和k−100≤xc​yc​≤1001≤k≤1000你需要在2D坐标平面上找到具有整数坐标的k个不同点 (x1​y1​)、(x2​y2​)、、(xk​yk​xc​yc​1ki−109≤xi​yi​≤109可以证明，至少有一组k个不同点始终存在，并且满足这些条件。k个点 (x1​y1​)、(x2​y2​)、、(xk​yk。
Codeforces round 965 D. Determine Winning Islands in Race
2301_80811962的博客
08-17 281
看了官方题解后感觉插入边删除边好麻烦，感觉完全没必要删除，因此时间复杂度O（n+m）就可以了。对于第一种情况，考虑所有端点为 v>S 的桥梁，那么 dv≥v−S−1 必须成立，因为当我们一直向右走时，我们要比艾尔西先到达 v。整体思路就是贝西从2号岛屿出发，正序遍历（1号岛屿时显然贝西必胜），再第i号岛屿时只用考虑1~i-1为起点的桥，因为其他桥要么已经被破坏，要么已经满足艾尔西可以在贝西前面的条件。因此每次插入i-1为起点的桥，同时更新与该桥有关的点的dv，最后更新v-dv的最大值。
Codeforces Round 965 (Div. 2) （题解A~D）
s1379659220的博客
08-13 625
意思抽象出来就是已知n个数平均数为x,求出这n个数字那么举个例子:假设n=3,就取x-1,x,x+1假设n=4就取x-2,x-1,x+1,x+2即可。
前缀和+单调栈，CF1998 E1 - Eliminating Balls With Merging (Easy Version)
EQUINOX1的博客
08-11 356
如果sum(pre[i] + 1, suf[i] - 1) >= a[pre[i]]，那么a[i] 可以和左边合并。如果sum(pre[i] + 1, suf[i] - 1) >= a[suf[i]]，那么a[i] 可以和右边合并。合并意即，如果pre[i] 或者 suf[i] 中有一个可以留下，那么能够合并说明a[i] 也可以留下。对于a[i]，我们记左边第一个大于a[i]的下标为pre[i]，右边为suf[i]然后将下标按照元素值降序排序，依次处理即可。时间复杂度： O(N)空间复杂度：O(N)
算法刷题：300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组、1143. 最长公共子序列
最新发布
qq_61936886的博客
09-12 488
如果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 284
除了换行之外，还会清空缓存区，而清空缓存区这件事情会耗时很久，因此为了提高速度，一般直接：cout << “\n”;2、n组输入输出(n不确定）1、n组输入输出(n确定）3、 复杂的输入输出。
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1171
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
算法基础-约数
qq_65186476的博客
09-11 313
试除法求约数、约数个数、约数之和、最大公约数
Invalid use of DISTINCT with function 'size
04-28
这个错误通常是因为在使用DISTINCT关键字时，使用了size()函数。在CQL中，DISTINCT关键字只能用于列名，而不能用于函数。如果您想对结果集中的元素数量进行去重，可以考虑使用COUNT(DISTINCT ...)来替代size()函数。例如： ``` SELECT COUNT(DISTINCT column_name) FROM table_name; ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值