Codeforces Round 1023 (Div.2)

最新推荐文章于 2025-05-19 20:18:50 发布
最新推荐文章于 2025-05-19 20:18:50 发布
阅读量751 收藏 23
点赞数 29
分类专栏： Codeforces Contest 文章标签： 算法 图论 动态规划 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/djhws144/article/details/147981286
版权

比赛链接：CF1023

A. LRC and VIP

  • 如果 a a a 数组全部值都相同，则无法构造出满足条件的 B B B, C C C 序列。
  • 否则，将最大值放到 C C C 序列中，其余元素放到 B B B 序列中。

时间复杂度： O ( n ) O(n) O(n)。

#include <bits/stdc++.h>
using namespace std;

const int N = 105;
int n, a[N];

void solve() {
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> a[i];
    int maxm = 0, minm = INT_MAX;
    for (int i = 1; i <= n; i++)
        maxm = max(maxm, a[i]), minm = min(minm, a[i]);
    if (maxm == minm) {
        cout << "NO\n";
        return;
    }
    cout << "YES\n";
    for (int i = 1; i <= n; i++) cout << (1 + (a[i] == maxm)) << " ";
    cout << "\n";
}

int main() {
    ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr);
    int T;
    cin >> T;
    while (T--) solve();
    return 0;
}

B. Apples in Boxes

Jerry 获胜条件：

  • 当前最大值 − 1 - 1 −1 后，剩余所有元素的最大值 − - − 最小值 > k > k >k。
  • 操作一次后，剩余所有元素数量的和为偶数。

剩余情况都是 Tom 获胜。

时间复杂度： O ( n ) O(n) O(n)。

#include <bits/stdc++.h>
using namespace std;

#define int long long

const int N = 1e5 + 10;
int n, k, a[N];

void solve() {
    cin >> n >> k;
    int maxm = 0, minm = LLONG_MAX, sum = 0, maxpos = 0;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        sum += a[i];
        if (a[i] > maxm) maxm = a[i], maxpos = i;
    }
    a[maxpos]--;
    maxm = 0, minm = LLONG_MAX;
    for (int i = 1; i <= n; i++)
        maxm = max(maxm, a[i]), minm = min(minm, a[i]);
    if (maxm - minm > k || sum % 2 == 0) cout << "Jerry\n";
    else cout << "Tom\n";
}

signed main() {
    ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr);
    int T;
    cin >> T;
    while (T--) solve();
    return 0;
}

C. Maximum Subarray Sum

  • 如果 s i s_i si​ 全为 1，无法进行操作，利用 d p dp dp 找出最大连续子数组，并且判断是否等于 k k k。
  • 如果存在 s i = 0 s_i = 0 si​=0，根据题目数据范围，只需要一个位置就可以让最大连续子数组的值等于 k k k。
    • 找到第一个 s i = 0 s_i = 0 si​=0 的位置，算出这个位置前面的一段最大后缀 s u f suf suf，跟这个位置往后的最大前缀 p r e pre pre，这个位置的 a i a_i ai​ 直接赋值为 k − p r e − s u f k - pre - suf k−pre−suf。
    • 第二个 s i = 0 s_i = 0 si​=0 的位置，将 a i a_i ai​ 赋值为 − 1 0 18 -10^{18} −1018，其余位置不需要改变。

时间复杂度： O ( n ) O(n) O(n)。

#include <bits/stdc++.h>
using namespace std;

#define int long long

const int N = 2e5 + 10;
int n, k, a[N], dp[N];
string s;

