devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Codeforces Round 965 (Div. 2)

作者：从前慢现在也慢 | 2024-08-19 20:01:59

赞

踩

codeforces round 965 (div. 2)

前言

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

        Standings：2166

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

A. Find K Distinct Points with Fixed Center

        题意：

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

        思路：

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

  1. #include<cstdio>
  2. #include<cstring>
  3. using namespace std;
  4.  
  5. int T,x,y,k;
  6.  
  7. int main()
  8. {
  9. 	scanf("%d",&T);
  10. 	while (T --)
  11. 	{
  12. 		scanf("%d%d%d",&x,&y,&k);
  13. 		if(k & 1)
  14. 		{
  15. 			printf("%d %d\n",x,y);
  16. 			for (int i = 1;i <= k / 2;++ i) printf("%d %d\n%d %d\n",x + i,y + i,x - i,y - i);
  17. 		}
  18. 		else
  19. 		{
  20. 			for (int i = 1;i <= k / 2;++ i) printf("%d %d\n%d %d\n",x + i,y + i,x - i,y - i);
  21. 		}
  22. 	}
  23. 	return 0;
  24. }

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 的时候就已经心态崩了

  1. #include<cstdio>
  2. #include<cstring>
  3. #include<algorithm>
  4. #include<vector>
  5. using namespace std;
  6.  
  7. #define N 200005
  8.  
  9. int T,n,fst;
  10. long long sum[N],a[N],b[N],pre[N],las[N],now;
  11.  
  12. int main()
  13. {
  14. 	scanf("%d",&T);
  15. 	while (T --)
  16. 	{
  17. 		scanf("%d",&n),sum[0] = now = 0ll;
  18. 		for (int i = 1,x;i <= n;++ i)
  19. 			scanf("%lld",&a[i]),sum[i] = sum[i - 1] + a[i],b[i] = 0,pre[i] = i - 1,las[i] = i + 1;
  20. 		fst = 1;
  21. 		for (int i = 1;i <= n;++ i)
  22. 		{
  23. 			if(i == n || (now + a[fst] != sum[i]))
  24. 			{
  25. 				b[i] = a[fst];
  26. 				now += b[i];
  27. 				fst = las[a[fst]];
  28. 			}
  29. 			else
  30. 			{
  31. 				b[i] = a[las[fst]];
  32. 				now += b[i];
  33. 				las[fst] = las[las[fst]];
  34. 			}
  35. 		}
  36. 		for (int i = 1;i <= n;++ i) printf("%lld ",b[i]);
  37. 		printf("\n");
  38. 	}
  39. 	return 0;
  40. }

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 后的序列，让它的中位数尽可能大即可。我们可以二分中位数的值，再判断是否合法即可。

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

  1. #include<cstdio>
  2. #include<cstring>
  3. #include<algorithm>
  4. using namespace std;
  5.  
  6. #define N 200005
  7.  
  8. int T,n,mid,m;
  9. long long k,ans,mx1,mx2;
  10.  
  11. struct Node
  12. {
  13. 	int val,b;
  14. }a[N],c[N];
  15.  
  16. long long max(long long x,long long y) { return x > y ? x : y ; }
  17.  
  18. int cmp(Node x,Node y) { return x.val < y.val ; }
  19.  
  20. int check(int x)
  21. {
  22. 	int tmp = m - mid + 1;
  23. 	int fl = m;
  24. 	for (int i = m; i ;-- i)
  25. 		if(c[i].val >= x) -- tmp,fl = i - 1;
  26. 		else break;
  27. 	if(tmp <= 0) return 1;
  28. 	int now = k;
  29. 	for (int i = fl; i ;-- i)
  30. 	{
  31. 		if(c[i].b) now -= x - c[i].val,-- tmp;
  32. 		if(now <= 0 || tmp <= 0) break;
  33. 	}
  34. 	if(now < 0) return 0;
  35. 	if(tmp <= 0) return 1;
  36. 	return 0;
  37. }
  38.  
  39. int main()
  40. {
  41. 	scanf("%d",&T);
  42. 	while (T --)
  43. 	{
  44. 		scanf("%d%lld",&n,&k),ans = a[n + 1].val = 0ll;
  45. 		mid = n / 2;
  46. 		for (int i = 1;i <= n;++ i)
  47. 		{
  48. 			scanf("%lld",&a[i].val);
  49. 			if(a[i].val >= mx1) mx2 = mx1,mx1 = a[i].val;
  50. 		}
  51. 		for (int i = 1;i <= n;++ i) scanf("%d",&a[i].b);
  52. 		sort(a + 1,a + n + 1,cmp);
  53. 		int bz = 0;
  54. 		for (int i = 1;i <= n;++ i)
  55. 			if(a[i].b)
  56. 			{
  57. 				int tp;
  58. 				if(i <= mid) tp = a[mid + 1].val;
  59. 				else tp = a[mid].val;
  60. 				ans = max(ans,a[i].val + k + tp);
  61. 			}
  62. 			else
  63. 			{
  64. 				bz = i;
  65. 			}
  66. 		if(bz)
  67. 		{
  68. 			m = 0;
  69. 			for (int i = 1;i <= n;++ i)
  70. 				if(i != bz) c[++ m].b = a[i].b,c[m].val = a[i].val;
  71. 			ans = max(ans,a[bz].val + c[mid].val);
  72. 			int l = c[mid].val;
  73. 			int r = 1e9;
  74. 			while (l <= r)
  75. 			{
  76. 				int md = (l + r) >> 1;
  77. 				if(check(md)) l = md + 1,ans = max(ans,a[bz].val + md);
  78. 				else r = md - 1;
  79. 			}
  80. 		}
  81. 		printf("%lld\n",ans);
  82. 	}
  83. 	return 0;
  84. }

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 到每个点的最短时间，再用差分数组统计贡献即可。

  1. #include<cstdio>
  2. #include<cstring>
  3. #include<queue>
  4. using namespace std;
  5.  
  6. #define N 200005
  7.  
  8. int T,n,m,cnt,st[N],dis[N],vis[N],dif[N];
  9.  
  10. struct Edge
  11. {
  12. 	int next,to;
  13. }ed[N << 1];
  14.  
  15. queue<int> q;
  16.  
  17. void add(int u,int v)
  18. {
  19. 	ed[++ cnt].next = st[u];
  20. 	ed[cnt].to = v;
  21. 	st[u] = cnt;
  22. 	return;
  23. }
  24.  
  25. void bfs()
  26. {
  27. 	while (!q.empty()) q.pop();	
  28. 	q.push(1),vis[1] = 1;
  29. 	while (!q.empty())
  30. 	{
  31. 		int x = q.front();
  32. 		q.pop(),vis[x] = 0;
  33. 		for (int i = st[x]; ~i ;i = ed[i].next)
  34. 		{
  35. 			int rec = ed[i].to;
  36. 			if(dis[x] + 1 < dis[rec])
  37. 			{
  38. 				dis[rec] = dis[x] + 1;
  39. 				if(!vis[rec]) q.push(rec),vis[rec] = 1;
  40. 			}
  41. 			int l = x + 1;
  42. 			int r = rec - (dis[x] + 1) - 1;
  43. 			if(l <= r) ++ dif[l],-- dif[r + 1];
  44. 		}
  45. 	}
  46. 	return;
  47. }
  48.  
  49. int main()
  50. {
  51. 	scanf("%d",&T);
  52. 	while (T --)
  53. 	{
  54. 		scanf("%d%d",&n,&m),cnt = 0;
  55. 		for (int i = 1;i <= n;++ i) st[i] = -1,dis[i] = n + 1,vis[i] = dif[i] = 0;
  56. 		dis[1] = dif[0] = 0;
  57. 		for (int i = 1;i < n;++ i) add(i,i + 1);
  58. 		for (int i = 1,u,v;i <= m;++ i) scanf("%d%d",&u,&v),add(u,v);
  59. 		bfs();
  60. 		for (int i = 1;i < n;++ i) dif[i] += dif[i - 1],printf("%d",(dif[i]) ? 0 : 1);
  61. 		printf("\n");
  62. 	}
  63. 	return 0;
  64. }

