Educational Codeforces Round 166(Div.2) A~D

最新推荐文章于 2025-11-24 15:27:16 发布

原创最新推荐文章于 2025-11-24 15:27:16 发布 · 949 阅读

24 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #数据结构 #OI #ACM-ICPC #c++ #codeforces

codeforces题解专栏收录该内容

101 篇文章

订阅专栏

A.Verify Password（字符串）

题意：

Monocarp正在开发他的新网站，目前面临的挑战是如何让用户选择强密码。

Monocarp认为，强密码应满足以下条件：

密码只能由小写拉丁字母和数字组成；
字母后面不能有数字（因此，每个字母后面要么有另一个字母，要么字符串结束）；
所有数字应按非递减顺序排序；
所有字母应按非递减顺序排序。

请注意，密码可以只有字母或数字。

Monocarp成功地实现了第一个条件，但他在其余条件上很吃力。您能帮他验证密码吗？

分析：

按照 $A SC II$ 值进行比较（因为字母的 $A SC II$ 本来就在数字后面）。只要找到前面比后面的数大就输出 $NO$ ，反之 $Y ES$ 。

代码：

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

void solve(){
    int n;
    cin>>n;
    string s;
    cin>>s;
    bool flag = true;
    for (int i = 1; i < n; i++){
        if (isalpha(s[i - 1]) && isdigit(s[i])){
            flag = false;
            break;
        }
        if(s[i - 1] > s[i]){
            flag = false;
            break;
        }
    }
    if(flag)
        cout<<"YES"<<endl;
    else
        cout<<"NO"<<endl;
}

int main(){
    int t;
    cin>>t;
    while(t--){
        solve();
    }
    return 0;
}

B.Increase/Decrease/Copy（思维）

题意：

给你两个整数数组：长度为 $n$ 的数组 $a$ 和长度为 $n + 1$ 的数组 $b$ 。

你可以按任意顺序执行下列操作任意次数：

选择数组 $a$ 中的任意元素，并将其增加 $1$ ；
选择数组 $a$ 中的任意元素，并将其减少 $1$ ；
选择数组 $a$ 中的任意元素，复制并追加到数组 $a$ 的末尾。

你的任务是计算将数组 $a$ 转换为数组 $b$ 所需的最少上述操作次数（可能为零）。可以证明，在问题的限制条件下，这总是可能的。

分析：

对于 $ai−>bi,1≤i≤na_i->b_i,1\le i\le n$ ，转变的最小代价就是它们的差值。

对于 $b_{n+1}$ ，得到它的最小代价就是 $a_i->b_i$ 过程中与它最小的差值 $+ 1$ 。

代码：

#include<bits/stdc++.h>

typedef long long LL;
using namespace std;
#define INF 0x7fffffff

void solve() {
    int n;
    cin >> n;
    vector<int> a(n);
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }
    vector<int> b(n + 1);
    for (int i = 0; i < n + 1; i++) {
        cin >> b[i];
    }
    int need = INF;
    LL ans = 0;
    for (int i = 0; i < n; i++) {
        ans += abs(b[i] - a[i]);
        need = min(need, abs(b[n] - b[i]));
        need = min(need, abs(b[n] - a[i]));
        if (a[i] < b[n] && b[n] < b[i] || a[i] > b[n] && b[n] > b[i])
            need = 0;
    }
    cout << ans + need + 1 << endl;
}

