Codeforces Round 958 (Div. 2)

于 2024-07-29 23:02:51 发布
阅读量459 收藏 4
点赞数 11
文章标签： 算法 c++ 数据结构 贪心算法 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HKUST_ZJH/article/details/140715977
版权

前言

        没错，这场打得稀烂，A 题一个小时都没切，掉下浅绿名......

        Standings：7955

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

A. Split the Multiset

        我愿称之为目前做过的最难的 A 题！（其实 A 能难过 BCD 吗？可能是比赛的时候短路了一直往错的贪心想）

        题意：

        给一个只含有一个元素 n 的多重集合，需要你进行若干次操作，每次操作选择一个集合里的一个元素 u ，再向集合里加入不超过 k 个元素，使这些加入的元素之和等于 u 。最后要求得到的多重集合是 n 个 1 ，求最小的操作次数。

        思路：

        一眼贪心，很像合并果子之类的题目，首先显然的贪心是当 u >= k 的时候，一定要加满 k 个元素，这样不会导致浪费操作，下面考虑加入的这些元素要如何分配。其实只需尽可能多地加入“1” 就是最优方案。

        第一种解释：我们最后要得到的全为 “1” 的多重集合，这样可以保证我们每一次操作得到最多的 “1” ，可以让我们以最快的速度达成目标。

        第二种解释：无论如何分配这不超过 k 个元素，要减少的总数值都是（n - 1），分配尽可能多的 “1” 是无须进行二次操作的，而如果分配的数里有两个或以上不为 1 的数，这些数需要单独二次操作，这样每个数二次操作可能用不满 k 个元素，这样就导致了更多的操作数浪费。

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

int T,n,k;

int ask(int x,int y)
{
	if(x == 1) return 0;
	if(x <= y) return 1;
	return ask(x - (k - 1),y) + 1;
}

int main()
{
	scanf("%d",&T);
	while (T --)
	{
		scanf("%d%d",&n,&k);
		printf("%d\n",ask(n,k));
	}
	return 0;
}

B. Make Majority

        题意：

        给一个长度为 n 的 01 序列 a，每次操作选取一段区间 [l,r] ，记 eq?c_0 表示这段区间内 0 的数目，记 eq?c_1 表示这段区间内 1 的数目。

        1. eq?c_0 >= eq?c_1 ，则将这段区间变成单个元素 0

        2. eq?c_0  <  eq?c_1 ，则将这段区间变成单个元素 1

        询问对于每个给定的 01 串，能否通过若干次操作使最终的序列全是 1 。

        思路：

        简单来说就是要消灭所有的 0 ，显然我们可以先把所有长度大于 1 的连续的 0 都缩成一个单个的 0 ，那么此时原数列就变成了若干个单个的 0 嵌在一堆 1 中间，下面我们考虑对这些 0 逐个击破。对于每个 0 ，消灭它需要身边有至少两个 1 （“011”、“101”、“110”），每次我们选取这样连续的三个数并把它变成 1 ，发现每次操作都是减少了一个 1 和一个 0 。于是我们只需判断处理了连续 0 之后的序列中，eq?c_1 >= eq?c_0 + 1 是否成立即可。若成立，我们每次都一定可以找到至少一个这样的三个数并击破，最后得到全为 1 的串。

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

#define N 200005

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

int main()
{
	scanf("%d",&T);
	while (T --)
	{
		scanf("%d",&n);
		scanf("%s",s + 1);
		for (int i = 1;i <= n;++ i) a[i] = s[i] - '0';
		int x,y;
		x = y = 0;
		if(a[1] == 1) x = 1;
		else y = 1;
		for (int i = 2;i <= n;++ i)
			if(a[i] != a[i - 1])
			{
				if(a[i] == 1) ++ x;
				else ++ y;
			}
			else if(a[i] == 1) ++ x;
		if(x >= y + 1) printf("Yes\n");
		else printf("No\n");
	}
	return 0;
}

C. Increasing Sequence with Fixed OR

        题意：

        给定一个正整数 n ，构造出一个满足以下条件的最长序列。

        1. eq?%5Cforall  2<=i<=k ，eq?a_i <= n

        2. 序列 a 严格递增

        3. eq?%5Cforall  2<=i<=k ，eq?a_i%20%7C%20a_%7Bi-1%7D = n

        思路：

        我们从大到小构造序列，那么显然最大的那个数可以构造为 n ，考虑往下如何构造。

        由于要使相邻两个数异或和为 n ，我们又是从大到小构造的，于是每一步的最优方案就是 n 从小到大依次减去二进制下的 1 。

        我们以 23 为例，在二进制下观察：

        1 0 1 1 1 （23）

        1 0 1 1 0 （22）

        1 0 1 0 1 （21）

        1 0 0 1 1 （19）

        0 0 1 1 1  （7）

        因此假设 n 的二进制下有 m 个 1 ，则最长序列的长度为 m + 1 。

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

