The 2023 ICPC Asia Jinan Regional Contest (The 2nd Universal Cup. Stage 17: Jinan)

最新推荐文章于 2025-08-25 16:51:38 发布
最新推荐文章于 2025-08-25 16:51:38 发布
阅读量996 收藏 17
点赞数 8
CC 4.0 BY-SA版权
分类专栏： Codeforces 文章标签： 算法 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80105412/article/details/142619911

背景

我是菜逼

A.Many Many Heads

思路

怎样才是合法括号序列？首先是"("的数量等于")"的数量，其次是从左往右遍历的过程中"("的数量始终不少于")"的数量。（但是这题没有任何关系）

用来维护合法括号序列的有用数据结构是栈

首先先把这个序列给调成合法的，其次就是判断是否唯一

1.遇到")("或者"]["

2.遇到")[X]("或者"](X)["

X是一个合法括号序列

代码

#include <bits/stdc++.h>
#define int long long
#define vv vector
using namespace std;
using PII = pair<int, int>;
/*
sad
*/
void solve() {
    string s; cin >> s;
    int n = s.size();
    vv<char> st;
    for (char &c : s) {
        if (st.empty()) {
            if (c == ')') c = '(';
            else if (c == ']') c = '[';
            st.push_back(c);
        }else {
            if (st.back() == '(') {
                if (c == '(') c = ')', st.pop_back();
                else if (c == ')') st.pop_back();
                else c = '[', st.push_back(c);
            }else if (st.back() == '[') {
                if (c == '[') c = ']', st.pop_back();
                else if (c == ']') st.pop_back();
                else c = '(', st.push_back(c);
            }else {
                if (c == ']') c = '[';
                if (c == ')') c = '(';
                st.push_back(c);
            }
        }
    }
    bool ok = true;
    vv<int> pos(n + 2), st1, st2;
    s = ' ' + s + ' ';
    for (int i = 1; i <= n; i ++ ) {
        if (s[i] == '(') st1.push_back(i);
        else if (s[i] == '[') st2.push_back(i);
        else {
            if (s[i] == ']') pos[st2.back()] = i, st2.pop_back();
            else pos[st1.back()] = i, st1.pop_back();
        }
    }
    for (int i = 1; i < n; i ++ ) {
        if (s[i] == ')' && s[i + 1] == '(') ok = false;
        if (s[i] == ']' && s[i + 1] == '[') ok = false;
        if (s[i] == ')' && pos[i + 1] && s[pos[i + 1] + 1] == '(') ok = false;
        if (s[i] == ']' && pos[i + 1] && s[pos[i + 1] + 1] == '[') ok = false; 
    }
    if (ok) puts("Yes");
    else puts("No");
	return;
}

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

D.Largest Digit

思路

如果l和r之间相差10，那么就一定可以由两个数组出来一个9

否则直接暴力就行了

代码

#include <bits/stdc++.h>
#define int long long
#define vv vector
using namespace std;
using PII = pair<int, int>;
/*
sad
*/
void solve() {
    
	int l, r, l1, r1; cin >> l >> r >> l1 >> r1;
    int ans = -1;
    if (r - l >= 10 || r1 - l1 >= 10) ans = 9;
    else {
        for (int i = l; i <= r; i ++ ) {
            for (int j = l1; j <= r1; j ++ ) {
                int cur = i + j;
                while (cur) {
                    ans = max(ans, cur % 10);
                    cur /= 10;
                }
            }
        }
    }
    cout << ans << endl;
	return;
}


signed main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
    srand(time(0));
	int tt = 10000; cin >> tt;
	while (tt -- ) solve();
	return 0;
}

G.Gifts from Knowledge

思路

首先，如果第i列和第m-i+1列的“1”的数量超过了2，那么是不可能的

记原字符串为S，翻转后的字符串为T

现在遇到了两个字符串Si，Ti，Sj，Tj

如果两个字符串在第k的位置上都有“1”，那么Si一定是跟Tj在一块的，Sj一定是跟Ti在一块的

如果两个字符串在第k和m-k+1的位置上都有“1”，那么Si一定是跟Sj在一块的，Ti一定是跟Tj在一块的

