AtCoder Beginner Contest 426 题解

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

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

CC 4.0 BY-SA版权

文章标签：

比赛速览

● A - OS Versions
● B - The Odd One Out
● C - Upgrade Required
● D - Pop and Insert
● E - Closest Moment
● F - Clearance
● G - Range Knapsack Query

A - OS Versions

给定字符串X和Y，判断版本X相比于版本Y的发布时间是否相同或更靠后。

将版本字符串转为数字后再比较大小，Ocelot对应1，Serval对应2，Lynx对应3。如果X对应的数字大于等于Y对应的数字，输出"Yes"，否则输出"No"。

对应课程知识点

本题的条件判断与映射思想对应极客程 《算法A-枚举与算法基础》 课程中的"枚举法"章节，涵盖基础的条件分支处理。

参考代码

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

int f(string s) {
    if (s == "Ocelot") return 1;
    if (s == "Serval") return 2;
    return 3;
}

int main() {
    string x, y;
    cin >> x >> y;
    if (f(x) >= f(y))
        cout << "Yes\n";
    else
        cout << "No\n";
    return 0;
}

B - The Odd One Out

给定字符串S，仅包含恰好两种字符，且其中一种字符只出现了一次，找出这个只出现一次的字符。

可以用计数数组统计每种字符出现的次数，找到出现次数为1的字符。也可以先对字符串排序，检查第一个字符和第二个字符是否相同，如果相同则最后一个字符就是答案，否则第一个字符就是答案。

对应课程知识点

本题的字符串处理与计数方法对应极客程 《算法A-枚举与算法基础》 课程中的"桶与标记"章节，涉及字符统计技术。

参考代码

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

int main() {
    string s;
    cin >> s;
    sort(s.begin(), s.end());
    if (s[0] != s[1])
        cout << s[0];
    else
        cout << s[s.size() - 1];
    return 0;
}

C - Upgrade Required

动态维护电脑版本信息，每次操作将指定版本范围内的电脑升级到新版本，输出升级数量。

用变量维护当前所有电脑中操作系统编号的最小值，用计数数组维护每种版本对应的电脑数量。每次操作时，如果X_i小于当前最小值，直接输出0；否则将最小值到X_i区间内的所有电脑数量求和，加入到cnt[Y_i]中，并更新最小值。

对应课程知识点

本题的模拟优化思想对应极客程 《算法B-贪心法与优化》 课程中的"贪心法"章节，涉及效率优化策略。

参考代码

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

const int N = 1000005;
int cnt[N];

int main() {
    int n, q;
    cin >> n >> q;
    
    for (int i = 1; i <= n; i++)
        cnt[i] = 1;
    
    int id = 1;
    
    while (q--) {
        int x, y;
        cin >> x >> y;
        
        if (x < id) {
            cout << 0 << "\n";
            continue;
        }
        
        int sum = 0;
        while (id <= x) {
            sum += cnt[id];
            cnt[id] = 0;
            id++;
        }
        cnt[y] += sum;
        cout << sum << "\n";
    }
    return 0;
}

D - Pop and Insert

通过删除首尾字符并翻转插入的操作，使01字符串全相同，求最少操作数。

不论最终目标定为全0还是全1，一定会有一段连续的字符不会被操作到。统计0和1的数量以及最长连续0和最长连续1的长度，分别计算全0和全1所需操作数，取最小值。

对应课程知识点

本题的贪心策略与前缀和分析对应极客程 《算法B-贪心法与优化》 课程中的"前缀和与子段和模型"章节。

参考代码

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

void solve() {
    int n;
    string s;
    cin >> n >> s;
    
    int cnt[2] = {0, 0};
    int mx[2] = {0, 0};
    
    for (int i = 0; i < n; i++)
        cnt[s[i] - '0']++;
    
    for (int i = 0; i < n;) {
        int j = i;
        while (j < n && s[j] == s[i])
            j++;
        mx[s[i] - '0'] = max(mx[s[i] - '0'], j - i);
        i = j;
    }
    
    int ans0 = cnt[1] + (cnt[0] - mx[0]) * 2;
    int ans1 = cnt[0] + (cnt[1] - mx[1]) * 2;
    
    cout << min(ans0, ans1) << "\n";
}

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