int T,m;
long long pow[62],n,a[62];

int main()
{
	pow[0] = 1ll;
	for (int i = 1;i <= 61;++ i) pow[i] = pow[i - 1] << 1;
	scanf("%d",&T);
	while (T --)
	{
		scanf("%lld",&n),m = 0;
		long long now = n;
		for (int i = 61;i >= 0;-- i)
			if(now >= pow[i]) a[++ m] = pow[i],now -= pow[i];
		if(m == 1)
		{
			printf("1\n");
			printf("%lld\n",n);
			continue;
		}
		printf("%d\n",m + 1);
		for (int i = 1;i <= m;++ i) printf("%lld ",n - a[i]);
		printf("%lld\n",n);
	}
	return 0;
}

D. The Omnipotent Monster Killer

        题意：

        给一棵 n 个节点的树，每个节点上都有一个怪兽，每个怪兽都有一个攻击值 。每一轮所有存活的怪兽都会对你产生攻击，之后你需要在每一轮消灭若干怪兽，被消灭的怪兽在树上不能相邻，直到所有的怪兽都被消灭，求这个过程中怪兽产生的最小攻击值总和。

        思路：

        一眼树形dp，而且很像最经典的那道题 —— “ 没有上司的舞会 ” 。考场时飞速码完了但一直 WA，造成了这次 rating 的惨剧。

        设 eq?f_%7Bi%2Cj%7D 表示节点 i 上的怪兽在第 j 轮被消灭时，以 i 为根的子树内总攻击值的最小值，那么它本身的贡献就是 eq?a_i * j ，在转移的时候从子节点上的怪兽都不在第 j 轮消灭来转移即可。

        时间复杂度：不用前缀和优化就是 O（ eq?n%7Blog%7D%5E2n ），前缀和优化就是 O（nlogn）。

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

#define N 300005
#define Inf 8e18

int T,n,st[N],cnt;
long long a[N],f[N][22],ans,pre[N][22],suf[N][22];

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

long long min(long long x,long long y) { return x < y ? x : y ; }

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

void dfs(int x,int fa)
{
	for (int i = 1;i <= 20;++ i) f[x][i] = 1ll * i * a[x];
	for (int i = st[x]; ~i ;i = ed[i].next)
	{
		int rec = ed[i].to;
		if(rec == fa) continue;
		dfs(rec,x);
		for (int j = 1;j <= 20;++ j) pre[rec][j] = min(pre[rec][j - 1],f[rec][j]);
		for (int j = 20; j ;-- j) suf[rec][j] = min(suf[rec][j + 1],f[rec][j]);
		for (int j = 1;j <= 20;++ j) f[x][j] += min(pre[rec][j - 1],suf[rec][j + 1]);
	}
	return;
}

int main()
{
	scanf("%d",&T);
	while (T --)
	{
		scanf("%d",&n),cnt = 0,ans = Inf;
		for (int i = 1;i <= n;++ i)
		{
			scanf("%lld",&a[i]),st[i] = -1;
			for (int j = 0;j <= 21;++ j) f[i][j] = pre[i][j] = suf[i][j] = Inf;
		}
		for (int i = 1,u,v;i < n;++ i) scanf("%d%d",&u,&v),add(u,v),add(v,u);
		dfs(1,0);
		for (int i = 1;i <= 20;++ i) ans = min(ans,f[1][i]);
		printf("%lld\n",ans);
	}
	return 0;
}

E - Range Minimum Sum

        一道计数好题。

        题意：

        给一个长度为 n 的序列a，定义  f(a) = \sum_{l=1}^n\sum_{r=1}^n min_{l<=i<=i} (a_i) ，对于每个 i ，单独解决以下问题：

        从序列 a 中移除 a_i ，剩下的数记作序列 b ，计算 f(b) 。

        思路：

        我们首先计算一个数都不删减时的答案，再考虑删除每个数之后产生的影响。

        一个数都不删的情况：

        统计出每个位置左右第一个小于当前这个数的位置，分别记作 l_i 和 r_i ，那么这个位置上的贡献就是（ i - l_i  ）*  ( r_i - i ) * a_i，求 l,r 数组的过程可以用单调栈线性解决。

        删除位置i上的数对答案产生的影响：

        1. 首先显然要减去（ i - l_i  ）*  ( r_i - i ) * a_i

        2. 假设除去 i 之外的某个位置 j ，区间 [ l_i + 1 , r_i - 1 ] 覆盖了位置i，那么在删去 i 之后， j 的贡献也会减少。如果 i 位于左侧区间 [ l_i + 1 , j - 1 ]，那么少了一个 i 对于 j 的贡献的影响就是减少 1 个 ( r_i - i ) * a_i 。i 位于右侧区间的情况同理。那么这段贡献的变化如何统计呢？我们可以枚举 j ，那么对于 [ l_i + 1 , j - 1 ] 和  [ j + 1 , r_i - 1 ] 区间内的每个 i ，删除 i 都会造成上述影响，这实际上是两段区间减，用差分数组维护即可。

        3. 对于某个位置 j ，若 l_j 或者 r_j 刚好等于 i，那么在删除i之后就会更新 j 的 l_j 或者 r_j ，更新之后 j 的贡献会增加。更新 l,r 的过程即在 i 的左右找出第一个比 a_j 小的数，这部分可以用二分 + ST表解决（如果用二分 + 线段树就会带两个 log ，可能超时）。

        时间复杂度：O（n log n）

        真是一道酣畅淋漓的计数好题！

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