int main() {
    int t;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

C.Job Interview（枚举）

题意：

Monocarp打算开一家自己的IT公司。他想招聘 $n$ 名程序员和 $m$ 名测试员。

有 $n + m + 1$ 名候选人，按到达时间顺序从 $1$ 到 $n + m + 1$ 依次编号。第 $i$ 个候选人的编程技能为 $a_i$ ，测试技能为 $b_i$ （一个人的编程技能和测试技能是不同的）。团队的技能是所有被聘为程序员的候选人的编程技能之和，以及所有被聘为测试员的候选人的测试技能之和。

当应聘者前来面试时，Monocarp会尝试将其分配到最适合的职位（如果应聘者的编程技能较高，则录用其为程序员，否则录用其为测试员）。如果该职位的所有名额都已招满，Monocarp就会将他们分配到其他职位。

你的任务是，针对每个候选人，计算如果除他们之外的所有人都来面试，团队的技能。请注意，这意味着正好有 $n + m$ 名候选人来参加面试，因此公司的所有 $n + m$ 个职位都将被填满。

分析：

从前往后遍历，检查一下是 $a$ 能力值浪费了还是 $b$ 能力值浪费了，然后从后往前枚举，开一个数组维护一下最近后缀损失能力值。输出答案的时候，如果当前的人的站的职位刚好是能力值被浪费的职位，输出总和减去当前的人的能力值加上最近损失能力值。

代码：

#include<bits/stdc++.h>

typedef long long LL;
using namespace std;
const LL N = 1e6 + 10;
LL q[N], p[N], a[N], b[N];

void solve() {
    LL n, m;
    cin >> n >> m;
    LL sum1, sum2, num1, num2, f;
    sum1 = sum2 = num1 = num2 = f = 0;
    for (int i = 0; i <= n + m; i++) {
        cin >> a[i];
        q[i] = p[i] = 0;
    }
    for (int i = 0; i <= n + m; i++) {
        cin >> b[i];
        f += a[i] > b[i];
        if (a[i] > b[i] && num1 <= n || m == i - num1) {
            num1++;
            sum1 += a[i];
            p[i] = 1;
        } else
            sum1 += b[i];
        if (a[i] < b[i] && num2 <= m || n == i - num2) {
            num2++;
            sum2 += b[i];
            q[i] = 1;
        } else
            sum2 += a[i];
    }
    for (int i = 0; i <= n + m; i++) {
        cout << " ";
        cout << (f > n ? (p[i] ? sum1 - a[i] : sum2 - b[i]) : (q[i] ? sum2 - b[i] : sum1 - a[i]));
    }
}

int main() {
    int t;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

D.Invertible Bracket Sequences（前缀和、双指针）

题意：

正则括号序列是指可以通过在序列的原始字符之间插入字符"1"和"+"来转换成正确算术表达式的括号序列。例如

括号序列"()()“和”(())“是正则表达式（得到的表达式是”(1)+(1)“和”((1+1)+1)"）；
括号序列")(“、”(“和”)"则不是。

让我们定义括号序列的逆序如下：用’)‘替换所有括号’(‘，反之亦然（用’(‘替换所有括号’)'）。例如，字符串"()((“和”)())"互为反义词。

给你一个正则括号序列 $s$ 。计算如果将 $s$ 中从第 $l$ 个字符到第 $r$ 个字符（包括）的子串 $s$ 替换为其逆序数， $s$ 仍然是正则括号序列的整数对 $(l, r)$ ( $1≤l≤r≤∣s∣1\le l\le r\le|s|$ )的个数。

分析：

统计序列前 $i$ 个有多少个左括号是剩余的，然后思考 $(l, r)$ 的选择有何特征：可以发现，若第 $i$ 位之前所剩余的左括号跟第 $j$ 位之前所剩余的左括号数量一样，那么 $(i + 1, j)$ 这个区间就可能被选择，否则一定不会被选择。

因此我们将剩余左括号数量相同的位置放一起，然后考虑其区间能否真的被选中。通过观察可以发现：若 $(i, j)$ 之间位置的剩余左括号数量小于等于第 $i$ 位之前所剩余的左括号的两倍，那么这个区间就可以被选中，因此本题转换成 $RMQ$ 问题。

在枚举位置时，随着起始位置的增大，末尾位置也一定是非递减的，因此用双指针可以将复杂度从 $O(n^{2}logn)$ 变为 $O (n l o g n)$ 。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
const LL N = 5e05 + 10;

LL n;
vector<LL> a(N, 0);

LL Max[N][21];
LL Min[N][21];

struct ST {
    void init() {
        for (LL i = 1; i <= n; i++) {
            Max[i][0] = a[i];
            Min[i][0] = a[i];
        }
    }

    void work() {
        for (LL j = 1; j <= 21; j++)
            for (LL i = 1; i + (1 << j) - 1 <= n; i++) {
                Max[i][j] = max(Max[i][j - 1], Max[i + (1 << (j - 1))][j - 1]);
                Min[i][j] = min(Min[i][j - 1], Min[i + (1 << (j - 1))][j - 1]);
            }
    }

    LL QueryMax(LL l, LL r) {
        LL k = log2(r - l + 1);
        return max(Max[l][k], Max[r - (1 << k) + 1][k]);
    }

    LL QueryMin(LL l, LL r) {
        LL k = log2(r - l + 1);
        return min(Min[l][k], Min[r - (1 << k) + 1][k]);
    }
};

void solve() {
    string s;
    cin >> s;
    s = "0" + s;
    LL len = s.size();
    n = len + 5;
    a[0] = 0;
    vector<LL> st[len];
    for (LL i = 1; i < len; i++) {
        if (s[i] == '(') {
            a[i] = a[i - 1] + 1;
        } else {
            a[i] = a[i - 1] - 1;
        }
        st[a[i]].push_back(i);
    }
    ST st1;
    st1.init();
    st1.work();
    LL cnt = 0;
    for (LL i = 1; i < len; i++) {
        if (st[i].size() <= 1)
            continue;
        LL len = st[i].size();
        LL r = 0;
        for (LL l = 0; l < len; l++) {
            if (r == len) {
                cnt += (r - l - 1);
                continue;
            }
            LL left = st[i][l];
            LL right = st[i][r];
            while (r < len && st1.QueryMax(left, right) <= i * 2) {
                r++;
                if (r == len) {
                    break;
                }
                right = st[i][r];
            }
            cnt += (r - l - 1);
        }
    }
    cout << cnt << endl;
}

int main() {
    LL t;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}