Codeforces Round 966 (Div. 3) A~F

关注

原创最新推荐文章于 2026-11-08 21:05:35 发布 971 阅读 AI 写同款· GEO 优化 ›

STM32 无线充电接收端硬件设计：从 LC 谐振到 PWM 控制的 5 大关键电路解析本文深入解析了基于STM32的无线充电接收端硬件设计，重点探讨了LC谐振倍压整流、INA282电流采样、IR2104S半桥驱动、超级电容保护及STM32最小系统等5大关键电路。针对超级电容的恒功率充电需求，详细介绍了PID控制算法优化及PCB设计实战要点，帮助工程师提升无线充电系统的效率和可靠性。阅读详情

A.Primary Task（模拟）

题意：

德米特里在黑板上写下了 $t$ 个整数，这很好。他肯定自己丢失了其中一个重要的整数 $n$ ，这就不好了。

整数 $n$ 的形式是 $10$ ^ $x$ ( $x≥2x\ge 2$ )，其中符号"^"表示指数化。出了点差错，德米特里在写重要整数时漏掉了符号"^"。例如，他应该写 $105$ 而不是 $10^5$ ，应该写 $1019$ 而不是 $10^{19}$ 。

德米特里想知道黑板上的整数哪些可能是重要整数，哪些不可能。

分析：

判断一下字符串前两位是不是10 ，除去前两位后后面的部分是不是一个大于等于2的数即可。

代码：

#include<bits/stdc++.h>

using namespace std;

void solve() {
    string s;
    cin >> s;
    if (s.length() <= 2) {
        cout << "NO" << endl;
        return;
    }
    if (!(s[0] == '1' && s[1] == '0')) {
        cout << "NO" << endl;
        return;
    }
    if (s[2] == '0') {
        cout << "NO" << endl;
        return;
    } else if (s[2] == '1') {
        if (s.length() == 3) {
            cout << "NO" << endl;
            return;
        }
    }
    cout << "YES" << endl;
}

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

B.Seating in a Bus（模拟）

题意：

在伯兰，一辆公共汽车由一排从 $1$ 到 $n$ 的 $n$ 个座位组成。乘客上车时请务必遵守这些规则：

如果车上没有空座位，乘客可以坐在任何空座位上；
否则，乘客应坐在至少有一个邻座空闲的座位上。换句话说，只有当 $i - 1$ 或 $i + 1$ 中至少有一个座位有人时，乘客才能坐在索引为 $i$ （ $1≤i≤n1\le i\le n$ ）的座位上。

今天有 $n$ 位乘客上车。数组 $a$ 按时间顺序记录了他们的座位号。也就是说， $a_1$ 包含了第一位乘客的座位号， $a_2$ -第二位乘客的座位号，以此类推。

你知道数组 $a$ 的内容。确定是否所有乘客都遵循了建议。

例如，如果 $n = 5$ 和 $a$ =[ $5, 4, 2, 1, 3$ ]，那么建议就没有被遵守，因为第 $3$ 个乘客坐在了座位号为 $2$ 的座位上，而相邻的座位号为 $1$ 和 $3$ 的座位是空闲的。

分析：

按题意模拟，每次判断相邻位置是否有乘客，如果都没有，那么返回false, 否则置 $a [x] = 1$ , 继续判断下一个。

代码：

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

void solve() {
    int n;
    cin >> n;
    vector<int> a(n + 2, 0);
    bool tag = true;
    for (int i = 1; i <= n; i++) {
        int x;
        cin >> x;
        if (i == 1) {
            a[x] = 1;
            continue;
        } else {
            if (a[x - 1] == 1 || a[x + 1] == 1) {
                a[x] = 1;
                continue;
            } else {
                tag = false;
            }
        }
    }
    if (tag)
        cout << "YES" << endl;
    else
        cout << "NO" << endl;
}

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

C.Numeric String Template（遍历）

题意：

克里斯蒂娜有一个由 $n$ 个整数组成的数组 $a$ ，称为模板。她还有 $m$ 个字符串，每个字符串都只由小写拉丁字母组成。这些字符串的编号从 $1$ 到 $m$ 。她想检查哪些字符串与模板匹配。

如果同时满足以下所有条件，则认为字符串 $s$ 与模板匹配：