void solve() {
	cin >> n >> k >> s;
	s = " " + s;
	for (int i = 1; i <= n; i++) cin >> a[i];
	int pos1 = 0;
	for (int i = 1; i <= n; i++) {
		if (s[i] == '0') {
			pos1 = i;
			break;
		}
	}
	if (pos1 == 0) {
		int maxm = 0;
		for (int i = 1; i <= n; i++)
			dp[i] = max(dp[i - 1] + a[i], a[i]), maxm = max(maxm, dp[i]);
		if (maxm == k) {
			cout << "Yes\n";
			for (int i = 1; i <= n; i++) cout << a[i] << " ";
			cout << "\n";
		} else cout << "No\n";
		return;
	}
	int maxm = 0, r = 1;
	for (int i = 1; i <= n; i++) dp[i] = 0;
	for (int l = 1; l <= n; l++) {
		r = l;
		while (r <= n && s[r] != '0') {
			dp[r] = max(dp[r - 1] + a[r], a[r]);
			maxm = max(maxm, dp[r]);
			r++;
		}
		l = r;
	}
	if (maxm > k) {
		cout << "No\n";
		return;
	}
	int sum = 0, pre = 0, suf = 0;
	for (int i = pos1 - 1; i >= 1; i--) {
		sum += a[i];
		pre = max(pre, sum);
	}
	sum = suf = 0;
	int pos2 = 0, pos = pos1;
	for (int i = pos1 + 1; i <= n; i++) {
		sum += a[i];
		if (suf < sum) {
			pos = i;
			suf = sum;
		}
		if (s[i] == '0') {
			pos2 = i;
			break;
		}
	}
	a[pos1] = k - suf - pre;
	if (pos2) {
		for (int i = pos + 1; i <= n; i++) {
			if (s[i] == '0') a[i] = -1e18;
		}
	}
	cout << "Yes\n";
	for (int i = 1; i <= n; i++) cout << a[i] << " ";
	cout << "\n";
}

signed main() {
	ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr);
	int T;
	cin >> T;
	while (T--) solve();
	return 0;
}

D. Apple Tree Traversing

可以发现按照字典序排列的第一关键字是 d d d，也就是路径长度，所以只需要每一次在剩余森林的每一棵树中找出直径，并且存下这条直径的长度以及端点，最后按照字典序排列即可。

时间复杂度： O ( n n ) O(n \sqrt{n}) O(nn ​)。

  • 每一次找的直径一定会比前面的短，所以最多需要找 n \sqrt{n} n ​ 次直径。
#include <bits/stdc++.h>
using namespace std;

const int N = 150005;
int n, pre[N], used[N], d[N], head[N], num = 0, tar;
struct edge { int to, nxt; } e[N << 1];
array<int, 3> ans[N];

inline 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 * 10 + c - '0', c = getchar();
    return x * f;
}

void addEdge(int u, int v) { e[++num] = (edge){ v, head[u] }, head[u] = num; }

void dfs(int u, int fa) {
    for (int i = head[u]; i; i = e[i].nxt) {
        int v = e[i].to;
        if (v == fa || used[v]) continue;
        d[v] = d[u] + 1, pre[v] = u;
        if (d[v] > d[tar] || (d[v] == d[tar] && tar < v)) tar = v;
        dfs(v, u);
    }
}

void solve() {
    n = read();
    for (int i = 1; i <= n; i++) head[i] = used[i] = 0;
    num = 0;
    for (int i = 1; i < n; i++) {
        int u = read(), v = read();
        addEdge(u, v), addEdge(v, u);
    }
    int m = 0;
    tar = 0;
    while (1) {
        int flag = 0;
        for (int i = 1; i <= n; i++)
            if (!used[i]) { flag = i; break; }
        if (!flag) break;
        d[flag] = 1;
        tar = flag;
        dfs(tar, 0);
        int st = tar;
        d[tar] = 1;
        dfs(tar, 0);
        int ed = tar;
        for (int i = ed; i != st; i = pre[i]) used[i] = 1;
        used[st] = 1;
        ans[++m] = array<int, 3>({ d[ed], max(st, ed), min(st, ed) });
    }
    sort(ans + 1, ans + m + 1, greater<array<int, 3>>());
    for (int i = 1; i <= m; i++) printf("%d %d %d ", ans[i][0], ans[i][1], ans[i][2]);
    putchar('\n');
}

