CSP-S 2024 第二轮认证 解题报告
CSP-S 2024 第二轮认证 解题报告
比赛：CSP-S 2024 第二轮认证（提高级）
语言：C++14 ｜ 代码在本地官方测试数据上验证（见各题得分档说明）
一、比赛总体概述
1.1 题目总览
| 题号 | 题目名称 | 洛谷编号 | 难度 | 题型 | 核心考点 |
|---|---|---|---|---|---|
| T1 | 决斗 | P11231 | 普及− | 贪心 | 最大匹配、排序双指针 |
| T2 | 超速检测 | P11232 | 普及+/提高 | 模拟 + 贪心 | 匀加速公式、区间覆盖 |
| T3 | 染色 | P11233 | 提高+/省选− | DP | 延续增益、陈色维护 |
| T4 | 擂台游戏 | P11234 | NOI/NOI+/CTSC | 数据结构 | 淘汰赛、冠军可能性 |
1.2 整体难度感受
- T1（决斗） 是送分题：最大消灭数 = 二分图最大匹配，排序后双指针贪心 O(n log n)。
- T2（超速检测） 是模拟 + 贪心：匀加速运动求超速区间（平方比较避免浮点），问题 2 是"最少点覆盖区间"的经典贪心。
- T3（染色） 是 DP：核心观察是"延续增益固定 + 陈色最后值维护"，配合整体偏移量惰性累加，O(n)。
- T4（擂台游戏） 是 NOI 级压轴：每轮胜者由擂主能力决定，求"可能冠军编号和"需要维护锦标赛树上的冠军可能性，难度陡增。
1.3 考点分布
- 贪心 / 匹配：T1
- 物理模拟 / 区间覆盖：T2
- DP / 状态维护：T3
- 树上淘汰赛 / 冠军判定：T4
1.4 策略建议
本场建议：T1 满分 → T2 满分 → T3 想清楚 DP 满分 → T4 用暴力拿部分分。T4 是全场区分度最高的题，NOI 级难度，考试时优先保证前三题。
二、T1：决斗（P11231）
1. 题目大意
n 张卡牌（攻击力 = 防御力 = r_i），每只怪兽至多攻击一次，攻击力 > 对方防御力则对方退出。求安排攻击顺序后最少剩余数量。
2. 满分做法（测试点 1~20，n ≤ 1e5）
- 关键观察/性质：最大消灭数 = 二分图最大匹配——怪兽 i 能消灭 j 当且仅当 r[i] > r[j]，每个怪兽至多当一次攻击者、至多被消灭一次。
- 算法推导：排序后贪心求最大匹配：升序排列，双指针 i（攻击者）、j（受害者）都从最小开始，
r[i] > r[j]时 i 消灭 j（i++、j++），否则 i++ 找更大的攻击力。受害者指针也必须从最小开始（最小者也能被更大的消灭——本项目实测 j 从 2 开始会差 1 的坑）。经 3000 组随机对拍与匈牙利最大匹配一致。 - 代码：
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN = 100005;
// 满分做法：n <= 1e5（测试点 1~20）
// 每只怪兽至多攻击一次，攻击力 > 对方防御力则对方退出。
// 最大消灭数 = 最大匹配（i 攻击 j 当且仅当 r[i] > r[j]，每个点至多
// 参与一次匹配）。排序后贪心：
// 把 r 升序排序。双指针：i 是"攻击者"（当前最小可用攻击力），
// j 是"受害者"（当前最小可被消灭者）。
// - 若 r[i] > r[j]：i 能消灭 j，消灭数 +1，i++、j++；
// - 否则：i 的攻击力不够消灭 j（j 太小？不——r[i] <= r[j] 说明
// i 打不过 j，i 继续向后找更大的攻击力）。
// 注意方向：攻击力大的消灭小的。i、j 都只向右推进，贪心最优
// （用尽量小的攻击力去消灭尽量小的受害者，为更大的攻击力留余地）。
// 答案 = n - 消灭数。复杂度 O(n log n)（排序）。
int n;
int r[MAXN];
int main()
{
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; i++) cin >> r[i];
sort(r + 1, r + n + 1); // 升序
int i = 1, j = 1, kill = 0;
while (i <= n && j <= n)
{
if (r[i] > r[j])
{
// 攻击者 i 消灭受害者 j
kill++;
i++;
j++;
}
else
{
// i 的攻击力不够（r[i] <= r[j]），i 向后找更大的攻击力
i++;
}
}
cout << n - kill << "\n";
return 0;
}
- 复杂度：\(O(n \log n)\)（排序），空间 \(O(n)\)。
3. 总结
- 核心考点：最大匹配 + 排序双指针贪心。
- 实现注意：受害者指针从最小开始；攻击力严格大于才消灭。
- 得分档验证：满分档通过全部 20 个测试点（n ≤ 1e5，实测毫秒级），3000 组随机对拍与匈牙利一致。
三、T2：超速检测（P11232）
n 辆车匀加速运动（初速 v_i、加速度 a_i、驶入位置 d_i），m 个测速仪（位置 p_j）。车在位置 s 超速 ⟺ 速度 > V（速度平方 v^2 = v_i² + 2a_i(s-d_i)）。问题 1：全部测速仪开启时多少车超速；问题 2：最多关多少测速仪仍能抓住所有超速车。
2. 档位一：20 分做法（测试点 1~2，n, m ≤ 20）
- 思路：逐车逐测速仪模拟：对每辆车，枚举每个测速仪位置计算速度平方判断是否超速，得到"覆盖它的测速仪下标连续区间"。问题 1 统计区间非空的车数；问题 2 = m - 最少点覆盖区间数（贪心）。本档是正确性基准。
- 实现注意：速度平方用
long long，严格大于 V² 判断；V不能声明局部变量遮蔽全局（本项目实测踩坑）。 - 代码：
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN = 25;
// 20 分做法：n, m <= 20（测试点 1~2）
// 匀加速运动：位置 s 处速度 v 满足 v^2 = v0^2 + 2*a*(s - d)。
// 车辆在位置区间 [d, L] 内行驶（a<0 时速度降 0 提前驶离）。
// 超速条件：速度 > V（严格大于），即 v0^2 + 2*a*(s-d) > V^2。
// 对每辆车求超速位置区间 [x1, x2)：
// - a > 0：速度递增，从某位置起超速直到驶离 → [max(d, x0), L]
// - a = 0：全程匀速 v0，v0 > V 则全程 [d, L] 超速
// - a < 0：速度递减，超速区间 [d, x0)（x0 是速度降到 V 的位置），
// 且要在驶离（速度降 0 或到 L）之前
// 落在超速区间的测速仪会判定该车超速。
//
// 问题 1：统计有多少辆车的超速区间内含至少一个测速仪。
// 问题 2：最少保留多少测速仪，使每个超速车区间都被覆盖。
// 把每个超速车转成"覆盖它的测速仪下标区间 [l, r]"（测速仪位置排序，
// 区间是连续的），问题 2 = 用最少的点覆盖所有区间（贪心：按右端点
// 排序，每次在未覆盖区间的最右端点放测速仪）。
// 本档 n,m<=20，直接模拟 + 贪心覆盖。
int T;
ll d[MAXN], v[MAXN], a[MAXN];
ll p[MAXN];
ll V; // 道路限速（全局，getRange 使用）
// 求车辆 i 超速的测速仪下标区间 [L, R]（覆盖它的连续测速仪段）
// 返回 false 表示该车不超速（超速区间无测速仪）
bool getRange(int i, int m, int &L, int &R)
{
// 超速位置区间 [x1, x2)：速度 > V 的位置（V 是全局限速）
// 直接枚举每个测速仪位置判断该车是否在那里超速，取连续段
L = -1; R = -1;
for (int j = 1; j <= m; j++)
{
ll s = p[j];
if (s < d[i]) continue; // 车还没驶入
// 车在位置 s 的速度平方
ll v2 = v[i] * v[i] + 2 * a[i] * (s - d[i]);
if (v2 < 0) break; // a<0 且速度已降 0，车已驶离
bool over = (v2 > V * V); // 严格大于 V
if (over)
{
if (L == -1) L = j;
R = j;
}
else if (L != -1) break; // 已离开超速段
}
return L != -1;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> T;
while (T--)
{
int n, m;
ll L;
cin >> n >> m >> L >> V;
for (int i = 1; i <= n; i++) cin >> d[i] >> v[i] >> a[i];
for (int j = 1; j <= m; j++) cin >> p[j];
// 问题 1：统计超速车数，并收集每辆超速车的测速仪区间
vector<pair<int, int> > segs; // 覆盖区间 [l, r]（测速仪下标）
int cnt = 0;
for (int i = 1; i <= n; i++)
{
int l, r;
if (getRange(i, m, l, r))
{
cnt++;
segs.push_back(make_pair(l, r));
}
}
// 问题 2：最少点数覆盖所有区间（标准贪心）
// 区间按左端点排序。遍历时维护"当前已放点的覆盖右界"。
// 若当前区间左端点 <= 已放点位置则已被覆盖；
// 否则必须新增一个点，放在"当前这批未覆盖区间中右端点最小"的位置
//（该位置能覆盖尽量多的后续区间）。
sort(segs.begin(), segs.end());
int keep = 0;
int idx = 0;
int sz = (int)segs.size();
while (idx < sz)
{
keep++; // 新增一个点
int cand = segs[idx].second; // 候选位置：当前区间右端点
// 一边把候选点往左移（取右端点最小值以覆盖更多区间），
// 一边跳过所有左端点 <= cand 的区间（已被该点覆盖）。
// 区间按左端点排序，故跳过的是一段连续前缀；cand 只减不增，
// 无需额外的探测循环（探测与覆盖同步完成）。
while (idx < sz && segs[idx].first <= cand)
{
cand = min(cand, segs[idx].second);
idx++;
}
}
cout << cnt << " " << m - keep << "\n";
}
return 0;
}
- 复杂度：\(O(nm)\)，空间 \(O(n)\)。
3. 档位二：20 分做法（特殊性质 A，测试点 3~4，a_i = 0）
- 思路：性质 A 保证所有车匀速（a = 0）。v_i > V 的车全程（位置 d_i 到 L）超速，v_i <= V 的车永不超速。超速车区间 = [第一个 >= d_i 的测速仪, m]（右端都是 m），问题 2 只需保留最后一个测速仪（keep = 有无超速车 ? 1 : 0）。
- 代码：
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN = 100005;
// 特殊性质 A 档（测试点 3~4，a_i = 0）：20 分
// 所有车匀速运动（a = 0），速度恒为 v_i。因此：
// - v_i > V 的车全程（位置 d_i 到 L）超速；
// - v_i <= V 的车永不超速。
// 超速车的测速仪区间 = [第一个 >= d_i 的测速仪, m]（位置递增）。
// 问题 1：统计 v_i > V 且区间非空的车数。
// 问题 2：最少点覆盖区间（所有区间形如 [l, m]，右端点都是 m——
// 只需 1 个点放最后一个测速仪即可覆盖全部，keep = (有无超速车 ? 1 : 0)）。
// 复杂度 O(n + m)。
int T;
ll d[MAXN], v[MAXN], a[MAXN];
ll p[MAXN];
ll V;
int main()
{
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> T;
while (T--)
{
int n, m;
ll L;
cin >> n >> m >> L >> V;
for (int i = 1; i <= n; i++) cin >> d[i] >> v[i] >> a[i];
for (int j = 1; j <= m; j++) cin >> p[j];
int cnt = 0; // 超速车数
for (int i = 1; i <= n; i++)
{
if (v[i] > V)
{
// 全程超速，测速仪区间 = [第一个 >= d[i] 的, m]
int l = lower_bound(p + 1, p + m + 1, d[i]) - p;
if (l <= m) cnt++;
}
}
// 所有超速车区间都是 [l, m]（右端 m），只需保留最后一个测速仪
int keep = (cnt > 0) ? 1 : 0;
cout << cnt << " " << m - keep << "\n";
}
return 0;
}
- 复杂度：\(O(n \log m + m)\)。
4. 档位三：20 分做法（特殊性质 B，测试点 5~6，a_i > 0）
- 思路：性质 B 保证所有车加速（a > 0），速度递增。超速起点 x1 = d + floor((V²-v²)/(2a)) + 1，超速区间 [x1, L]，测速仪区间 [l, m]（右端 m）。问题 2 保留最后一个测速仪即可。
- 代码：
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef __int128 lll;
const int MAXN = 100005;
// 特殊性质 B 档（测试点 5~6，a_i > 0）：20 分
// 所有车加速运动（a > 0），速度从 v_i 递增。超速位置区间：
// 速度 > V ⟺ v_i^2 + 2a(s - d) > V^2 ⟺ s > d + (V^2 - v_i^2)/(2a)
// 超速区间 = [x1, L]，x1 = d + floor((V^2-v_i^2)/(2a)) + 1（且 >= d）。
// 若 v_i > V 则从 d 就超速（x1 = d）。
// 落在 [x1, L] 的测速仪（位置递增）下标是连续区间 [l, m]。
// 问题 1：统计区间非空的车数。
// 问题 2：最少点覆盖区间（右端都是 m，保留最后一个测速仪即可）。
// 复杂度 O(n log m + m)。
int T;
ll d[MAXN], v[MAXN], a[MAXN];
ll p[MAXN];
ll V;
int main()
{
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> T;
while (T--)
{
int n, m;
ll L;
cin >> n >> m >> L >> V;
for (int i = 1; i <= n; i++) cin >> d[i] >> v[i] >> a[i];
for (int j = 1; j <= m; j++) cin >> p[j];
int cnt = 0;
for (int i = 1; i <= n; i++)
{
// 超速起点 x1：v^2 + 2a(x-d) > V^2
// x > d + (V^2 - v^2)/(2a)，floor + 1
lll num = (lll)V * V - (lll)v[i] * v[i];
lll den = 2 * (lll)a[i]; // > 0
ll step;
if (num >= 0) step = (ll)(num / den);
else step = (ll)(-((-num + den - 1) / den)); // floor 负数
ll x1 = d[i] + step + 1;
if (x1 < d[i]) x1 = d[i];
// 测速仪区间 [l, m]
int l = lower_bound(p + 1, p + m + 1, x1) - p;
if (l <= m) cnt++;
}
int keep = (cnt > 0) ? 1 : 0;
cout << cnt << " " << m - keep << "\n";
}
return 0;
}
- 复杂度：\(O(n \log m + m)\)。
5. 档位四：20 分做法（特殊性质 C，测试点 7~8，a_i < 0 且不驶离）
- 思路：性质 C 保证所有车减速（a < 0），速度递减。超速区间 [d, x2)，x2 = d + ceil((V²-v²)/(2a))。测速仪区间 [l, r] 用二分求边界，问题 2 用标准区间最少点覆盖贪心。
- 代码：
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef __int128 lll;
const int MAXN = 100005;
// 特殊性质 C 档（测试点 7~8，a_i < 0 且车不在最北端驶离）：20 分
// 所有车减速运动（a < 0），速度从 v_i 递减，最终降为 0 驶离（非最北端）。
// 超速位置区间：v^2 + 2a(s-d) > V^2，且 s < 降 0 位置（速度 > 0）。
// 速度 > V ⟺ v_i^2 + 2a(s-d) > V^2 ⟺ s < d + (V^2 - v_i^2)/(2a)（2a<0）
// 超速区间 = [d, x2)，x2 = d + ceil((V^2-v_i^2)/(2a))（除数为负，商为正）。
// 若 v_i <= V 则从不超速。
// 落在 [d, x2) 的测速仪（位置递增）下标是连续区间 [l, r]。
// 问题 1：统计区间非空的车数。
// 问题 2：最少点覆盖所有区间（标准贪心：按左端点排序，新点放
// "当前未覆盖区间右端点最小"处）。
// 复杂度 O(n log m + m log m)。
int T;
ll d[MAXN], v[MAXN], a[MAXN];
ll p[MAXN];
ll V;
int main()
{
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> T;
while (T--)
{
int n, m;
ll L;
cin >> n >> m >> L >> V;
for (int i = 1; i <= n; i++) cin >> d[i] >> v[i] >> a[i];
for (int j = 1; j <= m; j++) cin >> p[j];
vector<pair<int, int> > segs;
int cnt = 0;
for (int i = 1; i <= n; i++)
{
if (v[i] <= V) continue; // 初速不超速且速度递减
// 超速终点 x2：v^2 + 2a(x-d) > V^2 ⟺ x < d + (V^2-v^2)/(2a)
// (V^2-v^2) < 0, (2a) < 0 → 商为正，ceil
lll num = (lll)V * V - (lll)v[i] * v[i]; // 负
lll den = 2 * (lll)a[i]; // 负
lll q = (-num) / (-den);
if ((-num) % (-den) != 0) q++;
ll x2 = d[i] + (ll)q;
// 测速仪区间 [l, r]：>= d[i] 且 < x2
int l = lower_bound(p + 1, p + m + 1, d[i]) - p;
int r = lower_bound(p + 1, p + m + 1, x2) - p - 1;
if (l <= r)
{
cnt++;
segs.push_back(make_pair(l, r));
}
}
// 问题 2：最少点覆盖区间（标准贪心）
sort(segs.begin(), segs.end());
int keep = 0, idx = 0, sz = (int)segs.size();
while (idx < sz)
{
keep++;
int cand = segs[idx].second;
while (idx < sz && segs[idx].first <= cand)
{
cand = min(cand, segs[idx].second);
idx++;
}
}
cout << cnt << " " << m - keep << "\n";
}
return 0;
}
- 复杂度：\(O(n \log m + m \log m)\)。
6. 满分做法（测试点 1~10，n, m ≤ 1e5）
- 关键观察/性质：
- 超速区间公式：速度 v(s) > V ⟺ v²+2a(s-d) > V²。按 a 正/零/负三类求超速位置区间 [lo, hi)：
- a > 0：速度递增，从某个位置起超速直到驶离 → [x1, L]；
- a = 0：匀速，v0 > V 则全程超速，否则不超速；
- a < 0：速度递减，超速区间 [d, x2)（x2 是速度降到 V 的位置）。
x1/x2 用整数运算求（避免浮点误差，比较用平方）。
- 区间覆盖：落在超速区间的测速仪下标是连续区间（测速仪位置递增，二分求边界）。问题 2 = 最少点覆盖所有区间（按左端点排序，新点放"当前未覆盖区间右端点最小"处）。
- 超速区间公式：速度 v(s) > V ⟺ v²+2a(s-d) > V²。按 a 正/零/负三类求超速位置区间 [lo, hi)：
- 代码：
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef __int128 lll;
const int MAXN = 100005;
// 满分做法：n, m <= 1e5（测试点 1~10）
// 匀加速运动：位置 s 处速度满足 v^2 = v0^2 + 2*a*(s - d)。
// 车在位置 s 超速 ⟺ v0^2 + 2*a*(s-d) > V^2。
//
// 每辆车的超速位置区间（速度 > V 的连续段）：
// a > 0：速度递增，从某个位置起超速直到驶离（位置 L 或无限）→ [x1, L]
// a = 0：匀速，v0 > V 则全程 [d, L] 超速，否则不超速
// a < 0：速度递减，超速区间 [d, x2)（x2 是速度降到 V 的位置），且需在
// 驶离（速度降 0 或到 L）之前；若 v0 <= V 则不超速
// 求 x1 / x2 用公式（避免浮点误差，比较用平方，边界用整数运算）：
// v0^2 + 2a(x-d) > V^2 => x > d + (V^2 - v0^2) / (2a)（a>0 时向下取整+1）
// v0^2 + 2a(x-d) <= V^2 => x >= d + (V^2 - v0^2) / (2a)（a<0 时向上取整）
// 落在超速区间的测速仪下标是连续区间 [L, R]（测速仪位置递增，二分求边界）。
//
// 问题 1：统计超速车数（超速区间含至少一个测速仪）。
// 问题 2：最少保留测速仪覆盖所有超速车区间 = 区间最少点覆盖贪心
// （按左端点排序，新点放"当前未覆盖区间右端点最小"处）。
// 复杂度 O(n log m + m log m)。
int T;
ll d[MAXN], v[MAXN], a[MAXN];
ll p[MAXN];
ll V; // 全局限速
// 求车辆 i 超速的测速仪下标区间 [L, R]（1-based，闭区间）；不超速返回 false
bool getRange(int i, int m, int &L, int &R)
{
// 车 i 超速的位置区间 [lo, hi)（位置，整数；含 lo 不含 hi）
ll lo, hi;
ll v0 = v[i], aa = a[i], dd = d[i];
// v0^2 + 2*aa*(x-dd) > V^2
// 用 __int128 防 2*aa*(x-dd) 溢出（L <= 1e6, a <= 1e3 => 2e9，ll 够，
// 但 V^2 - v0^2 可能负，统一用 lll）
lll target = (lll)V * V;
if (aa > 0)
{
// 速度递增：找最小的位置 x 使 v0^2 + 2a(x-d) > V^2
// x > d + (V^2 - v0^2)/(2a)，取整：x = d + floor((V^2-v0^2)/(2a)) + 1
lll num = target - (lll)v0 * v0; // V^2 - v0^2（可负）
lll den = 2 * (lll)aa;
// floor(num/den)（den>0）
ll step;
if (num >= 0) step = (ll)(num / den);
else step = (ll)(-((-num + den - 1) / den)); // floor 负数
lo = dd + step + 1;
if (lo < dd) lo = dd;
hi = LLONG_MAX; // 驶离前一直超速（到 L 由测速仪位置限制）
}
else if (aa == 0)
{
if (v0 <= V) return false; // 匀速不超速
lo = dd;
hi = LLONG_MAX;
}
else // aa < 0
{
if (v0 <= V) return false; // 初速就不超速，且速度递减
// 速度递减：超速区间 [d, x2)，x2 是速度降到 V 的位置
// v0^2 + 2a(x-d) > V^2 => x < d + (V^2 - v0^2)/(2a)（2a<0）
// x2 = d + ceil((V^2-v0^2)/(2a))（注意 2a<0，除数为负）
lll num = target - (lll)v0 * v0; // V^2 - v0^2（负）
lll den = 2 * (lll)aa; // 负
// ceil(num/den) 其中 num<0, den<0 => 商为正
lll q = (-num) / (-den); // 正数除法
// ceil：若 (-num) % (-den) != 0 则 +1
if ((-num) % (-den) != 0) q++;
ll x2 = dd + (ll)q;
lo = dd;
hi = x2;
}
// 在 [lo, hi) 内找测速仪的下标区间
// 第一个 >= lo 的测速仪，和最后一个 < hi 的
int lpos = lower_bound(p + 1, p + m + 1, lo) - p; // 1-based
int rpos = lower_bound(p + 1, p + m + 1, hi) - p - 1; // 最后一个 < hi
if (lpos > rpos) return false; // 区间内无测速仪
L = lpos;
R = rpos;
return true;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> T;
while (T--)
{
int n, m;
ll L;
cin >> n >> m >> L >> V;
for (int i = 1; i <= n; i++) cin >> d[i] >> v[i] >> a[i];
for (int j = 1; j <= m; j++) cin >> p[j];
// 问题 1：统计超速车数，收集区间
vector<pair<int, int> > segs;
int cnt = 0;
for (int i = 1; i <= n; i++)
{
int l, r;
if (getRange(i, m, l, r))
{
cnt++;
segs.push_back(make_pair(l, r));
}
}
// 问题 2：最少点覆盖所有区间（标准贪心）
sort(segs.begin(), segs.end());
int keep = 0;
int idx = 0;
int sz = (int)segs.size();
while (idx < sz)
{
keep++;
int cand = segs[idx].second;
// 一边把候选点往左移（取右端点最小值以覆盖更多区间），
// 一边跳过所有左端点 <= cand 的区间（已被该点覆盖）。
while (idx < sz && segs[idx].first <= cand)
{
cand = min(cand, segs[idx].second);
idx++;
}
}
cout << cnt << " " << m - keep << "\n";
}
return 0;
}
- 复杂度：\(O(n \log m + m \log m)\)，空间 \(O(n)\)。
4. 总结
- 核心考点：匀加速公式 + 区间最少点覆盖贪心。
- 实现注意：速度平方用 __int128 防溢出（a、L 较大）；严格大于 V²；测速仪区间用二分。
- 得分档验证：20 分档通过 1~2，满分档通过全部 10 个测试点，且 1000 组随机对拍与暴力一致。
四、T3：染色（P11233）
给数组 A 染红/蓝，得分 = 每个数与其"左侧最近同色数"相同则加 A[i]。求最大得分。n ≤ 2e5，T ≤ 10。
2. 档位一：20 分做法（测试点 1~4，n ≤ 15）
- 思路：枚举 2^n 种染色方案，按题意逐位置找"左侧最近同色"计算得分，取最大。本档是正确性基准。
- 代码：
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN = 20;
// 20 分做法：n <= 15（测试点 1~4）
// 枚举每个数的颜色（红/蓝，2^n 种方案），对每种方案按题意计算得分，
// 取最大值。n <= 15 时 2^15 = 32768 种，完全可行。
// 本档是正确性基准（与满分 DP 对拍验证）。
int n;
int A[MAXN];
// 计算染色方案 mask（第 i 位 0=红 1=蓝）的得分
ll calc(int mask)
{
ll score = 0;
// 对每个位置 i，找它左侧最近的同色位置 j，若 A[j] == A[i] 则加 A[i]
for (int i = 1; i <= n; i++)
{
int ci = (mask >> (i - 1)) & 1;
for (int j = i - 1; j >= 1; j--)
{
int cj = (mask >> (j - 1)) & 1;
if (ci == cj) // 最近同色
{
if (A[j] == A[i]) score += A[i];
break;
}
}
}
return score;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(nullptr);
int T;
cin >> T;
while (T--)
{
cin >> n;
for (int i = 1; i <= n; i++) cin >> A[i];
ll ans = 0;
for (int mask = 0; mask < (1 << n); mask++)
ans = max(ans, calc(mask));
cout << ans << "\n";
}
return 0;
}
- 复杂度：\(O(2^n \cdot n^2)\)，空间 \(O(n)\)。
3. 档位二：50 分做法（O(n^2)，测试点 1~10，n ≤ 2000）
- 思路：状态 = 两色最后元素值 (x, y)，稀疏存储（map）。转移：染红时新状态 (v, y) 得分 + (xv ? v : 0)，染蓝时 (x, v) 得分 + (yv ? v : 0)。状态数 O(n) 每步（不可达状态少），总 O(n²)。n ≤ 2000 时 1 秒内。
- 代码：
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN = 2005;
// O(n^2) 做法：n <= 2000（测试点 5~10）
// 状态：dp[x][y] = 处理完当前前缀后，红颜色最后元素值为 x、蓝颜色
// 最后元素值为 y 的最大得分。值域 A_i <= 2000（本档数据范围），
// 用二维数组。转移（处理新元素 v）：
// 染红：dp[v][y] = max(dp[v][y], dp[x][y] + (x == v ? v : 0))
// 染蓝：dp[x][v] = max(dp[x][v], dp[x][y] + (y == v ? v : 0))
// 其中 x 是红的最后值、y 是蓝的最后值；"左侧最近同色"就是 x（或 y）。
// 初始：dp[0][0] = 0（0 表示该色无元素）。
// 复杂度 O(n * V^2) 太高，但本档用"滚动 + 只遍历有值状态"优化：
// 每步最多 V^2 个状态，n=2000, V=2000 时 4e6*2000 太大。
// 改进：注意到每步只有"最后一色 = 上一步的值"的状态会更新，
// 用 map 稀疏存储，O(n^2) 实际可行（每步状态数 O(n)）。
// 本档实现：稀疏 DP（unordered_map 存状态），O(n^2) 状态数。
int n;
int A[MAXN];
int main()
{
ios::sync_with_stdio(false);
cin.tie(nullptr);
int T;
cin >> T;
while (T--)
{
cin >> n;
for (int i = 1; i <= n; i++) cin >> A[i];
// 稀疏状态：key = x * (V+1) + y，值 = 最大得分
// 但值域 V = max A 可能 2000，key 用 (x,y) 编码
int V = 0;
for (int i = 1; i <= n; i++) V = max(V, A[i]);
// 用 map<pair,int>, ll> 太慢；改用"最后一色值"压缩：
// 观察：两色最后值中，必有一个等于"最近一次被染的元素的颜色
// 最后值"——其实两色最后值 x, y 分别是两个值。
// 用 dp[i][j] 表示：处理完前 i 个，红最后值 = A[j]（j 是某位置）
// 或 0，蓝最后值 = 另一个。状态数 O(n^2)。
// 简化实现：用二维 map 存 (x,y)，只遍历存在的状态。
map<pair<int,int>, ll> dp;
dp[make_pair(0, 0)] = 0; // 初始两色空
for (int i = 1; i <= n; i++)
{
int v = A[i];
map<pair<int,int>, ll> ndp;
for (auto &pr : dp)
{
int x = pr.first.first, y = pr.first.second;
ll val = pr.second;
// 染红：红最后值变 v
ll addR = (x == v) ? v : 0;
pair<int,int> kR(x == 0 ? v : (x == v ? v : x), y);
// 红最后值：若 x==0（红空）则变 v；否则若 x==v 则不变（v 覆盖 x），
// 若 x != v 则红最后值 = v（新元素）——但 x 是"上一个红元素值"，
// 染 v 后红最后值 = v，且若 x==v 则得分 v。
// 修正：红最后值恒变 v（新元素成为红最后），得分看旧 x==v。
kR = make_pair(v, y);
ndp[kR] = max(ndp[kR], val + addR);
// 染蓝：蓝最后值变 v
ll addB = (y == v) ? v : 0;
pair<int,int> kB(x, v);
ndp[kB] = max(ndp[kB], val + addB);
}
dp = ndp;
}
ll ans = 0;
for (auto &pr : dp) ans = max(ans, pr.second);
cout << ans << "\n";
}
return 0;
}
- 复杂度：\(O(n^2)\)（稀疏状态），空间 \(O(n)\)。
4. 档位三：75 分做法（A_i 值域小，测试点 13~15，A_i ≤ 10）
- 思路：A_i 值域 ≤ 10 时，两色最后值状态 (x, y) 只有 V² ≤ 100 种，用二维数组 dp[x][y] 每步 O(V²) 转移，总 O(n·V²)。值域大时状态爆炸不适用（本档只面向 A_i 小的数据）。
- 代码：
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN = 200005;
// 特殊性质档：A_i 值域较小时（测试点 13~15，A_i <= 10）
// 状态 = 两色最后元素值 (x, y)，值域 V <= 10 → 状态 V^2 <= 100 个。
// 用二维数组 dp[x][y] 存最大得分，每步 O(V^2) 转移，总 O(n * V^2)。
// 转移（处理新元素 v）：
// 染红：dp[v][y] = max(dp[v][y], dp[x][y] + (x == v ? v : 0))
// 染蓝：dp[x][v] = max(dp[x][v], dp[x][y] + (y == v ? v : 0))
// 用滚动数组避免覆盖：新 dp 存 ndp。
// 本档面向 A_i 值域小的数据；值域大时 V^2 状态爆炸，不适用。
int n;
int A[MAXN];
int main()
{
ios::sync_with_stdio(false);
cin.tie(nullptr);
int T;
cin >> T;
while (T--)
{
cin >> n;
for (int i = 1; i <= n; i++) cin >> A[i];
int V = 0;
for (int i = 1; i <= n; i++) V = max(V, A[i]);
const ll NEG = -4000000000000000000LL;
// dp[x][y]：红最后值 x、蓝最后值 y（0 表示该色无元素）
vector<vector<ll> > dp(V + 1, vector<ll>(V + 1, NEG));
dp[0][0] = 0;
for (int i = 1; i <= n; i++)
{
int v = A[i];
vector<vector<ll> > ndp(V + 1, vector<ll>(V + 1, NEG));
for (int x = 0; x <= V; x++)
for (int y = 0; y <= V; y++)
{
ll val = dp[x][y];
if (val == NEG) continue;
// 染红：红最后值变 v
ll addR = (x == v) ? v : 0;
if (val + addR > ndp[v][y]) ndp[v][y] = val + addR;
// 染蓝：蓝最后值变 v
ll addB = (y == v) ? v : 0;
if (val + addB > ndp[x][v]) ndp[x][v] = val + addB;
}
dp = ndp;
}
ll ans = 0;
for (int x = 0; x <= V; x++)
for (int y = 0; y <= V; y++)
ans = max(ans, dp[x][y]);
cout << ans << "\n";
}
return 0;
}
- 复杂度：\(O(n \cdot V^2)\)（V = max A_i），空间 \(O(V^2)\)。
5. 满分做法（测试点 1~20，n ≤ 2e5）
- 关键观察/性质：
- 延续增益固定：若位置 i 与 i-1 同色且 A[i]A[i-1]，则无论之前怎么染，i 必然得分 +A[i]。记 c[i] = (A[i]A[i-1]) ? A[i] : 0。
- 切换只需"陈色"最后值：位置 i 染成另一色时，只有当该色最后元素值 == A[i] 才 +A[i]。维护 best[x] = "陈色最后值为 x 的最大得分"。
- 算法推导：
f[i] = max(f[i-1] + c[i], best[A[i]] + A[i])（延续 / 切换）；- 染完 i 后陈色最后值变为 A[i-1]：
best[A[i-1]] = max(best[A[i-1]], f[i])； - 用整体偏移量 off 惰性累加延续增益（所有 best 统一 +c[i]），O(1) 每步。
- 实现注意：
best[A[i]]必须在 off 更新（加 c[i]）之前读取。 - 代码：
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN = 200005;
const ll NEG = -4000000000000000000LL; // 极小值
// 满分做法：n <= 2e5（测试点 1~20），O(n + maxA)
// 染色 DP。核心观察：
// 1. **延续增益固定**：若位置 i 与 i-1 同色且 A[i]==A[i-1]，则无论之前
// 怎么染，i 必然得分 +A[i]。记 c[i] = (A[i]==A[i-1]) ? A[i] : 0。
// 2. **切换（异色）只需知道"陈色"最后元素的值**：位置 i 染成"非 i-1
// 颜色"（陈色）时，只有当陈色最后元素值 == A[i] 才 +A[i]。
// 因此维护 best[x] = 在当前前缀的染色方案中，使"陈色最后元素值 == x"
// 的最大得分。
//
// 转移（i 从 2 到 n）：
// f[i] = max( f[i-1] + c[i], // 延续：与 i-1 同色
// best[A[i]] + A[i] ) // 切换：染陈色，若陈色最后值==A[i]
// 染完 i 后，陈色最后值变为 A[i-1]：
// best[A[i-1]] = max(best[A[i-1]], f[i])
//
// 惰性偏移：延续会同时给所有 best[x] 增加后续的 c[k] 总和，因此 best 存
// "相对值"（减去已累加的延续和 off），读取时加回 off，O(1) 每步。
// 注意 best[A[i]] 必须在 off 更新（加 c[i]）之前读取。
int T;
int n;
int A[MAXN];
int main()
{
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> T;
while (T--)
{
cin >> n;
int maxv = 0;
for (int i = 1; i <= n; i++)
{
cin >> A[i];
maxv = max(maxv, A[i]);
}
vector<ll> best(maxv + 1, NEG); // best[x]：陈色最后值为 x 的相对最优得分
ll off = 0; // 已累加的延续增益（S[i-1]）
ll f = 0; // f[i-1]
for (int i = 2; i <= n; i++)
{
// 切换候选：染成陈色，读取 best[A[i]]（off 更新前）
ll bestNow = best[A[i]] + off; // 真实 best[A[i]]
ll newval = max(f, bestNow + A[i]); // 切换路径候选
ll c = (A[i] == A[i - 1]) ? A[i] : 0; // 延续增益
off += c; // 惰性：所有 best 统一 +c
best[A[i - 1]] = max(best[A[i - 1]], newval - off); // 记录 f[i] 等价
f = max(f + c, newval); // f[i]
}
cout << f << "\n";
}
return 0;
}
-
复杂度：\(O(n + \max A)\)，空间 \(O(\max A)\)。
-
核心考点：延续增益 + 陈色维护的 DP。
-
实现注意：best 读取时机（off 更新前）；惰性偏移量；
A_i可达 1e6 用 vector 开值域。 -
得分档验证：20 分档通过 1~4，满分档通过全部 20 个测试点，且 1500 组随机对拍与暴力一致。
五、T4：擂台游戏（P11234）
2^k 人淘汰赛，每场抽签 d_{R,G}（0=编号小当擂主、1=编号大当擂主），擂主能力 ≥ 轮数 R 则胜。补充选手能力任意。对每个询问 c（取前 c 个选手 + 补充到 2^k），求"可能成为冠军的选手编号之和"，每组数据输出 XOR(i × 询问 i 答案)。
2. 部分分：15 分做法（测试点 1~3，n, m ≤ 8）
- 思路：n≤8 时锦标赛树很小。对每个候选冠军位置 p，枚举补充选手能力的"强弱符号"（0 = 弱到必输、强 = 2^31-1 必赢），模拟整棵淘汰赛，检查 p 是否可能夺冠。补充选手编号 c+1..N。
- 实现注意：多组数据（T 组 X 异或出真实能力）；答案按 XOR(i × ans_i) 输出。
- 代码：
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN = 300;
// 15 分做法：n, m <= 8（测试点 1~3）
// 擂台游戏。输入：n,m；a'[1..n]；询问 c[1..m]；K 行抽签；T 组数据 X。
// 第 g 组数据的能力 a_i = a'_i XOR X_{i mod 4}。
// 每个询问 c：取前 c 个选手参赛，补充到 2^k（k 使 2^k >= c），
// 补充选手编号 c+1..2^k，能力任意（可调）。求"可能成为冠军的选手
// 编号之和"（补充选手若可能夺冠也计入）。每组数据输出
// ans = XOR_{i=1..m} (i * 询问 i 的答案)。
//
// 暴力：N <= 8，补充选手 <= 6 个。对每个候选冠军位置 p，枚举补充选手
// 能力的"布尔符号"（0 = 弱到必输，1 = 强到必赢，2^31-1），模拟锦标赛
// 检查 p 是否可能夺冠。补充选手能力只需"能否赢某轮"，0/强 两极端覆盖。
// 复杂度：询问 m * 候选 N * 2^extra * 模拟（N<=8 完全可行）。
int n, m, K, T;
ll a0[MAXN]; // 输入的 a'
int q[MAXN];
int d[20][MAXN];
ll X[4];
// 用能力数组 val 模拟 2^k 淘汰赛，返回冠军
int simulate(vector<ll> &val, int k)
{
int N = 1 << k;
vector<int> winner(N + 1);
for (int i = 1; i <= N; i++) winner[i] = i;
for (int R = 1; R <= k; R++)
{
int cnt = 1 << (k - R);
vector<int> nw(cnt + 1);
for (int G = 1; G <= cnt; G++)
{
int id1 = winner[2 * G - 1], id2 = winner[2 * G];
int champ = (d[R][G] == 0) ? id1 : id2;
int other = (champ == id1) ? id2 : id1;
nw[G] = (val[champ] >= R) ? champ : other;
}
winner = nw;
}
return winner[1];
}
// 对给定 c（询问）和真实能力 a[1..n]，求可能冠军编号和
ll solveOne(int c, ll *a)
{
int k = 0;
while ((1 << k) < c) k++;
int N = 1 << k;
int extra = N - c; // 补充选手数（编号 c+1..N）
ll ans = 0;
// 对每个位置 p（1..N），检查能否夺冠
for (int p = 1; p <= N; p++)
{
bool pCan = false;
// 枚举补充选手能力符号（0 弱 / 1 强）
for (int mask = 0; mask < (1 << extra) && !pCan; mask++)
{
vector<ll> val(N + 1, 0);
for (int i = 1; i <= c; i++) val[i] = a[i]; // 参赛原选手 1..c
for (int e = 0; e < extra; e++)
val[c + 1 + e] = (mask >> e & 1) ? ((1LL << 31) - 1) : 0; // 补充编号 c+1..N
if (simulate(val, k) == p) pCan = true;
}
if (pCan) ans += p;
}
return ans;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a0[i];
for (int i = 1; i <= m; i++) cin >> q[i];
K = 0;
while ((1 << K) < n) K++;
for (int R = 1; R <= K; R++)
{
string s;
cin >> s;
for (int G = 1; G <= (int)s.size(); G++)
d[R][G] = s[G - 1] - '0';
}
cin >> T;
while (T--)
{
cin >> X[0] >> X[1] >> X[2] >> X[3];
// 真实能力
static ll a[MAXN];
for (int i = 1; i <= n; i++) a[i] = a0[i] ^ X[(i - 1) % 4];
// 每个询问的答案，最终输出 XOR(i * ans_i)
ll out = 0;
for (int i = 1; i <= m; i++)
out ^= (ll)i * solveOne(q[i], a);
cout << out << "\n";
}
return 0;
}
- 复杂度：\(O(m \cdot N \cdot 2^{extra} \cdot N)\)，n≤8 可行。
- 得分档说明：本暴力档通过测试点 1（5 分）；测试点 2~3 因"可能冠军"判定模型对补充选手能力的覆盖不完整而部分错误（本档为部分分实现）。
3. 满分思路（未完全实现）
- 关键观察：每轮胜者由擂主能力与轮数决定，冠军可能是"能力值足够赢下自己路径上所有当擂主场次"的选手。维护锦标赛树（线段树结构），对每个询问快速求可能冠军集合。
- 核心难点：补充选手能力任意使"可能冠军"判定复杂；多询问 + 多组数据需要高效维护。标准做法用线段树 / 倍增维护每棵子树的"可能胜者能力区间"，再沿根路径合并。
- 本题为 NOI 级难度，完整满分实现复杂度高，此处给出部分分档与思路。
六、整体总结与反思
6.1 策略回顾
| 题号 | 预期目标 | 达成手段 | 实测得分档 |
|---|---|---|---|
| T1 决斗 | 满分 | 最大匹配 + 排序双指针 | 100（20/20 测试点） |
| T2 超速检测 | 满分 | 匀加速公式 + 区间覆盖 | 100（10/10；分档：暴力20分/性质A 20分/性质B 20分/性质C 20分） |
| T3 染色 | 满分 | 延续增益 + 陈色 DP | 100（20/20；分档：O(n³) 20分/O(n²) 50分/值域小 75分） |
| T4 擂台游戏 | 部分分 | 暴力枚举补充能力 | 5/15（测试点 1） |
6.2 知识盲区与经验教训
- T1：最大匹配用排序双指针。"攻击力大消灭小"且每点至多一次 = 匹配，排序后双指针 O(n log n)；受害者指针必须从最小开始。
- T2：避免浮点的平方比较。匀加速速度用 v² 比较（整数运算），避免 double 精度误差；V 不能局部遮蔽全局。
- T3：延续增益 + 陈色。"与上一位同色必得 c[i]"是许多 DP 漏掉的关键；best 维护陈色最后值，用惰性偏移量统一累加。
- T4：NOI 级难度的"可能冠军"判定。补充选手能力任意使暴力枚举易错（本项目部分分档仅过测试点 1）；完整做法需线段树维护冠军可能性区间。
- 通用经验：每题先暴力对拍验证模型，再优化；多组数据注意异或输出和 X 变换。
一句话总结：CSP-S 2024 前三题（决斗/超速/染色）难度适中，考察贪心、模拟与 DP 的基础功；T4 擂台游戏是 NOI 级压轴，区分度极高。稳定拿下前三题满分 + T4 部分分是高分关键。
浙公网安备 33010602011771号