字符串 $s$ 的长度等于数组 $a$ 中的元素个数。
来自 $a$ 的相同数字对应于来自 $s$ 的相同符号。因此，如果是 $a_i=a_j$ ，那么 $s_i=s_j$ （ $1≤i,j≤n1\le i,j\le n$ ）。
来自 $s$ 的相同符号对应于来自 $a$ 的相同数字。因此，如果是 $s_i=s_j$ ，那么 $a_i=a_j$ （ $1≤i,j≤n1\le i,j\le n$ ）。

换句话说，字符串中的字符与数组中的元素必须一一对应。

例如，如果 $a$ =[ $3, 5, 2, 1, 3$ ]，那么字符串"abfda"与模板匹配，而字符串"afbfa"则不匹配，因为字符"f"同时对应数字 $1$ 和 $5$ 。

分析：

按顺序遍历字符串，用两个map给字母和数字建立起一一映射关系，然后进行判断即可。

代码：

#include<bits/stdc++.h>

typedef long long LL;
using namespace std;
const LL N = 10000005;
LL a[N];

void solve() {
    LL n;
    cin >> n;
    for (LL i = 0; i < n; i++) {
        cin >> a[i];
    }
    LL m;
    cin >> m;
    while (m--) {
        map<LL, char> q1;
        map<char, LL> q2;
        map<LL, bool> vis1;
        map<char, bool> vis2;
        string text;
        cin >> text;
        if (text.length() != n) {
            cout << "NO" << endl;
            continue;
        }
        bool ok = 1;
        for (LL i = 0; i < n; i++) {
            if (vis1[a[i]]) {
                if (text[i] != q1[a[i]]) {
                    cout << "NO" << endl;
                    ok = 0;
                    break;
                }
            }
            if (vis2[text[i]]) {
                if (a[i] != q2[text[i]]) {
                    cout << "NO" << endl;
                    ok = 0;
                    break;
                }
            }
            vis1[a[i]] = 1;
            vis2[text[i]] = 1;
            q1[a[i]] = text[i];
            q2[text[i]] = a[i];
        }
        if (ok) {
            cout << "YES" << endl;
        }
    }
}

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

D.Right Left Wrong（双指针）

题意：

弗拉德发现了一个由 $n$ 个单元格组成的长条，从左到右的编号为 $1$ 到 $n$ 。在第 $i$ 个单元格中，有一个正整数 $a_i$ 和一个字母 $s_i$ ，其中所有的 $s_i$ 不是"L"就是"R"。

弗拉德邀请您尝试进行任意数量（可能为零）的运算，以获得尽可能多的分数。

在一次操作中，您可以选择两个索引 $l$ 和 $r$ （ $1≤l<r≤n1\le l\lt r\le n$ ）。使得 $s_l$ ='L’和 $s_r$ =‘R’，然后执行以下操作：

为当前积分加上 $al+al+1+⋯+ar−1+ara_l+a_{l+1}+\dots+a_{r-1}+a_r$ 分；
将所有 $l≤i≤rl\le i\le r$ 的 $s_i$ 替换为’.'，这意味着您不能再选择这些索引。

例如，请考虑以下长条：

$3$	$5$	$1$	$4$	$3$	$2$
l	r	l	l	r	l

你可以先选择 $l = 1$ 、 $r = 2$ ，然后在分数上加上 $3 + 5 = 8$ 。

$3$	$5$	$1$	$4$	$3$	$2$
.	.	L	L	L	R

然后选择 $l = 3$ 、 $r = 6$ ，再加上 $1 + 4 + 3 + 2 = 10$ 。

$3$	$5$	$1$	$4$	$3$	$2$
.	.	.	.	.	.

因此，不可能再进行其他操作，最终得分是 $18$ 。

最大得分是多少？

分析：

首先，由于 $a [i] >= 1$ ,所以我们总是希望尽可能多的取数。

我们希望每一个数字被取的次数尽可能多，那么最优的方案就是找到最左边的 $L$ 和最右边的 $R$ ，之后，再找到剩余的项中，最左边的 $L$ 和最右边的 $R$ ，以此类推，使用双指针往里缩，前缀和优化即可。

代码：

#include<bits/stdc++.h>

typedef long long LL;
using namespace std;
const LL N = 1e6 + 7;
LL a[N];