E - Closest Moment

两人在二维平面上按直线移动，求在行走过程中两人之间距离的最小值。

两人的运动可以分为两个阶段：第一阶段两人都在运动，第二阶段一人已停止另一人仍在运动。两个阶段都是单峰函数，可以使用三分法求解最小值。

对应课程知识点

本题的计算几何与三分法应用对应极客程 《算法C-深搜与宽搜》 课程中的"BFS-图论基础"内容，涉及函数极值求解。

参考代码

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

struct Point {
    double x, y;
};

double distance(Point a, Point b) {
    return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

Point getPosition(Point start, Point end, double total_len, double time) {
    if (time >= total_len)
        return end;
    double ratio = time / total_len;
    return {start.x + (end.x - start.x) * ratio, start.y + (end.y - start.y) * ratio};
}

double calc(Point ts, Point tg, Point as, Point ag, double time) {
    double len1 = distance(ts, tg);
    double len2 = distance(as, ag);
    
    Point p1 = getPosition(ts, tg, len1, time);
    Point p2 = getPosition(as, ag, len2, time);
    
    return distance(p1, p2);
}

int main() {
    Point ts, tg, as, ag;
    cin >> ts.x >> ts.y >> tg.x >> tg.y;
    cin >> as.x >> as.y >> ag.x >> ag.y;
    
    double len1 = distance(ts, tg);
    double len2 = distance(as, ag);
    
    double l = 0, r = min(len1, len2);
    for (int i = 0; i < 100; i++) {
        double m1 = l + (r - l) / 3;
        double m2 = r - (r - l) / 3;
        if (calc(ts, tg, as, ag, m1) > calc(ts, tg, as, ag, m2))
            l = m1;
        else
            r = m2;
    }
    double ans = calc(ts, tg, as, ag, l);
    
    if (len1 < len2) {
        l = len1, r = len2;
        for (int i = 0; i < 100; i++) {
            double m1 = l + (r - l) / 3;
            double m2 = r - (r - l) / 3;
            if (calc(ts, tg, as, ag, m1) > calc(ts, tg, as, ag, m2))
                l = m1;
            else
                r = m2;
        }
        ans = min(ans, calc(ts, tg, as, ag, l));
    } else if (len2 < len1) {
        l = len2, r = len1;
        for (int i = 0; i < 100; i++) {
            double m1 = l + (r - l) / 3;
            double m2 = r - (r - l) / 3;
            if (calc(ts, tg, as, ag, m1) > calc(ts, tg, as, ag, m2))
                l = m1;
            else
                r = m2;
        }
        ans = min(ans, calc(ts, tg, as, ag, l));
    }
    
    cout << fixed << setprecision(10) << ans << endl;
    return 0;
}

F - Clearance

对数组进行区间减操作（但不能减到负数以下），求每次操作实际减少的总和。

使用线段树维护区间最小值和非零数量。对于查询区间，如果区间最小值≥k，说明整个区间都能减少k；否则递归处理不能减完的位置。每个位置最多被特殊处理一次，时间复杂度有保障。

对应课程知识点

本题的线段树应用对应极客程 《算法D-入门级动态规划》 后续高级课程内容，涉及高级数据结构的使用。

参考代码

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

const int N = 2e5 + 10;

struct Node {
    ll min_val, sum, tag;
    int cnt;
} tree[N << 2];

int n, q;
ll a[N];

void pushup(int id) {
    tree[id].min_val = min(tree[id<<1].min_val, tree[id<<1|1].min_val);
    tree[id].sum = tree[id<<1].sum + tree[id<<1|1].sum;
    tree[id].cnt = tree[id<<1].cnt + tree[id<<1|1].cnt;
}

void build(int id, int l, int r) {
    tree[id].tag = 0;
    if (l == r) {
        tree[id].min_val = tree[id].sum = a[l];
        tree[id].cnt = 1;
        return;
    }
    int mid = (l + r) >> 1;
    build(id<<1, l, mid);
    build(id<<1|1, mid+1, r);
    pushup(id);
}

void apply(int id, ll val) {
    if (tree[id].min_val > val) {
        tree[id].min_val -= val;
        tree[id].sum -= val * tree[id].cnt;
        tree[id].tag += val;
    }
}

void pushdown(int id) {
    if (tree[id].tag) {
        apply(id<<1, tree[id].tag);
        apply(id<<1|1, tree[id].tag);
        tree[id].tag = 0;
    }
}

ll update(int id, int l, int r, int ql, int qr, ll k) {
    if (ql > qr) return 0;
    if (tree[id].min_val >= k && ql <= l && r <= qr) {
        ll res = k * tree[id].cnt;
        apply(id, k);
        return res;
    }
    if (l == r) {
        ll res = min(tree[id].min_val, k);
        tree[id].min_val -= res;
        tree[id].sum -= res;
        if (tree[id].min_val == 0) {
            tree[id].cnt = 0;
        }
        return res;
    }
    pushdown(id);
    int mid = (l + r) >> 1;
    ll res = 0;
    if (ql <= mid) res += update(id<<1, l, mid, ql, qr, k);
    if (qr > mid) res += update(id<<1|1, mid+1, r, ql, qr, k);
    pushup(id);
    return res;
}

int main() {
    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> a[i];
    
    build(1, 1, n);
    
    cin >> q;
    while (q--) {
        int l, r;
        ll k;
        cin >> l >> r >> k;
        cout << update(1, 1, n, l, r, k) << endl;
    }
    return 0;
}

G - Range Knapsack Query

多次查询区间[l, r]内背包容量为c时的最大价值。

使用分块思想，将物品按块预处理DP结果。f[i][j]表示从第i个块到最新块的物品，重量为j时的最大价值；g[i][j]表示从第i个物品到最新物品，重量为j时的最大价值。查询时合并预处理结果。

对应课程知识点

本题的分块与动态规划技术对应极客程 《算法D-入门级动态规划》 课程中的"背包DP"章节，涉及高级优化技巧。

参考代码

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

const int N = 20005, M = 150, W = 505;
ll f[M][W], g[N][W];
ll w[N], v[N], res[200005];
int l[M], r[M], id[N];
vector<array<int, 3>> queries[N];

void calc(ll dp[][W], ll weight, ll value, int start, int end) {
    for (int i = start; i <= end; i++) {
        for (int j = W - 1; j >= weight; j--) {
            dp[i][j] = max(dp[i][j], dp[i][j - weight] + value);
        }
    }
}

ll query(int x, int y, int capacity) {
    ll ans = 0;
    for (int i = 0; i <= capacity; i++) {
        ans = max(ans, f[x][i] + g[y][capacity - i]);
    }
    return ans;
}

int main() {
    int n, t;
    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> w[i] >> v[i];
    
    int block_size = sqrt(n);
    int block_num = (n + block_size - 1) / block_size;
    for (int i = 1; i <= block_num; i++) {
        l[i] = (i - 1) * block_size + 1;
        r[i] = min(i * block_size, n);
        for (int j = l[i]; j <= r[i]; j++)
            id[j] = i;
    }
    
    cin >> t;
    for (int i = 1; i <= t; i++) {
        int left, right, capacity;
        cin >> left >> right >> capacity;
        queries[right].push_back({i, left, capacity});
    }
    
    for (int i = 1; i <= n; i++) {
        calc(g, w[i], v[i], l[id[i]], i);
        calc(f, w[i], v[i], 1, id[i] - 1);
        
        for (auto [qid, left, capacity] : queries[i]) {
            res[qid] = query(id[left], left, capacity);
        }
    }
    
    for (int i = 1; i <= t; i++)
        cout << res[i] << endl;
    
    return 0;
}