int main() {
    // freopen("D.out", "w", stdout);
    int T = read();
    while (T--) solve();
    return 0;
}

E. Ain and Apple Tree

  • 可以发现，当构造出来的树是一条链的时候答案最大，答案为 ∑ i = 0 n − 1 i ⋅ ( n − i − 1 ) \sum_{i = 0}^{n - 1}i \cdot (n - i - 1) ∑i=0n−1​i⋅(n−i−1)。
    • 如果 k > ∑ i = 0 n − 1 i ⋅ ( n − i − 1 ) + 1 k > \sum_{i = 0}^{n - 1}i \cdot (n - i - 1) + 1 k>∑i=0n−1​i⋅(n−i−1)+1，则无解。
  • 将一条链状的树的最深节点往上移到比其深度小 x x x 的节点的地方时，最后答案会减小 1 + 2 + … + x − 1 = x ( x − 1 ) 2 1 + 2 + \ldots + x - 1 = \frac{x(x - 1)}{2} 1+2+…+x−1=2x(x−1)​。
  • 我们可以将要构造的树初始化为链状，然后将最深节点依次上移，直到 ∣ ∑ i = 1 n ∑ j = i + 1 n d e p ( l c a ( i , j ) ) − k ∣ < 1 |\sum_{i = 1}^n\sum_{j = i + 1}^ndep(lca(i, j)) - k| < 1 ∣∑i=1n​∑j=i+1n​dep(lca(i,j))−k∣<1。

时间复杂度： O ( n ) O(n) O(n)。

#include <bits/stdc++.h>
using namespace std;

#define int long long 

int n, k;

void solve() {
	cin >> n >> k;
	int maxm = 0;
	for (int i = 0; i < n; i++) maxm += i * (n - i - 1);
	if (maxm < k - 1) {
		cout << "No\n";
		return;
	}
	k = maxm - k;
	vector<vector<int>> g(n + 1);
	int h = n - 1;
	for (int i = n - 1; i; i--)
		if (k >= i * (i - 1) / 2) {
			g[h - i].push_back(h);
			h--;
			k -= i * (i - 1) / 2;
		}
	for (int i = 0; i < h; i++) g[i].push_back(i + 1);
	cout << "Yes\n";
	for (int i = 0; i < n; i++) {
		for (int v : g[i]) cout << i + 1 << " " << v + 1 << "\n"; 
	}
}

signed main() {
	ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr);
	int T;
	cin >> T;
	while (T--) solve();
	return 0;
}

F1. Cycling (Easy Version)

  • 当 a [ x , y ) > = a y + 1 a_{[x,y)} >= a_y + 1 a[x,y)​>=ay​+1 时，每次将 y y y 前移一定不会使答案更劣，因为这种操作的花费为 a y + 1 a_y + 1 ay​+1，其中 1 1 1 是前移的花费。
  • 如果 a y a_y ay​ 要后移到位置 z z z，Leo 超越到位置 x x x 的花费为 c o s t [ z + 1 , n ] + ( z − y ) ⋅ a y + ( z − y ) + ( z − x − 1 ) cost_{[z + 1, n]} + (z - y) \cdot a_y + (z - y) + (z - x - 1) cost[z+1,n]​+(z−y)⋅ay​+(z−y)+(z−x−1)。

时间复杂度： O ( n 2 ) O(n^2) O(n2)。

#include <bits/stdc++.h>
using namespace std;

#define int long long

const int N = 5e3 + 10;
int n, a[N], dp[N];

void solve() {
	cin >> n;
	for (int i = 1; i <= n; i++) cin >> a[i], dp[i - 1] = LLONG_MAX;
	dp[n] = 0;
	for (int i = n - 1; i >= 0; i--) {
		int p = i + 1;
		for (int j = i + 1; j <= n; j++)
			if (a[j] < a[p]) p = j;
		for (int j = p; j <= n; j++)
			dp[i] = min(dp[i], dp[j] + 2 * (j - p) + (j - i) * a[p] + p - i - 1);
	}
	cout << dp[0] << "\n";
}