E1. Eliminating Balls With Merging (Easy Version)

        题意：

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

        思路：

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

  1. #include<cstdio>
  2. #include<cstring>
  3. #include<algorithm>
  4. #include<stack>
  5. using namespace std;
  6.  
  7. #define N 200005
  8.  
  9. int T,n,k,l[N],r[N],f[N],mx,ans;
  10. long long a[N],pre[N];
  11.  
  12. struct Node
  13. {
  14. 	long long val,id;
  15. }b[N];
  16.  
  17. stack<int> q;
  18.  
  19. int cmp(Node x,Node y) { return x.val > y.val ; }
  20.  
  21. long long max(long long x,long long y) { return x > y ? x : y ; }
  22.  
  23. int main()
  24. {
  25. 	scanf("%d",&T);
  26. 	while (T --)
  27. 	{
  28. 		scanf("%d%d",&n,&k),pre[0] = f[0] = f[n + 1] = mx = ans = 0;
  29. 		for (int i = 1;i <= n;++ i)
  30. 		{
  31. 			scanf("%lld",&a[i]);
  32. 			b[i].id = i,b[i].val = a[i],f[i] = 0,mx = max(mx,a[i]),pre[i] = pre[i - 1] + a[i];
  33. 		}
  34. 		for (int i = 1;i <= n;++ i) f[i] = (a[i] == mx);
  35. 		sort(b + 1,b + n + 1,cmp);
  36. 		while (!q.empty()) q.pop();
  37. 		q.push(0),a[0] = 1e9 + 1ll;
  38. 		for (int i = 1;i <= n;++ i)
  39. 		{
  40. 			while (!q.empty() && a[i] >= a[q.top()]) q.pop();
  41. 			l[i] = q.top();
  42. 			q.push(i);
  43. 		}
  44. 		while (!q.empty()) q.pop();
  45. 		q.push(n + 1),a[n + 1] = 1e9 + 1ll;
  46. 		for (int i = n; i ;-- i)
  47. 		{
  48. 			while (!q.empty() && a[i] >= a[q.top()]) q.pop();
  49. 			r[i] = q.top();
  50. 			q.push(i);
  51. 		}
  52. 		for (int i = 1;i <= n;++ i)
  53. 		{
  54. 			if(b[i].val == mx) continue;
  55. 			int now = b[i].id;
  56. 			long long sum = pre[r[now] - 1] - pre[l[now]];
  57. 			if(sum >= a[l[now]]) f[now] |= f[l[now]];
  58. 			if(sum >= a[r[now]]) f[now] |= f[r[now]];
  59. 		}
  60. 		for (int i = 1;i <= n;++ i) ans += f[i];
  61. 		printf("%d\n",ans);
  62. 	}
  63. 	return 0;
  64. }

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(最大分值) 的。

  1. #include<cstdio>
  2. #include<cstring>
  3. #include<stack>
  4. using namespace std;
  5.  
  6. #define N 200005
  7.  
  8. int T,n,p,lg[N],dif[N];
  9. long long a[N],pre[N],f[N][22];
  10.  
  11. stack<long long> st;
  12.  
  13. long long max(long long x,long long y) { return x > y ? x : y ; }
  14.  
  15. void RMQ()
  16. {
  17. 	for (int i = 1;i <= lg[n];++ i)
  18. 		for (int j = 1;j + (1 << i) - 1 <= n;++ j)
  19. 			f[j][i] = max(f[j][i - 1],f[j + (1 << (i - 1))][i - 1]);
  20. 	return;
  21. }
  22.  
  23. int getMINR(int x)
  24. {
  25. 	int tl,tr;
  26. 	tl = tr = x;
  27. 	while (tl > 1)
  28. 	{
  29. 		int ml = 1;
  30. 		int mr = tl - 1;
  31. 		int now = tl;
  32. 		long long sum = pre[tr] - pre[tl - 1];
  33. 		int mid,len;
  34. 		while (ml <= mr)
  35. 		{
  36. 			mid = (ml + mr) >> 1;
  37. 			len = tl - mid;
  38. 			long long mx = max(f[mid][lg[len]],f[tl - (1 << lg[len])][lg[len]]);
  39. 			if(sum >= mx) now = mid,mr = mid - 1;
  40. 			else ml = mid + 1;
  41. 		}
  42. 		if(tl > 1 && tl == now)
  43. 		{
  44. 			ml = tr + 1;
  45. 			mr = n;
  46. 			now = tr;
  47. 			sum = pre[tr] - pre[tl - 1];
  48. 			while (ml <= mr)
  49. 			{
  50. 				mid = (ml + mr) >> 1;
  51. 				len = mid - tr;
  52. 				long long mx = max(f[tr + 1][lg[len]],f[mid - (1 << lg[len]) + 1][lg[len]]);
  53. 				if(sum >= mx && sum + pre[mid] - pre[tr] >= a[tl - 1]) now = mid,mr = mid - 1;
  54. 				else if (sum >= mx) now = mid,ml = mid + 1;
  55. 				else mr = mid - 1;
  56. 			}
  57. 			if(now == tr)
  58. 			{
  59. 				tr = -1;
  60. 				break;
  61. 			}
  62. 			else tr = now;
  63. 		}
  64. 		else tl = now;
  65. 	}
  66. 	return tr;
  67. }
  68.  
  69. int getMAXR(int x)
  70. {
  71. 	while (x < n)
  72. 	{
  73. 		int ml = x + 1;
  74. 		int mr = n;
  75. 		int now = x;
  76. 		long long sum = pre[x];
  77. 		while (ml <= mr)
  78. 		{
  79. 			int mid = (ml + mr) >> 1;
  80. 			int len = mid - x;
  81. 			long long mx = max(f[x + 1][lg[len]],f[mid - (1 << lg[len]) + 1][lg[len]]);
  82. 			if(sum >= mx) now = mid,ml = mid + 1;
  83. 			else mr = mid - 1;
  84. 		}
  85. 		if(now == x) break;
  86. 		x = now;
  87. 	}
  88. 	return x;
  89. }
  90.  
  91. int main()
  92. {
  93. 	lg[1] = 0;
  94. 	for (int i = 2;i <= 200000;++ i) lg[i] = lg[i >> 1] + 1;
  95. 	scanf("%d",&T);
  96. 	while (T --)
  97. 	{
  98. 		scanf("%d%d",&n,&p),pre[0] = 0ll,a[0] = a[n + 1] = 1e9 + 1,dif[0] = 0;
  99. 		for (int i = 1;i <= n;++ i)
  100. 			scanf("%lld",&a[i]),f[i][0] = a[i],pre[i] = pre[i - 1] + a[i],dif[i] = 0;
  101. 		RMQ();
  102. 		for (int i = 1;i <= n;++ i)
  103. 		{
  104. 			int mnr = getMINR(i);
  105. 			if(mnr == -1) continue;
  106. 			int mxr = getMAXR(i);
  107. 			++ dif[mnr],-- dif[mxr + 1];
  108. 		}
  109. 		for (int i = 1;i <= n;++ i)
  110. 		{
  111. 			dif[i] += dif[i - 1];
  112. 			if(i >= p) printf("%d ",dif[i]);
  113. 		}
  114. 		printf("\n");
  115. 	}
  116. 	return 0;
  117. }

总结

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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/1003579
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号