我们用并查集维护这一个“在一块”

fa[i]放Si，fa[i+n]放Ti

最后只需要判断Si和Ti是否在同一个连通块即可

对于答案

如果符合题意，我们一定是得到偶数个连通块的，记为n

那么可以选S也可以选T，就会有2的n/2次贡献

代码

#include <bits/stdc++.h>
#define int long long
#define vv vector
using namespace std;
using PII = pair<int, int>;
/*
Have a nice day!
*/
const int mod = (int)1e9 + 7;
int qpow(int a, int b) {
    int res = 1;
    while (b) {
        if (b & 1) res = res * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return res;
}
void solve() {
    int n, m; cin >> n >> m;
    vv<vv<int>> col(2 * m + 1);
    for (int i = 1; i <= n; i ++ ) {
        string s; cin >> s; 
        s = ' ' + s;
        for (int j = 1; j <= m; j ++ ) if (s[j] - '0') col[j].push_back(i);
    }
    for (int i = 1; i <= (m + 1) / 2; i ++ ) {
        if (col[i].size() + col[m - i + 1].size() > 2) return cout << 0 << endl, void();
    }
    vv<int> fa(2 * n + 1);
    function<int(int)> find = [&](int x) {
        return fa[x] == x ? x : fa[x] = find(fa[x]);
    };
    iota(fa.begin(), fa.end(), 0);

    for (int i = 1; i <= m / 2; i ++ ) {
        if (col[i].size() == 2) {
            int f1 = find(col[i][0]), f4 = find(col[i][1] + n);
            fa[f4] = f1;
            int f2 = find(col[i][1]), f3 = find(col[i][0] + n);
            fa[f3] = f2;
        }else if (col[m - i + 1].size() == 2) {
            int f1 = find(col[m - i + 1][0]), f4 = find(col[m - i + 1][1] + n);
            fa[f4] = f1;
            int f2 = find(col[m - i + 1][1]), f3 = find(col[m - i + 1][0] + n);
            fa[f3] = f2;
        }else if (col[i].size() && col[m - i + 1].size()) {
            int f1 = find(col[i][0]), f2 = find(col[m - i + 1][0]);
            fa[f2] = f1;
            int f3 = find(col[i][0] + n), f4 = find(col[m - i + 1][0] + n);
            fa[f3] = f4;
        }
    }
    for (int i = 1; i <= n; i ++ ) if (find(i) == find(i + n)) return cout << 0 << endl, void(); 
    vv<int> vis(2 * n + 1);
    int ans = 0;
    for (int i = 1; i <= 2 * n; i ++ ) {
        if (!vis[find(i)]) {
            vis[find(i)] = 1;
            ans += 1;
        }
    }
    ans /= 2;
    cout << qpow(2, ans) << endl;
	return;
}

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

I.Strange Sorting

思路

先进行题目意思的转化，每次可以选择一个逆序对，然后使得这个区间内的数变成升序。

题目中的n/2是哪里来的？

2 1 4 3 6 5

相邻的两个元素分别要sort一下，所以是n/2次

那么我们从左往右进行遍历，当a[i] != i的时候，我们就必须选择一个逆序对进行sort，这时候我们选择哪一个呢？

1 2 5 4 3

当我们到5的时候，我们天然的会去选3，直接sort完毕

1 2 5 3 4

我们会去选4，也是直接sort完毕

明显地是

1 2 5 4 3

我们sort 5，4的话，会是

1 2 4 5 3

并不能使得3归位

1 2 5 3 4

如果sort 5，3的话

1 2 3 5 4

会被卡n/2的需求

那么我们是不是只要找离它最远的一个逆序对就可以了？

可以证明的是，这样一定可以sort一遍使得两个数归位

代码

#include <bits/stdc++.h>
#define int long long
#define vv vector
using namespace std;
using PII = pair<int, int>;
/*
Have a nice day!
*/
void solve() {
    int n; cin >> n;
    vv<int> a(n + 1);
    for (int i = 1; i <= n; i ++ ) cin >> a[i];
    vv<PII> ans;
    for (int i = 1; i <= n; i ++ ) {
        if (a[i] == i) continue;
        int id = -1;
        for (int j = i + 1; j <= n; j ++ ) if (a[j] < a[i]) id = j;
        ans.push_back({i, id});
        sort(a.begin() + i, a.begin() + id + 1);
    }
    cout << ans.size() << endl;
    for (auto [l, r] : ans) cout << l << ' ' << r << endl;
	return;
}

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

K.Rainbow Subarray 

思路

判断是否为连续子数组的有效方式是，对于每一个i，都让ai减去i（cf上做过）

那么问题就转化成了，在k次操作下，所包含元素都相同的区间长度是多少

然后再进行思考，使得区间里的元素都变成相同的最小花费是多少？

这个问题就是路程最短问题，是变成这些元素中的中位数。

中位数如果用二分去做的话，是去枚举长度的，最优也是两个log，是错误的

因为连续，我们考虑滑动窗口，中位数的话用set维护即可

代码

#include <bits/stdc++.h>
#define int long long
#define vv vector
using namespace std;
using PII = pair<int, int>;
/*
sad
*/
void solve() {
	int n, k; cin >> n >> k;
    vv<int> a(n + 1);
    for (int i = 1; i <= n; i ++ ) {
        cin >> a[i], a[i] -= i;
    }
    multiset<int> SA, SB;
    int suma = 0, sumb = 0;
    SA.insert(a[1]), suma += a[1];
    int ans = 1;
    function<void()> clear = [&]() {
        while (SA.size() > SB.size() + 1) {
            int x = *SA.rbegin();
            SB.insert(x); sumb += x;
            SA.erase(SA.find(x)); suma -= x;
        }
        while (SB.size() > SA.size()) {
            int x = *SB.begin();
            SA.insert(x); suma += x;
            SB.erase(SB.find(x)); sumb -= x;
        }
        while (SB.size() && (*SA.rbegin()) > (*SB.begin())) {
            int x = (*SA.rbegin()), y = (*SB.begin());
            suma -= x, sumb -= y;
            SA.erase(SA.find(x)), SB.erase(SB.find(y));
            SA.insert(y), SB.insert(x);
            suma += y, sumb += x;
        }
    };
    function<int()> calc = [&]() {
        int res = (sumb - SB.size() * (*SA.rbegin()));
        res += (SA.size() * (*SA.rbegin()) - suma);
        return res;
    };
    for (int i = 2, j = 1; i <= n; i ++ ) {
        SA.insert(a[i]), suma += a[i];
        clear();
        while (j <= n && calc() > k) {
            if (SB.count(a[j]))  SB.erase(SB.find(a[j])), sumb -= a[j];
            else SA.erase(SA.find(a[j])), suma -= a[j];
            j += 1;
            clear();
        }
        clear();
        ans = max(ans, (int)SA.size() + (int)SB.size());
        
    }
    cout << ans << endl;
	return;
}


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

Knapsack（ The 2023 ICPC Asia Nanjing Regional Contest (The 2nd Universal Cup. Stage 11 Nanjing) ）
BoBoo文睡不醒
01-26 941
Knapsack（ The 2023 ICPC Asia Nanjing Regional Contest (The 2nd Universal Cup. Stage 11: Nanjing) ） Little Cyan Fish, an inexperienced businessman, recently launched a store named Queen’s Organic Jewelry. This jewelry store houses n n gemstones, where the
二分+DP The 2023 ICPC Asia Hefei Regional Contest Problem G Streak Manipulation
m0_73738728的博客
02-04 1572
给定一个长度为n的01串，最多可以将m个0变成1，要求使01串中第k长连续1串的长度最大。输出最大值，如果无法得到第k长的连续1串，输出-1。
The 2023 ICPC Asia Regionals Online Contest (2)-2023 ICPC网络赛第二场部分题解 I,M
m0_73646108的博客
09-25 1031
共n个阶段，要从第0个阶段到达第n个阶段，有两种方法：（1）每天走一个阶段，第n天后到达第n个阶段。（2）开启“挑战” 模式，成功直接到第n阶段，成功概率为p/1e5;共有n道题，每道题有（1-pi）的概率需要 ai 的时间AC，有 pi 的概率需要（ai+bi）的时间AC，最优策略下，只会在一个点挑战，该点成功即到达第n阶段，枚举每个点作为挑战点，取最小值。根据ICPC规则，对于第i道题，它的罚时为从比赛开始直到它被AC的总时间。现给出n道题的ai,bi,qi，求做完所有题目需要的最小期望罚时。
The 2023 ICPC Asia Regionals Online Contest (I)部分题解
qq_61940050的博客
09-21 816
如果C1的圆心在C2的左边，肯定是C2左半部分某点到C1圆心的曼哈顿距离，否则则是C2右半部分到C1圆心的曼哈顿距离，通过圆心和半径表示出圆的方程，用方程把x坐标或y坐标表示出，带入曼哈顿距离公式，然后三分求解。先对两场的排名进行去重，然后依次从第一场和第二场各取出一所学校，如果未加入最终排名，则加入，否则跳过，有一场取完后就只从另一场取，直到取完所有学校。给定n个点，m条边的一个简单无向图。先判连通块，如果所有连通块都是可传递的，则连接最小的两个连通块，否则使每个连通块可传递。
Largest Digit（思维题）
qq_45809243的博客
05-14 1222
Largest Digit（思维题）
The 2023 ICPC Asia Nanjing Regional Contest (The 2nd Universal Cup. Stage 11: Nanjing)
qq_73631501的博客
09-12 502
容易发现f【i+1】>=f【i】，g【i】>=g【i+1】，有单调性，可以发现一定存在位置p，使得1到p min（f【i】，g【i】）取f【i】，p+1到n取g【i】，可以二分这个位置然后去判断f【i】和g【i】的大小就可以得出位置，然后原式变成f【1】+...f【p】+g【p+1】+...g【n】-sigma a【i】就是答案，这样是loglog的。就用sigma f【i】+sigma g【i】-n*max a【i】-sigma a【i】这个式子，难度在怎么维护f数组和g数组。
The 2023 ICPC Asia Hangzhou Regional Contest (The 2nd Universal Cup. Stage 22: Hangzhou) D题
wh233z的博客
05-19 1143
思维构造题，由等号的右边（a2+a3）*（a4+a5），可以构造2和-1（0不可取），这样2+（-1）为1，等号右边就为a1和a2n，等号左边为2a1*（-2)*(-2)*(-a2n),这样就相当于解二元方程，那么直接去a2n为1，解得a1为1-(-2)*(n-2)，然后按题意输出即可。给定一个整数n，输出2n个数，并且这些2n个数满足。
The 2023 ICPC Asia Hangzhou Regional Contest (The 2nd Universal Cup. Stage 22: Hangzhou)D、J、M题题解
wzxtsl的博客
05-01 425
这道题一定要看清题，题中给的就是一个V图，就不用再排序了。然后针对于这个图，我们发现最大的有可能的三个范围实际上就是全部的sum/n或者是最低点左边的全部和加上右边第一个除以对应的个数或者是最低点右边的和加上最低点左边的数除以相应的个数，这个可以大概理解一下，这个代码中要注意的是，我们最后要保留9位输出的话，也就是意味着我们要使用double类型的变量，但输入时数据为int类型，因此我们直接用int接受，但最后使用出发求职的时候用1.0L*res这种方式使得结果变为double类型。
题解 (The 2019 ICPC Asia Shanghai Regional Contest - Online Contest).pdf
01-12
根据给定文件的信息，我们可以总结出以下相关的IT与编程知识点： ### A-Lightning Routing I ...以上各个知识点涵盖了数据结构、算法优化、数学推导等多个方面，对于参加ICPC等编程竞赛的同学来说具有很高的实用价值。
The 2020 ICPC Asia Macau Regional Contest C Club Assignment 题解
weixin_44209093的博客
07-13 1639
题意：有n个数，现在要把他们拆分成两个集合，假设S为集合，有如下定义：f(S)={min(x⊗y)∣x,y∈S and x≠y} f(S)=\{min(x\otimes y)|x,y\in S \ and\ x\neq y \} f(S)={min(x⊗y)∣x,y∈S and x​=y}将n个数拆分为两个集合A,B，要求最大化min(f(A),f(B) )min(f(A),f(B)\ )min(f(A),f(B) ),并输出划分集合的方案，如果
The 2022 ICPC Asia Regionals Online Contest (I) 补题
m0_62167326的博客
09-19 531
ICPC
计数组合学7.20（平面分拆与RSK算法)
weixin_74905422的博客
08-22 1073
实际上，一个反半标准杨表（reverse SSYT）就是一种特殊的平面分拆（移除了无关的0），事实上，在我们定义反半标准杨表时，我们提到了另一个术语“列严格平面分拆”。本节和接下来的两节将致力于讨论整数分拆的一个引人入胜的推广，称为“平面分拆”。我们将基于 RSK 算法以及一种将一对同形状的反半标准杨表合并成单个平面分拆的简单方法，给出一个优雅的双射证明。当我们考虑 RSK 算法的对称性结果定理 7.13.1 时，定理 7.20.1 的一个很好的变体就出现了。的每一列都是互异奇数部分的分拆。
力扣（在排序数组中查找元素的第一个和最后一个位置）
weixin_52811458的博客
08-22 1119
本文解析了LeetCode 34题，探讨如何在有序数组中高效查找目标值的起始和结束位置。通过分析原始代码的复杂度问题，提出优化方案：采用两次独立的二分查找，分别定位左边界（第一个等于目标值的位置）和右边界（最后一个等于目标值的位置）。优化后的代码逻辑更清晰，时间复杂度保持O(log n)，空间复杂度为O(1)。关键点在于正确处理二分查找的边界条件，先验证左边界有效性，再推导右边界，确保结果准确。
c语言指针学习
曾大强博客
08-24 488
用途描述关键点基本操作通过指针间接访问和修改变量与数组高效地遍历和操作数组数组名即指针，指针算术运算与函数实现传址调用，修改实参，返回多个值函数参数定义为指针动态内存在运行时申请任意大小的内存malloccallocreallocfree掌握指针需要大量的练习和实践。先从简单的例子开始，理解地址和值的区别，然后再逐步深入到数组、函数和动态内存管理中。
【数据结构】计数排序：有时比快排还快的整数排序法
leilei050213的博客
08-23 364
计数排序是一种非比较排序算法，适用于整数数据且范围较小的情况。其核心思想是统计每个元素出现的次数，然后根据统计结果将元素重新排列。虽然时间复杂度高效（O(N+range)），但空间复杂度较高（O(range)），且仅适用于整数类型。该算法在数据范围集中时性能优异，比快速排序更快，但在数据范围较大时空间消耗显著。
数据结构之排序大全（4）
pusue_the_sun的博客
08-21 829
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法，该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
亚远景- 从算法到刹车片：ISO/PAS 8800如何量化自动驾驶的“安全冗余”？
最新发布
yayuanjingkeji的博客
08-25 321
ISO/PAS8800标准为自动驾驶安全构建量化体系，覆盖数据、算法、系统全生命周期：数据层要求99%常规场景和100%极端场景覆盖率；算法层通过对抗防御、置信度阈值等提升鲁棒性；系统层采用多传感器冗余和双芯片设计确保故障切换。标准要求10万+仿真场景测试和1000万公里实车验证，推动行业从定性安全转向可量化工程实践。地平线、MUNIK等企业已通过认证，欧盟拟将其纳入L4级法规审批，标志着自动驾驶安全进入"主动免疫"新阶段。
2022-2023 icpc brazil subregional programming contest
03-16
很抱歉，我是一名语言模型AI，无法参加编程竞赛。不过，2022-2023 icpc brazil subregional programming contest是巴西的一个编程竞赛，旨在鼓励和促进计算机科学和编程技能的发展。参赛者需要在规定时间内解决一系列编程问题，以获得最高分数。这是一个很好的机会，让编程爱好者展示自己的技能和才华。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值