signed main() {
	ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr);
	int T;
	cin >> T;
	while (T--) solve();
	return 0;
}

时间复杂度： O ( n 2 ) O(n^2) O(n2)

Codeforces Round 960 (Div. 2)
MenghuanL的博客
07-22 911
总结：Awa 2，Bwa 2，C一直wa。很难评价的一场。感觉D < C。
Codeforces Round 975 (Div. 2)(A~F)
weixin_61825750的博客
09-28 2621
疯狂掉分中
Codeforces Round 1023 (Div. 2) ABC
its_a_win的博客
05-06 454
ABC
Codeforces Round 1004 Div.2 ABCD题解
sisjsje的博客
02-12 1092
这一场真的不难，前四题都是思维题，感觉比上一场Div.4要简单的多平时没怎么做过交互题，所以花费了太长时间去理解，后面的题补了再写题解。
Codeforces Round 965 (Div. 2) 8.10
2301_81692739的博客
08-11 1061
看题得认真，不能迷糊，不然太费时间。
Codeforces Round 1015, Div. 1 + Div. 2
2301_81692739的博客
04-16 917
f (b) 是 mex(b) 的最小可能值，所以最多进行m次操作，视作 进行 m 次。设n 放在位置 x ,则 max(a[x-1],a[x])=n，应满足 n%x=x-1。​ n / (m+1) ，所以 f (b) 最大为 n / (m+1)-对于所有 2≤i≤n ，满足 max(pi−1,pi)mod。​ 每个数字最多删除m 次，要想留下来，至少存在 m+1 个。每次删除 k 个 ，删除m 次，最后剩下 n-m * k。进行排列， f (b)最大为 n - m * k。
Codeforces Round 1012 (Div. 2)
gyc271828的博客
03-26 1266
其实题干中已经有提示了，题一定有解，sum(b)>=sum(a)；和sum(a)有关，我们发现经过第一次操作后大数变为其和小数的差，小数直接变为0，然后a错位减。构造题，我们想取一个质数让 i=1时它是质数，但是当i=2时它肯定不是质数了，那么i=3时。一开始的想法是类似于一个dp看看这个1的左侧和上侧有没有1，如果有是对的不然直接退出。其实想法和答案以经很接近了，就是找每一个数变为0的步数然后求一个最大值，但是没往深想。就是动态维护一下起点到哪些桌子点最小的点，和到座位最小的点，可以用小根堆维护。
Codeforces Round 968 (Div. 2)
HKUST_ZJH的博客
08-28 1540
Codeforces Round 968 (Div. 2)
Codeforces Round 973 (Div. 2)
2301_79929720的博客
09-21 1339
Codeforces Round 973 (Div. 2)
Codeforces Round 992 (Div. 2)
2301_80475191的博客
12-09 531
这场cf只在b卡了一下，因为b真是犯蠢了，我以为会向下取整，结果是完全就不取整，或者说是向上取整，卡了我半个小时，要不是紧急看了题一下，昨天那场就毁了话不多说，直接开讲思路：很容易就能看出来就是同余定理，能够找到一个取模k的数，且只有这一个数取模k为当前的余数，那么就输出这个数，否则一定存在两个数相减会导致能被k整除。
Codeforces Round 1016 (Div. 3)
maisui12138的博客
04-09 977
但在x求取{x,y}时，由于我们的真实坐标是需要由最终推出的四元素坐标增加不同值得到的，所以递归过程中，以此为条件，我们可以不断将当前需要寻找的{x,y}不断向左上角的{1,2,3,4}进行递归。一直这削减的是所求元素x的大小去向{1,2,3,4}靠近，而记录的坐标值是不断增加的。实际上n=1是特殊的，对于1的不同相接元素是存在素数的，比如11。我们的思路还是递归到最左上的{1,2,3,4}，但有一点需要注意。很典的二分，直接二分Mex的值，然后尽可能的分成k段。同理，对于寻找大小为x的值的坐标。
Codeforces Round 958 (Div. 2)
鱼香rose_的博客
07-16 1557
CodeforcesRound958(Div.2)\Huge{Codeforces Round 958 (Div. 2)}CodeforcesRound958(Div.2)给出一个数组，每次可以选择数组中的一个数，并将其拆为不超过kkk个数。问最少需要几次可以构造出全111数组（数组中只包含111）。贪心的想，我们每次可以将选出的数字x拆为1+1+1+…+(x-k+1)。那么结果即为： ⌈n−1k−1⌉ \left \lceil \frac{n-1}{k-1} \right \rceil ⌈k−1n−1​
Codeforces Round 961 (Div. 2)
2301_76605150的博客
07-24 1051
算法小白刷题过程
Codeforces Round 961 (Div. 2)（A~D)
weixin_61825750的博客
07-24 1628
因此我们对于每一个位置，只需要将最大的那个集合设为不可选，然后最终将大集合中的所有小集合同步更新即可。枚金币买尽可能多的价格少的那一种花，然后再用剩下的钱买尽可能多的价格多的那一种花。因此我们只需要从后往前遍历所有位置，然后统计哪些集合是没法选的，最终在剩下的集合中选一个所含字母最少的即可。，接下来我们只需要求最多可以执行多少次这样的操作即可，然后便可以求出最大的花瓣数。然后，我们可以通过放弃价格少的一种花，再购买价格多的那一种花，使得所得到的花瓣加。贪心，先将占有单元格最多的对角线填满，然后依次往下填。
Codeforces Round 965 (Div. 2)
Landing_on_Mars的博客
08-11 381
情况一：最大值可能值经过加1操作，这种情况下将所有的k次操作全部操作到这个数上最优，因为，将加1操作直接操做上最终结果一定加1，而操作到其他数字上最终结果最优情况下也是加1，所以这样操作情况不会变得更差。容易发现，要想结果最大，那么一定是最大值序列中的最大值加上剩下数字的中位数。情况二：最大化中位数。这种情况可以使用二分来查找最大情况的中位数。
算法-数对的使用
最新发布
2303_80050865的博客
05-19 158
【代码】算法-数对的使用。
代码随想录算法训练营第60期第三十九天打卡
2401_83782806的博客
05-17 809
首先我们就直接看到这一道题目，看看我们是否可以发现究竟在考查哪一个算法：我们来看一下题意，就是我们有一堆石头，我们每一次可以选出任意两块石头并将其一起粉碎，如果两块石头的重量相同那么两块石头都会被完全粉碎，如果一块石头重量大一块石头重量小的话，那么我们重量小的石头会被完全粉碎，大的石头剩下的重量是大的石头减去小的石头，最后我们只会剩下一块石头，那么题目要求我们返回此石头的最小的可能重量，如果没有剩余就返回0，那么我们应该如何思考这一道题目呢？
高被引二区优化算法——肝癌算法（Liver Cancer Algorithm，LCA）深度解析+性能测试
woaipythonmeme的博客
05-19 645
LCA的核心机制聚焦于肿瘤在寻找最有利生存环境时所表现出的适应性与侵袭性行为，算法通过演化搜索策略再现肝癌细胞在器官中逐步扩张并主导空间的动态机制，其数学建模确保了算法在解空间内的全局探索能力与局部开采能力之间的高效平衡。为确定肿瘤的体积，我们采用一种基于数学模型的计算方法，假设肿瘤呈半椭球形，该形态已在包括肝癌在内的多种癌症中被观察到。在LCA算法的该阶段中，其设计灵感源自真实肿瘤的扩散过程，假设肿瘤可在竞争环境中逐步选择最优路径深入肝脏的不同区域以实现侵占。）时，目标代理元素的肿瘤位置将被考虑。
算法练习：19.JZ29 顺时针打印矩阵
qq_34348690的博客
05-16 358
【代码】算法练习：19.JZ29 顺时针打印矩阵。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值