#define N 500005

int T,n,a[N],l[N],r[N],lg[N],f[N][22];
long long tot,ans[N],dif[N];

stack<int> st;

int min(int x,int y) { return x < y ? x : y ; }

void solveLR()
{
	while (!st.empty()) st.pop();
	for (int i = 1;i <= n + 1;++ i)
	{
		while (!st.empty() && a[i] < a[st.top()]) r[st.top()] = i,st.pop();
		st.push(i);
	}
	while (!st.empty()) st.pop();
	for (int i = n;i >= 0;-- i)
	{
		while (!st.empty() && a[i] < a[st.top()]) l[st.top()] = i,st.pop();
		st.push(i);
	}
	return;
}

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

int findL(int x,int w)
{
	int ll = 0;
	int rr = x - 1;
	int tmp = 0;
	while (ll <= rr)
	{
		int mid = (ll + rr) >> 1;
		int len = x - mid;
		if(min(f[mid][lg[len]],f[x - (1 << lg[len])][lg[len]]) < w) tmp = mid,ll = mid + 1;
		else rr = mid - 1;
	}
	return tmp;
}

int findR(int x,int w)
{
	int ll = x + 1;
	int rr = n + 1;
	int tmp = n + 1;
	while (ll <= rr)
	{
		int mid = (ll + rr) >> 1;
		int len = mid - x;
		if(min(f[x + 1][lg[len]],f[mid - (1 << lg[len]) + 1][lg[len]]) < w) tmp = mid,rr = mid - 1;
		else ll = mid + 1;
	}
	return tmp;
}

int main()
{
	lg[1] = 0;
	for (int i = 2;i < N;++ i) lg[i] = lg[i >> 1] + 1;
	scanf("%d",&T);
	while (T --)
	{
		scanf("%d",&n),a[0] = a[n + 1] = 0,tot = dif[0] = 0ll;
		for (int i = 1;i <= n;++ i) scanf("%d",&a[i]),dif[i] = 0ll,f[i][0] = a[i];
		solveLR();
		solveST();
		for (int i = 1;i <= n;++ i) tot += 1ll * (i - l[i]) * (r[i] - i) * a[i];
		for (int i = 1;i <= n;++ i)
		{
			ans[i] = tot - 1ll * (i - l[i]) * (r[i] - i) * a[i];
			dif[l[i] + 1] -= 1ll * (r[i] - i) * a[i],dif[i] += 1ll * (r[i] - i) * a[i];
			dif[i + 1] -= 1ll * (i - l[i]) * a[i],dif[r[i]] += 1ll * (i - l[i]) * a[i];
		}
		for (int i = 1,nl,nr;i <= n;++ i)
		{
			nl = findL(l[i],a[i]);
			if(l[i]) ans[l[i]] += 1ll * (l[i] - nl - 1) * (r[i] - i) * a[i];
			nr = findR(r[i],a[i]);
			if(r[i] != n + 1) ans[r[i]] += 1ll * (nr - r[i] - 1) * (i - l[i]) * a[i];
		}
		for (int i = 1;i <= n;++ i)
		{
			dif[i] += dif[i - 1];
			ans[i] += dif[i];
			printf("%lld ",ans[i]);
		}
		printf("\n");
	}
	return 0;
}

总结

        事实摆在那，这场确实打得稀烂，最大的原因是 A 题滑铁卢，但本质上是思维上仍有缺口，不过好在是还有时间练习。D 题自己打的 dp 现在仍然不清楚错在哪里，可能是方法本身有点瑕疵，虽然 “ 到现在都不知道错哪了 ” 还是心里的一道坎，但多多学习正规的解法才是王道，很多时候得取其精华、去其糟粕。