void solve() {
    LL n;
    cin >> n;
    for (LL i = 1; i <= n; i++)
        cin >> a[i];
    for (LL i = 1; i <= n; i++)
        a[i] += a[i - 1];
    string s;
    cin >> s;
    s = ' ' + s;
    LL l = 1, r = n;
    LL ans = 0;
    while (true) {
        while (s[l] != 'L' && l <= n) l++;
        while (s[r] != 'R' && r >= 1) r--;

        if (l <= r)
            ans += (a[r] - a[l - 1]);
        else
            break;
        l++, r--;
    }
    cout << ans << endl;
}

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

E.Photoshoot for Gorillas（贪心）

题意：

你非常喜欢大猩猩，所以决定为它们组织一次摄影活动。大猩猩生活在丛林中。丛林是由 $n$ 行和 $m$ 列组成的网格。 $w$ 只大猩猩同意参加拍摄，索引为 $i$ ( $1≤i≤w1\le i\le w$ )的大猩猩的高度为 $a_i$ 。您希望将所有大猩猩放入网格单元格中，使每个单元格中的大猩猩数量不超过一只。

这个排列的奇观等于边长为 $k$ 的所有子方格的奇观之和。

一个子方格的奇观等于该子方格中大猩猩的高度之和。

从所有合适的排列中，选择一个最大的排列。

分析：

本题考虑贪心，观察样例解释可以发现，中心的格子会被多次记录，所以我们只需要把大值从中心向外填充即可，因为用二维平面填充比较困难，所以我们就可以转化为记录每个格子被重复记录的个数，用优先队列将其储存，每次取队头与最高的猩猩乘积得值最后相加即可。

代码：

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

void solve() {
    int n, m, k, w;
    cin >> n >> m >> k >> w;
    vector<int> a(w);
    for (int i = 0; i < w; i++) {
        cin >> a[i];
    }
    sort(a.rbegin(), a.rend());
    vector<vector<int>> grid(n, vector<int>(m, 0));
    for (int i = 0; i <= n - k; i++) {
        for (int j = 0; j <= m - k; j++) {
            for (int x = i; x < i + k; x++) {
                for (int y = j; y < j + k; y++) {
                    grid[x][y]++;
                }
            }
        }
    }
    priority_queue<int> pq;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (grid[i][j] > 0) {
                pq.push(grid[i][j]);
            }
        }
    }
    LL res = 0;
    for (int i = 0; i < w && !pq.empty(); i++) {
        int top = pq.top();
        pq.pop();
        res += static_cast<LL>(top) * a[i];
    }
    cout << res << endl;
}

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

F.Color Rows and Columns（动态规划）

题意：

你们有 $n$ 个矩形，其中 $i$ 个矩形的宽度为 $a_i$ ，高度为 $b_i$ 。

您可以无限次地执行以下操作：选择一个矩形和其中的一个单元格，然后为其着色。

每次为任意一行或任意一列完全着色，你都可以获得 $1$ 分。你的任务是用尽可能少的操作获得至少 $k$ 分。

假设有一个长方形，宽为 $6$ ，高为 $3$ 。您可以通过对任意 $4$ 列中的所有单元格着色，从而执行 $12$ 次操作，得到 $4$ 分。

分析：

本题考虑动态规划，令 $d p [i]$ 代表获取 $i$ 分所需要的最少次数。

对于每一个矩阵, 获取得到分数与相应最少操作次数存放在 $m e$ 数组中。先枚举 $j$ , 再枚举这个矩阵的得分 $p$ ，然后更新。

可得动态转移方程: $d p [j + p] = min (d p [j + p], d p [j] + m e [p])$

代码：

#include<bits/stdc++.h>

using namespace std;
const int INF = 0x3f3f3f3f;

void solve() {
    int n, k;
    cin >> n >> k;
    vector<int> dp(k + 1, INF);
    dp[0] = 0;
    for (int i = 0; i < n; i++) {
        int a, b;
        cin >> a >> b;
        vector<int> me(k + 1, INF);
        me[0] = 0;
        int cnt = 0;
        int cost = 0;
        while (cnt < k && (a > 0 || b > 0)) {
            if (a < b)
                swap(a, b);
            cnt += 1;
            cost += b;
            a -= 1;
            me[cnt] = cost;
        }
        for (int j = k - 1; j >= 0; j--) {
            for (int p = 1; p <= k - j; p++) {
                dp[j + p] = min(dp[j + p], dp[j] + me[p]);
            }
        }
    }
    cout << (dp[k] == INF ? -1 : dp[k]) << endl;
}

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