比赛速览
● 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-枚举与算法基础》 课程中的"枚举法"章节，涵盖基础的条件分支处理。
参考代码
cpp
#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-枚举与算法基础》 课程中的"桶与标记"章节，涉及字符统计技术。
参考代码
cpp
#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-贪心法与优化》 课程中的"贪心法"章节，涉及效率优化策略。
参考代码
cpp
#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-贪心法与优化》 课程中的"前缀和与子段和模型"章节。
参考代码
cpp
#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-图论基础"内容，涉及函数极值求解。
参考代码
cpp
#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-入门级动态规划》 后续高级课程内容，涉及高级数据结构的使用。
参考代码
cpp
#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"章节，涉及高级优化技巧。
参考代码
cpp
#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;
}