HKUST_ZJH
关注
  • 11
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
codeforces round 961 (div. 2)
07-25
思路：对角线上的个数为：n，n-1(2个)，n-2(2个)，n-3(2个),......，1(2个) AC代码： #pragma GCC optimize("O2") #pragma GCC optimize("O3") #include <bits/stdc++.h> using namespace std; #define int long ...
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 948 (Div. 2)
2301_80041146的博客
05-27 611
思路：有个非常重要的性质，对于某一列，假设确定了这一列的哪一行有1，那么这个图已经可以确定了。思路：如果n<m，显然不行。再看n>=m的情况，可以先假定放刚好m个，在思考是否可以在接下来的步骤使方块数不变。题意：给定一个数组，找到一个子数组，需使这个子数组的lcm（最小公倍数）不存在于给定的数组，问这个子数组的最大长度是多少。题意：有n次机会，每次可以选择放一个方块或者拿走一个，问最后是否可以有m个方块。题意：构造题，懒得描述了，直接看，其中第三条可以转换成不存在连续的1或-1。
Codeforces Round 915 (Div. 2)
Lanthamum的博客
12-16 561
【代码】Codeforces Round 915 (Div. 2)
Codeforces Round 951 (Div. 2) 题解分享
2301_80105412的博客
06-07 989
cf 951 div2 A~D
Codeforces Round 946 (Div. 3)
gege_0606的博客
05-21 1761
З手机桌面- A - Codeforces。
Codeforces Round 892 (Div. 2)
qq_64289808的博客
08-13 326
Codeforces Round 892 (Div. 2)
Codeforces Round 876 (Div. 2)
qq_61657632的博客
06-04 671
C.最后如果是1放不了，要想让最后的0变成1只能从后面放0所以最后的不能为1。可以手玩一下，排序ai ai层最多可以取ai件，且ai不会影响到ai+1层。放0直接放最前面，保证连续的0变成连续的1不会导致后面的状态改变。然后连续的1其实只要从末尾插入个0就能把前面都变成1。所以从小往大取即可贪心拿最大的物品。贪心放1的时候直接放i。
Codeforces Round 860 (Div. 2)题解
qq_60653991的博客
03-27 534
比如我现在是提供三组数据：1 2 3 4。
codeforces round 948(div.2）
2301_79426686的博客
05-27 730
codeforces round 948(div.2) AB
Codeforces Round 961 (Div. 2)（A~D)
weixin_61825750的博客
07-24 1132
因此我们对于每一个位置，只需要将最大的那个集合设为不可选，然后最终将大集合中的所有小集合同步更新即可。枚金币买尽可能多的价格少的那一种花，然后再用剩下的钱买尽可能多的价格多的那一种花。因此我们只需要从后往前遍历所有位置，然后统计哪些集合是没法选的，最终在剩下的集合中选一个所含字母最少的即可。，接下来我们只需要求最多可以执行多少次这样的操作即可，然后便可以求出最大的花瓣数。然后，我们可以通过放弃价格少的一种花，再购买价格多的那一种花，使得所得到的花瓣加。贪心，先将占有单元格最多的对角线填满，然后依次往下填。
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
codeforces round 962 (div. 3).docx
最新发布
07-29
Codeforces Round 962 (Div. 3) 是一场编程竞赛，其中包含了多个编程题目，每个题目都有其独特的挑战和解题思路。以下是对该竞赛中部分题目的简要介绍及解题思路概述： A题: Legs 题意： 一只鸡有2条腿，一头奶牛有...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 932
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 230
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
2.6基本算法之动态规划6045:开餐馆
Andy_SCP001的博客
07-24 240
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
算法-KMP字符串匹配
xx_xb的博客
07-23 306
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
2766. 重新放置石块 Medium
珞米的博客
07-24 531
第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，有石块的位置为 [2,2,3,3]。第 i = 1 步操作中，我们将位置 3 处的石块移到位置 2 处，有石块的位置为 [2,2,2,2]。第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，位置 2,6,7,8 有石块。第 i = 1 步操作中，我们将位置 7 处的石块移到位置 9 处，位置 2,6,8,9 有石块。第 i = 2 步操作中，我们将位置 2 处的石块移到位置 5 处，位置 5,6,8,9 有石块。
Codeforces Round 798 (Div. 2)
09-08
Codeforces Round 798 (Div. 2)是一个Codeforces竞赛系列中的一场比赛。根据提供的引用内容，我们可以看到一些参赛选手的AC代码链接。这些链接中包含了一些参赛选手在比赛中解答的题目的代码。 其中，AC代码链接是一种解答题目的代码，题目为"E. ANDfinity"。AC代码链接是另一种解答题目的代码，题目同样为"E. ANDfinity"。AC代码链接是解答题目"C. Infected Tree"的代码。 因此，Codeforces Round 798 (Div. 2)是一场包含了题目"E. ANDfinity"和"C. Infected Tree"的Codeforces竞赛。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值