[赛前模拟] J组难度小超班 · 赛后复盘报告 · 带批评版

2026-09-24 14:30–17:00 · 7 名参赛学生 · 95 次提交 · T1–T5 五道题

点上面的板块切换；点「全部展开」一次看完，方便打印。

这份报告是什么

2026 年 9 月 24 日 [赛前模拟] J组难度小超班 比赛结束后，对 7 名参赛学生的 95 次提交 （比赛当天 94 次 + 赛后补题 1 次）做的完整复盘：每一发做了什么、思路怎么演变、和正解差在哪。

板块看什么
总览比赛信息、成绩表、统计口径
总结所有结论汇总：四个横向发现、三种思维形态、三个「差一步」、训练建议
逐人流程每人每次提交「这一发在干什么」+ 打法分析 + 与正解的距离
状态轨迹每次提交改了哪几个字符（红删绿增）、改动类型、评测耗时/内存
思路轨迹每人每题的模型切换路径：起点 → 转折 → 卡点 → 终态
完整时间线95 次提交按时间排开
题目与正解T1–T4 的题意、正解骨架、数据范围与踩坑点
附录判题机异常清单、统计口径说明

比赛信息

项目内容
比赛名称[赛前模拟] J组难度小超班
时间窗口2026-09-24 14:30 – 17:00（2.5 小时）
题目T1 超常班叠叠乐 / T2 一般凹凸序列 / T3 超常班的走廊巡逻 / T4 Sanhai 群岛的“优质”桥梁 / T5 [Wzhoi2026] 梦开始的地方
参赛人数18 人（本报告统计其中有提交的 7 名学生）
提交次数比赛当天 94 次 + 赛后补题 1 次

成绩表

排名姓名总分T1T2T3T4T5当天提交次数
1张恩博220100100—20—24
1Vicco_Li220100100020025
1Guagua111220100100020—15
1crkr220100100020—14
5钟如杉100—100———4
5NaiLong100—100—0—6
7徐浩然95095———6
957 名学生提交总次数
2.5h比赛时长 14:30–17:00
17属于「结构性改动 / 重写」的提交
0做出 T3 或 T4 正解的人数

一句话结论

这批学生的强项是「结论题 + 构造题」，短板是「建模题」；而真正吃掉分数的是三个和算法无关的东西： 类型宽度、边界对齐、自测缺失。

四个横向发现（按重要性排）

① T1 的真凶是 int 溢出，不是算法

Guagua111 和 crkr 都拿到「逻辑完全正确但 ans/数组是 int」的 10 分。 crkr 从 16:03 到 16:08 连交 9 发、耗 71 分钟，最后 AC 的唯一实质改动就是 int a[] → ll a[]； Guagua111 的 10 分版与 AC 版差别也只是类型宽度。本题答案可达 10¹⁶ 量级，这是最该在赛前统一强调的一条。

② T2 是一道「调参数题」——分数是调出来的，不是想出来的

8 人共 37 发，轨迹清一色 0 → 5 → 40 → 45 → 65 → 70 → 95 → 100。 改的东西基本是：循环边界差 1、尾部多输出一个数、cout<<1e9（输出成 1e+09， 张恩博连掉 4 发）。真正换思路的只有两三次。

③ 判题机有两段不稳定窗口，白吃了 8 次提交

15:13–15:20：5 次 Compile Error——NaiLong 的 T2 连续 3 发提交 MD5 完全一致的代码 （WA → CE → CE → 第 3 次 AC）；Guagua111 同一份代码先 CE、2 分钟后 AC。
16:01：crkr 在 36 秒内连交 3 发 T1，三次都被判「题目配置错误。找不到输入文件 1.in。」。
这 8 次提交不是选手的问题，复盘统计时应剔除。

④ 无效提交比想象的多

95 次提交里有 10 次是把同一份代码原样再交：其中 6 次是判题机故障后的重试（应当剔除）， 剩下 4 次完全没有意义（张恩博 2 次、Vicco_Li 2 次），另有 1 次只改了空白。
而「假装在改」的典型有两次：徐浩然把 mx-a[i] 改成 abs(mx-a[i])（完全等价）； Vicco_Li 在 T1 上 6 发把哨兵值在 -1e9 / -1e18 / 1e9 / 1e18 之间来回换，相似度全部 >0.98。

三种思维形态 —— 需要三种不同的干预

形态特征代表缺什么怎么补
换模型型卡住就推倒重来，相似度会掉到 0.55 以下；换对一次就过张恩博、钟如杉、（后期）Vicco_Li、Guagua111(T2/T3)换完模型不验样例强制「改完先手算一遍题目样例再交」
磨参数型模型已对但不会定位失败原因，连续多发相似度 >0.95crkr、Guagua111 的 T1、NaiLong本地自测要求提交前必须本地跑通样例 + 一组自造数据
增量推广型
最危险		模型本身是错的，却把它包装得更「通用」，越改越自信徐浩然 T1、Vicco_Li T1 前 13 发回头质疑模型本身同一题卡满 3 发就停下来重读题、手推样例，而不是继续改

三个「差一步」，是最好的讲评素材

  1. 张恩博 · T4：16:36:42 写出了「奇数取 aᵢ、偶数取 aᵢ−1」的奇偶性分类——正解核心， 只因最后多写一个 +1 归零，16:38 收手，此时还剩 22 分钟。
  2. Vicco_Li · T4：把问题改写成链上带容量回溯的 DFS 搜索——模型其实就是正解的模型 （一次行走 + 每条桥有次数预算），但链上要的是奇偶性分类而不是枚举，4 发全部 RE、吃到 251MB。
  3. Guagua111 · T3：四发依次补齐「BIT 下标 0 → +1 → 模数 2n → 2(n−1) → 折叠函数 → 镜像」， 每一发都在缩小包围圈，最后只差「查询区间跨 0 时拆成两段」。

三条训练建议

  1. 统一打一次「类型宽度」补丁：「答案量级超过 2×10⁹ 就用 long long」——这一条直接对应 T1 上两个人共 20+ 次提交的浪费。
  2. 把「提交前自测」变成硬规则：crkr 少读一个参数、1.6GB 数组、int 溢出，三件事跑一次样例就全暴露； 他 T3/T4 各只交 1 发就放弃，说明试错意愿低、而自测更缺。
  3. 讲评就用「差一步」这三个例子：张恩博的 T4、Vicco_Li 的 T4、Guagua111 的 T3， 都是「方向对了但差最后一层」，比讲标准答案更能说明「再想 5 分钟」的价值。

逐人做题流程

每人一行一次提交：这一发在干什么 + 打法分析 + 与正解的距离。「赛中」列是距开赛（14:30）的分钟数。

张恩博 U79 · 220 分 · 24 次提交

#时刻赛中题判定这一发在干什么
114:46:45+16′T10 Wrong Answer开局就交：把「还差多少层」按 0 切成两段，答案取两段各自最大值之和 —— 错模型（峰一多就漏算）
214:52:13+22′T10 Wrong Answer把 cin 换 scanf、ans 显式初始化，逻辑一行没动
314:55:00+25′T10 Wrong Answer只加了个换行，继续没碰逻辑
415:19:52+49′T20 Wrong Answer转 T2：1/50001/2 交替铺，尾部 cout<<1e9 —— 1e9 是 double 字面量，输出成 1e+09，直接 0 分
515:20:15+50′T20 Wrong Answer★ 与上一发逐字节相同，原样重交
615:21:18+51′T20 Wrong Answer把 1e9 写成 1000000000
715:24:46+54′T20 Wrong Answer改成 1000000000-1（在猜数值上限）
815:26:38+56′T265 Wrong Answer循环边界改 n-k-1、尾部下标从 0 起 —— 第一次拿到分，65
915:29:03+59′T295 Wrong Answer尾部补一个 <<b<< —— 95
1015:32:20+62′T295 Wrong Answer补 if(n<3) 输出 -1 的边界分支
1115:47:33+77′T295 Wrong Answer补 if(k==0) 分支，但尾部多打了一个数
1215:47:55+77′T295 Wrong Answer把多余空格去掉再交一次
1315:50:16+80′T2100 Accepted去掉多余输出 → AC（T2 共 10 发、30 分钟）
1415:54:28+84′T10 Wrong Answer回 T1：只把换行去掉
1516:15:56+105′T10 Wrong Answer推倒重来，换成「差分取正和」的正确思路，但漏了首元素和尾元素
1616:19:01+109′T1100 Accepted补上 diff[n+1]=maxn-arr[n] → AC（T1 共 6 发、跨 92 分钟）
1716:30:16+120′T40 Wrong AnswerT4 首交：Σ|相邻差|
1816:30:31+120′T40 Wrong Answer16 秒后重交一发（同样思路）
1916:31:55+121′T40 Wrong Answer输出换成 arr[2]
2016:32:40+122′T40 Wrong Answer换成 2*min(arr[2],arr[3])
2116:32:56+122′T40 Wrong Answer只把 2 改成 2LL（改类型）
2216:33:44+123′T420 Wrong Answer换成 arr[2]+arr[3] → 20 分
2316:36:42+126′T40 Wrong Answer★ 转向奇偶性：奇数取 a[i]、偶数取 a[i]-1，然后 ans+1
2416:38:41+128′T40 Wrong Answer去掉 +1 → 仍是 0。16:38 停手，此时距比赛结束还有 22 分钟

他的打法

打法：三段式，每段都靠「打补丁」推进。T1 开局即翻车，前 3 发只改了输入输出、没碰逻辑，然后冷藏 65 分钟转 T2；T2 用 10 发把自己从 0 分一路调到 100 分，其中前 4 发的失败全是「输出格式/数值写法」问题（1e9 输出成 1e+09、边界差 1、尾部多打一个数）。T1 直到 16:15 才推倒重来换成正确思路，补了尾部才过。
关键点：他是全组唯一在 T4 上真正换过模型的。16:30–16:33 连着 6 发在猜公式（Σ|Δ| → arr[2] → 2·min → a1+a2），16:36:42 那一发改用了一整套奇偶性分类（奇数取 a[i]、偶数取 a[i]−1），这已经是正解的核心，只是聚合方式没想对（多写了 +1）。16:38 停手时距结束还有 22 分钟，他没再用这段时间。

与正解的距离

T1：6 发、92 分钟，最后靠正确模型+补尾部拿到。思路是对的，但「首尾边界」耗掉了他两次机会。
T2：正解构造，10 发 30 分钟。分数轨迹 0→0→0→0→65→95→95→95→95→100，典型的「判题机当编译器用」。
T4：最接近正解的一次尝试——奇偶性方向已找到，差最后一步的聚合。这是他这场最值得复盘的地方。

Vicco_Li U78 · 220 分 · 26 次提交

#时刻赛中题判定这一发在干什么
114:44:30+14′T10 Wrong AnswerT1 首交：「遇到 max 就把当前段的最大缺口累加一次」的段模型（错）
214:48:45+18′T10 Wrong Answer哨兵 -1e9 + 加条件 a[i-1]!=maxv，同一模型
314:49:48+19′T10 Wrong Answer把 n 从 int 改成 long long（与本题错误无关）
414:50:51+20′T10 Wrong Answer改成累加 nwmaxv、缺口改存 maxv-a[i]，继续试参数
514:53:05+23′T10 Wrong Answer把 max 换 min、哨兵换 1e9（方向反了）
614:57:44+27′T10 Wrong Answer末尾补 a[n+1]=maxv、重写循环 —— 同一模型第 6 次，仍 0 分
715:18:38+48′T240 Wrong Answer转 T2：首交，构造「3 + (k-1)个2 + 0 + 一串2」→ 40 分
815:22:01+52′T20 Wrong Answer换成 1 3 2 4 循环 → 0
915:27:59+57′T20 Wrong Answer边界改成 n-k → 0
1015:31:02+61′T270 Wrong Answer改成 a[] 查表取值 → 70
1115:32:23+62′T270 Wrong Answer补 n-k-2==0 与 <0 两个分支 → 70
1215:36:25+66′T245 Wrong Answer尾部填 -1 → 45（更差，退回）
1315:39:49+69′T2100 Accepted尾部改成 lst±1（按倒数第二个数与最后一个数的大小选方向，保证接口必坏）→ AC。T2 共 7 发、21 分钟
1415:43:09+73′T10 Wrong Answer重开 T1：换哨兵 -1e18
1515:48:43+78′T10 Wrong Answer★ 与上一发逐字节相同，原样重交
1616:05:43+95′T10 Wrong Answer★ 与上一发逐字节相同，原样重交
1716:09:01+99′T10 Wrong Answer★ 与上一发逐字节相同，原样重交（三连空转，共 21 分钟）
1816:19:45+109′T10 Wrong Answer再换哨兵方向（1e18/min）
1916:35:02+125′T1100 Accepted彻底换成正解写法（逐位比较，首元素补 maxv-a[1]）→ AC。T1 共 12 发、跨 110 分钟
2016:44:11+134′T420 Wrong AnswerT4：只写 n==3 分支（a1+a2）→ 20
2116:50:56+140′T420 Runtime Error★ 改交 DFS 回溯：在链上枚举所有走法求最长，模型其实是对的，但指数级、吃到 251MB → RE
2216:51:24+141′T420 Runtime Error修手误 --b[u] → --b[u-1]
2316:51:54+141′T420 Runtime Error补上回溯恢复 ++b[u]
2416:53:15+143′T420 Runtime Error又把回溯恢复删掉、memcpy 换手写循环
2516:56:28+146′T50 Time ExceededT5 交一发 O(len²) 枚举 gcd → TLE；赛后 19:10 又补了一发 T3，仍 WA
2619:10:24+280′ 赛后T30 Wrong Answer

他的打法

打法：最轴的一个，也最不会调试。T1 是全场投入最大的单题——12 发跨 110 分钟；前 6 发全在同一个错模型里换哨兵/换条件/换类型，一分没动。转 T2 后 7 发拿到 AC。回到 T1 之后出现了本场最典型的无效行为：15:48、16:05、16:09 三发是逐字节完全相同的代码，等于「再交一次看会不会变」；45 分钟后（16:35）才换成正解写法过了。
T4 反而是他思路最好的一次：拿到 20 分后立刻改写成一个 DFS，在链上带容量回溯枚举所有走法求最长——这就是正解的模型（一次行走 + 每条桥的访问次数预算），但他没意识到这条链上要的是「奇偶性分类」而不是「枚举」，于是 4 发全部 RE（250MB+）。16:56 又交了一发 T5，赛后 19:10 还回来补了一发 T3。

与正解的距离

T1：12 发、110 分钟。问题不是不会，是 6 发没换模型 + 3 发原样重交。
T2：全场对「接缝处理」想得最细的一份（lst±1），一次到位。
T4：模型对、方法错。如果把 DFS 换成「奇偶性分类」，这题就是他拿下的。

Guagua111 U81 · 220 分 · 15 次提交

#时刻赛中题判定这一发在干什么
115:03:42+33′T20 Wrong AnswerT2 首交：1 3 2 4 循环 + 尾部 i+4（越界构造）
215:08:50+38′T20 Wrong Answer★ 探针提交：把正式代码整段注释掉，只交一句 cout<<-1;
315:13:40+43′T245 Wrong Answer恢复正式代码，尾部统一填 4 → 45
415:18:28+48′T20 Compile Error重写成 a[4]={4,1,3,2} + 末值复制 —— 判题机报 Compile Error
515:20:02+50′T2100 Accepted★ 与上一发完全相同，重交 → AC（那次 CE 是判题机侧的）
616:08:30+98′T110 Wrong AnswerT1 首交：思路完全正确，但 ans 是 int → 溢出，只拿 10 分
716:09:03+99′T10 Wrong Answer加 #define int long long，但手抖把整个计算循环删空了 → 0
816:09:32+99′T1100 Accepted51 秒后补回循环 → AC
916:35:12+125′T30 Time ExceededT3 首交：BIT 从 0 下标起步 → lowbit(0)=0 死循环 TLE
1016:47:30+137′T30 Wrong Answer下标统一 +1 起（死循环解掉），模数仍是 2n
1116:53:28+143′T40 Wrong Answer模数换成 p=2(n-1)（关键一步），但区间没做折叠
1216:53:44+143′T40 Wrong Answer写出折叠函数 f(x)（取模+翻折+镜像）→ 仍 WA（离正解只差区间跨 0 的处理）
1316:54:15+144′T420 Wrong AnswerT4：min(a1,a2)
1416:55:33+145′T30 Wrong Answer改 max(a1,a2)
1516:56:40+146′T30 Wrong Answer改成 max(a1+min(a1,a2), a2+min(a1,a2))，化简即 a1+a2 → 20 分，收工

他的打法

打法：爱试探、动手快，但手抖。T2 第二发把代码整段注释掉、只交一句 cout<<-1;——这是明确的探针提交（用最小改动看判题反应），本组只有他这么做。T1 的过程最能说明问题：第一发思路完全正确，只因为 ans 是 int 溢出拿了 10 分；改成 long long 时手一抖把整个计算循环删空（0 分），51 秒后补回才 AC——同一道题的三种命运全在一分钟内。
T3 是全场对正解逼近得最完整的一条路径：第一发死循环 TLE（BIT 从 0 下标起步）→ 下标 +1 起（修掉死循环，还是 WA）→ 把模数从 2n 改成 2(n−1)（关键一步）→ 写出折叠函数 f(x) 并把镜像也过一遍 f。四发全 0，但每一发都在往正解靠，最后只差「查询区间跨 0 的拆分」这一层。

与正解的距离

T1：逻辑一次就对，输在类型宽度和一次手误。
T2：5 发、17 分钟，最后一份构造和其它人同构且正确。
T3：4 发全 0，但是全组唯一把「模数 → 折叠 → 镜像」依次补齐的人，差最后一层区间拆分。
T4：3 发在 min/max 之间摇摆，最后拐弯写成 a1+a2，拿 20 分。

crkr U82 · 220 分 · 14 次提交

#时刻赛中题判定这一发在干什么
114:57:08+27′T10 Wrong AnswerT1 首交：套刷题模板，从后往前差分取 |Δ|
215:02:27+32′T10 Wrong Answer改成缺口数组取正差分和（思路已经对了）但 int 溢出 → 0
315:13:04+43′T25 Wrong AnswerT2 首交（该记录页无代码，判定 5 分）
415:22:40+52′T20 Wrong AnswerT2 重写：1 3 2 4 循环 + i-=k 后查表
515:26:40+56′T2100 Accepted循环拆两段、边界改 n-k → AC
616:01:05+91′T10 Format Error★ 判题机报「题目配置错误。找不到输入文件 1.in。」—— 环境故障，白交
716:01:17+91′T10 Format Error★ 同上
816:01:41+91′T10 Format Error★ 同上（三连撞上环境故障）
916:03:48+93′T10 Wrong Answer重写：首元素补 max，但循环写成 i<n 且条件写错 → 0
1016:04:58+94′T110 Wrong Answer条件改成 a[i]-a[i+1]>0 → 10
1116:07:22+97′T110 Wrong Answer补上 a[n+1]（首尾都填 max）→ 10（还差类型）
1216:08:43+98′T1100 Accepted把数组与 ans 从 int 换成 ll → AC。整场 T1 唯一的实质改动就是加宽类型
1316:32:36+122′T30 Runtime ErrorT3 唯一一发：2×1.6GB 静态数组 + scanf 少读一个 t → RE（4ms 就挂）
1416:57:50+147′T420 Wrong Answer收比赛前最后一发 T4：a[1]+a[2] → 20 分

他的打法

打法：模板最熟、自测最少。代码骨架是标准刷题模板（solve(__CASE__)、typedef __int128、注释掉的常量），说明刷题量在这组里最大；但也是全场唯一在 T3 上「一次都不改就直接交」的人——2×1.6GB 的静态数组 + scanf 少读一个参数，4 毫秒就 RE 了，这两件事只要本地跑一次样例就会发现。
T1 的过程是本场最有代表性的一个现象：他的算法从第 2 发就已经正确，后面 9 发有 3 发撞上判题机「题目配置错误/找不到输入文件」的环境故障，剩下的都在敲细节，真正的转折是第 12 发把数组和答案从 int 换成 ll。也就是说这道题他花了 70 分钟，最后解决的是类型宽度问题，不是算法问题。

与正解的距离

T1：9 发、71 分钟，其中 3 发被判题机环境故障吃掉；AC 的唯一实质改动是 int→ll。
T2：3 发 14 分钟拿下，效率最高的一题。
T3：唯一一发，思路（用大偏移把 W/E 坐标分开 + 镜像查询）其实已接近正解，但输入解析错了、内存超了 6 倍。
T4：最后一发 a1+a2，20 分。

钟如杉 U80 · 100 分 · 4 次提交

#时刻赛中题判定这一发在干什么
114:57:33+27′T20 Wrong AnswerT2 首交：只处理 k==0 与 k==n-2 两种极端
215:02:58+32′T20 Wrong Answerk==0 分支改成 1 3 2 4 循环
315:15:08+45′T20 Compile Error★ 判题机报 Compile Error（代码本身没问题，同一时间窗另有 4 人 CE）
415:19:48+49′T2100 Accepted直接换成最终正确形态：前 k+1 个同值 + 其余走 1 3 2 4 循环 → AC

他的打法

全场最省提交的人：4 发、只做 T2。前两发只写了 k=0 与 k=n−2 两个极端分支（这是把子任务当全题做），第三发撞上判题机的 Compile Error（同一时间窗另有 4 人 CE），第四发直接跳到最终正确形态一次通过。

与正解的距离

T2：4 发、22 分钟 AC，写法（前 k+1 个同值 + 其余 1 3 2 4 循环）与其它人的「尾部复制末值」不同，但对边界三元组的处理同样成立。
没有提交 T1/T3/T4——4 次提交里有 1 次是判题机故障。这场他只用了别人 1/6 的提交量拿到 100 分。

NaiLong U99 · 100 分 · 6 次提交

#时刻赛中题判定这一发在干什么
115:14:44+44′T20 Wrong AnswerT2 首交（记录页只显示判题机提示，无代码）
215:15:54+45′T20 Compile Error★ 与后一发逐字节相同 → Compile Error
315:16:54+46′T20 Compile Error手工状态机推 1 3 2 4，尾部复制末值
415:18:26+48′T20 Compile Error★ 与上一发逐字节相同 → 又是 Compile Error
515:20:25+50′T2100 Accepted★ 同一份代码第 3 次提交 → AC。代码从头到尾没问题，是判题机编译服务不稳定
616:55:02+145′T40 Wrong AnswerT4：cout<<n+6; —— 放弃式提交

他的打法

T2 的代码从第一发起就是对的，被判题机耽误了 5 分钟。5 发 T2 里，后 4 发的代码 MD5 完全一致：先 WA、再连续两次 Compile Error、第三次提交直接 AC。这不是他的问题，是判题机在 15:15–15:20 这段的编译服务不稳定（同一窗口共有 5 次 CE，其中钟如杉、Guagua111 的代码重交后也都 AC 了）。
16:55 的 T4 是明确的放弃：cout<<n+6;。

与正解的距离

T2：手工状态机实现，一次写对；5 发、6 分钟里 4 发是判题机的锅。
T4：放弃式提交。全场 6 次提交，实际只认真做了 1 题。

徐浩然 U83 · 95 分 · 6 次提交

#时刻赛中题判定这一发在干什么
114:46:54+16′T10 Wrong Answer全场第一发（14:46:54）：按 0 切成两段，答案取两段最大值之和
214:51:34+21′T10 Wrong Answer把两段推广成 m 段：遇 0 开新段、段内取最大、再求和 —— 仍是同一个错模型
314:52:47+22′T10 Wrong Answer只加了快读快写，逻辑没动
415:01:00+31′T10 Wrong Answer把 b[i]=mx-a[i] 改成 abs(mx-a[i])（b 本来就非负，无意义）→ 之后放弃 T1
515:34:24+64′T25 Wrong AnswerT2 首交：1 3 2 4 循环、余下直接输出 i-3 → 5 分
615:56:26+86′T295 Wrong Answer重写成 a[] 循环 + j 记录末值复制 → 95 分（余数段被 4 整除时整段跳过）

他的打法

全场第一个交卷的人（14:46:54），也是唯一没上 100 的。T1 的 4 发暴露同一个毛病：换着花样改，但从不换模型。他从「两段取最大」推广到「按 0 分段取最大再求和」——听起来更一般了，其实还是错的（一个段内出现两次高峰仍然只算一次）；第三发只加了读入优化；第四发把 b[i]=mx-a[i] 改成 abs(mx-a[i])（b 本来就非负，等于什么都没做）。4 发之后他直接放弃了 T1。
T2 则是另一种极端：第一发朴素版拿 5 分，第二发重写后直接 95 分——思路和其它 7 个人完全一致且正确，只是用「每 4 个一次性输出」的写法时，当 n−k 恰好是 4 的倍数会整段跳过余数循环，j 保持全局初值 0，尾部变成了 0。

与正解的距离

T1：4 发全 0、15 分钟内结束，此后再没碰过——错因是模型只对一半，而且 4 发都没触及这个核心。
T2：95 分。思路 100 分、实现 95 分，精确失败条件为 (n−k) % 4 == 0 且 k ≥ 1（本地 152 组枚举错 32 组，真实数据只打掉 1 个测点）。
如果他 T1 的第 2 发不是「推广分段」而是「回头验算样例 2」，这场的名次会完全不同。

做题状态轨迹（细粒度）

看「改动幅度」判断他是在试参数还是在换思路，看「细粒度差异」的红删绿增判断他具体动了哪几个字符。评测耗时/内存是第二证据。

957 名学生的提交总数
10原样重交（其中 6 次是判题机故障后的重试）
2真正换思路的「重写」
0.863平均相似度

三类改动分布

局部修补 46 次、首交 21 次、结构性改动 15 次、原样重交 10 次、重写 2 次、仅空白 1 次。涉及的知识点：常量 50、比较/边界 38、控制流 25、输出 25、下标 17、模运算 12、类型只有 7。

翻译一下：绝大部分时间花在改数字和改不等号上，而不是改算法。

张恩博 24 次提交

T1 超常班叠叠乐 6 次提交 · 分数轨迹 0 → 0 → 0 → 0 → 0 → 100

#时刻判定用时/内存改动幅度细粒度差异
114:46:45
+16′
0 Wrong Answer545ms
15.6 MiB
首交
相似度 1.000 · +0/-0 行
（首次提交本题）
第一次提交本题
214:52:13
+22′
0 Wrong Answer174ms
15.8 MiB
局部修补
相似度 0.918 · +3/-3 行
ll ans;→ll ans=0;
cin>>n;→scanf("%d",&n);
cin>>arr[i];→scanf("%lld",&arr[i]);
常量 模/取余 下标
314:55:00
+25′
0 Wrong Answer184ms
16 MiB
局部修补
相似度 0.962 · +1/-1 行
cout<<ans;→cout<<ans<<'\n';
比较/边界 输出
415:54:28
+84′
0 Wrong Answer184ms
15.7 MiB
局部修补
相似度 0.962 · +1/-1 行
cout<<ans<<'\n';→cout<<ans;
516:15:56
+105′
0 Wrong Answer182ms
15.9 MiB
结构性改动
相似度 0.729 · +5/-9 行
新增diff[i]=arr[i]-arr[i-1];
ll cur=0;→ll ans=0;
for(int i=1;i<=n;i++){→for(int i=2;i<=n;i++){
diff[i]=maxn-arr[i];→if(diff[i]>0){
常量 下标 控制流 比较/边界 输出
616:19:01
+109′
100 Accepted2965ms
140 MiB
局部修补
相似度 0.962 · +2/-1 行
新增diff[n+1]=maxn-arr[n];
for(int i=2;i<=n;i++){→for(int i=2;i<=n+1;i++){
常量

T2 一般凹凸序列 10 次提交 · 分数轨迹 0 → 0 → 0 → 0 → 65 → 95 → 95 → 95 → 95 → 100

#时刻判定用时/内存改动幅度细粒度差异
115:19:52
+49′
0 Wrong Answer68ms
768 KiB
首交
相似度 1.000 · +0/-0 行
（首次提交本题）
第一次提交本题
215:20:15
+50′
0 Wrong Answer72ms
808 KiB
原样重交
相似度 1.000 · +0/-0 行
与上一发逐字节相同（MD5 一致）
逐字节相同
315:21:18
+51′
0 Wrong Answer46ms
1 MiB
局部修补
相似度 0.975 · +1/-1 行
cout<<1e9<<' ';→cout<<1000000000<<' ';
常量
415:24:46
+54′
0 Wrong Answer44ms
828 KiB
局部修补
相似度 0.996 · +1/-1 行
cout<<1000000000<<' ';→cout<<1000000000-1<<' ';
常量
515:26:38
+56′
65 Wrong Answer40ms
768 KiB
局部修补
相似度 0.991 · +2/-2 行
for(int i=1;i<n-k;i++){→for(int i=1;i<n-k-1;i++){
for(int i=1;i<k;i++){→for(int i=0;i<k;i++){
常量
615:29:03
+59′
95 Wrong Answer42ms
1 MiB
局部修补
相似度 0.981 · +2/-2 行
cout<<a<<' '<<b<<' ';→cout<<a<<' '<<b<<' '<<b<<' ';
for(int i=0;i<k;i++){→for(int i=1;i<k;i++){
比较/边界 输出 常量
715:32:20
+62′
95 Wrong Answer42ms
768 KiB
局部修补
相似度 0.947 · +1/-0 行
新增if(n<3) {cout<<-1;return 0;}
常量 比较/边界 输出
815:47:33
+77′
95 Wrong Answer40ms
796 KiB
局部修补
相似度 0.929 · +1/-0 行
新增if(k==0) {cout<<a<<' '<<b<<' '<<c;return 0;}
常量 比较/边界 输出 控制流
915:47:55
+77′
95 Wrong Answer41ms
768 KiB
局部修补
相似度 0.993 · +1/-1 行
if(k==0) {cout<<a<<' '<<b<<' '<<c;return 0;}→if(k==0) {cout<<a<<' '<<b<<' '<<c<<' ';return 0;}
比较/边界 输出
1015:50:16
+80′
100 Accepted39ms
768 KiB
结构性改动
相似度 0.692 · +1/-1 行
if(k==0) {cout<<a<<' '<<b<<' '<<c<<' ';return 0;}→if(k==0) {cout<<a<<' '<<b<<' ';return 0;}
常量 比较/边界 输出 控制流

T4 Sanhai 群岛的“优质”桥梁 8 次提交 · 分数轨迹 0 → 0 → 0 → 0 → 0 → 20 → 0 → 0

#时刻判定用时/内存改动幅度细粒度差异
116:30:16
+120′
0 Wrong Answer130ms
2 MiB
首交
相似度 1.000 · +0/-0 行
（首次提交本题）
第一次提交本题
216:30:31
+120′
0 Wrong Answer107ms
2 MiB
原样重交
相似度 1.000 · +0/-0 行
与上一发逐字节相同（MD5 一致）
逐字节相同
316:31:55
+121′
0 Wrong Answer102ms
2 MiB
局部修补
相似度 0.984 · +1/-1 行
cout<<ans;→cout<<arr[2];
常量
416:32:40
+122′
0 Wrong Answer107ms
2 MiB
局部修补
相似度 0.947 · +1/-1 行
cout<<arr[2];→cout<<2*min(arr[2],arr[3]);
常量 比较/边界
516:32:56
+122′
0 Wrong Answer114ms
2 MiB
局部修补
相似度 0.996 · +1/-1 行
cout<<2*min(arr[2],arr[3]);→cout<<2LL*min(arr[2],arr[3]);
类型
616:33:44
+123′
20 Wrong Answer100ms
2 MiB
局部修补
相似度 0.954 · +1/-1 行
cout<<2LL*min(arr[2],arr[3]);→cout<<arr[2]+arr[3];
716:36:42
+126′
0 Wrong Answer106ms
1.3 MiB
结构性改动
相似度 0.741 · +6/-3 行
diff[i]=arr[i]-arr[i-1];→if(arr[i]%2){
ans+=abs(diff[i]);→ans+=arr[i];
新增}else{
新增ans+=arr[i]-1;
常量 比较/边界 模/取余 下标 控制流 输出
816:38:41
+128′
0 Wrong Answer117ms
1.3 MiB
局部修补
相似度 0.996 · +1/-1 行
cout<<ans+1;→cout<<ans;
常量

Vicco_Li 26 次提交

T1 超常班叠叠乐 12 次提交 · 分数轨迹 0 → 0 → 0 → 0 → 0 → 0 → 0 → 0 → 0 → 0 → 0 → 100

#时刻判定用时/内存改动幅度细粒度差异
114:44:30
+14′
0 Wrong Answer484ms
4.3 MiB
首交
相似度 1.000 · +0/-0 行
（首次提交本题）
第一次提交本题
214:48:45
+18′
0 Wrong Answer154ms
4.2 MiB
结构性改动
相似度 0.566 · +5/-3 行
int n, a[N], maxv = -1, nwmaxv = -1;→int n, a[N], maxv = -1e9, nwmaxv = -1e9;
新增ios::sync_with_stdio(false);
新增cin.tie(nullptr);
if ((a[i] == maxv && i > 1) || i == n) {→if (((a[i] == maxv && i > 1) || i == n) && a[i - 1] != maxv) {
常量 比较/边界 输出 下标 控制流
314:49:48
+19′
0 Wrong Answer159ms
8 MiB
局部修补
相似度 0.994 · +1/-1 行
int n, a[N], maxv = -1e9, nwmaxv = -1e9;→LL n, a[N], maxv = -1e9, nwmaxv = -1e9;
类型
414:50:51
+20′
0 Wrong Answer162ms
8.2 MiB
局部修补
相似度 0.987 · +2/-2 行
ans += maxv - nwmaxv;→ans += nwmaxv;
nwmaxv = max(nwmaxv, a[i]);→nwmaxv = max(nwmaxv, maxv - a[i]);
514:53:05
+23′
0 Wrong Answer157ms
8.2 MiB
局部修补
相似度 0.924 · +4/-4 行
LL n, a[N], maxv = -1e9, nwmaxv = -1e9;→LL n, a[N], maxv = -1e9, nwmaxv = 1e9;
ans += nwmaxv;→ans += maxv - nwmaxv;
nwmaxv = -1e9;→nwmaxv = 1e9;
nwmaxv = max(nwmaxv, maxv - a[i]);→nwmaxv = min(nwmaxv, a[i]);
614:57:44
+27′
0 Wrong Answer166ms
8 MiB
结构性改动
相似度 0.657 · +8/-7 行
LL n, a[N], maxv = -1e9, nwmaxv = 1e9;→LL n, a[N], maxv = -1e9, nwmaxv = -1e9;
}→} a[n + 1] = maxv;
for (int i = 1; i <= n; ++i) {→for (int i = 1; i <= n + 1; ++i) {
if (((a[i] == maxv && i > 1) || i == n) && a[i - 1] != maxv) {→if (a[i] == maxv) {
常量 比较/边界 下标 控制流
715:43:09
+73′
0 Wrong Answer161ms
8 MiB
结构性改动
相似度 0.743 · +6/-5 行
LL n, a[N], maxv = -1e9, nwmaxv = -1e9;→LL n, a[N], maxv = -1e18, nwmaxv = -1e18;
删除for (int i = 1; i <= n + 1; ++i) {
新增for (int i = 1; i <= (n + 1); ++i) {
if (nwmaxv == -1e9) continue;→if (nwmaxv == -1e18) continue;
常量 比较/边界 下标 控制流
815:48:43
+78′
0 Wrong Answer170ms
8.1 MiB
原样重交
相似度 1.000 · +0/-0 行
与上一发逐字节相同（MD5 一致）
逐字节相同
916:05:43
+95′
0 Wrong Answer171ms
8.2 MiB
原样重交
相似度 1.000 · +0/-0 行
与上一发逐字节相同（MD5 一致）
逐字节相同
1016:09:01
+99′
0 Wrong Answer167ms
8.2 MiB
仅空白/缩进
相似度 1.000 · +0/-0 行
仅空白/缩进差异
只改了空格/换行
1116:19:45
+109′
0 Wrong Answer170ms
8.1 MiB
局部修补
相似度 0.835 · +5/-5 行
LL n, a[N], maxv = -1e18, nwmaxv = -1e18;→LL n, a[N], maxv = -1e18, nwmaxv = 1e18;
if (nwmaxv == -1e18) continue;→if (nwmaxv == 1e18) continue;
ans += nwmaxv;→ans += maxv - nwmaxv;
nwmaxv = -1e18;→nwmaxv = 1e18;
常量 比较/边界 控制流
1216:35:02
+125′
100 Accepted2634ms
70.1 MiB
结构性改动
相似度 0.656 · +13/-11 行
} a[n + 1] = maxv;→}
缩进
for (int i = 1; i <= (n + 1); ++i) {→for (int i = 1; i <= n; ++i) {
if (a[i] == maxv) {→if (a[i] >= a[i - 1] && i > 1) {
常量 比较/边界 下标 控制流

T2 一般凹凸序列 7 次提交 · 分数轨迹 40 → 0 → 0 → 70 → 70 → 45 → 100

#时刻判定用时/内存改动幅度细粒度差异
115:18:38
+48′
40 Wrong Answer37ms
768 KiB
首交
相似度 1.000 · +0/-0 行
（首次提交本题）
第一次提交本题
215:22:01
+52′
0 Wrong Answer29ms
768 KiB
结构性改动
相似度 0.693 · +5/-11 行
int n, k;→int n, k, i;
if (n - k - 2 == 0) {→for (i = 0; i <= n; i += 4) {
for (int i = 1; i <= n; ++i) cout << 0 << ' ';→cout << "1 3 2 4 ";
删除exit(0);
常量 比较/边界 控制流
315:27:59
+57′
0 Wrong Answer32ms
512 KiB
局部修补
相似度 0.941 · +3/-5 行
int n, k, i;→int n, k, i, cnt, a[50005];
for (i = 0; i <= n; i += 4) {→for (i = 0; i <= n - k; i += 4) {
for (; i <= n; ++i) {→for (; i <= n; ++i) cout << "4 ";
删除cout << "4 ";
常量
415:31:02
+61′
70 Wrong Answer41ms
768 KiB
局部修补
相似度 0.852 · +4/-3 行
int n, k, i, cnt, a[50005];→int n, k, i, cnt, a[5] = {0, 1, 3, 2, 4};
for (i = 0; i <= n - k; i += 4) {→for (i = 1; i <= n - k; ++i) {
cout << "1 3 2 4 ";→cout << a[(i % 4) == 0 ? 4 : i % 4] << ' ';
缩进
常量 比较/边界 模/取余 输出
515:32:23
+62′
70 Wrong Answer39ms
768 KiB
结构性改动
相似度 0.797 · +7/-0 行
新增if (n - k - 2 == 0) {
新增for (int i = 1; i <= n; ++i) cout << 0 << ' ';
新增exit(0);
新增} else if (n - k - 2 < 0) {
常量 比较/边界 输出 控制流
615:36:25
+66′
45 Wrong Answer40ms
768 KiB
局部修补
相似度 0.994 · +3/-3 行
缩进cout << -1;
缩进exit(0);
for (; i <= n; ++i) cout << "4 ";→for (; i <= n; ++i) cout << "-1 ";
常量
715:39:49
+69′
100 Accepted43ms
768 KiB
结构性改动
相似度 0.724 · +10/-2 行
新增int lst = 2, ll = 4;
新增lst = a[(i % 4) == 0 ? 4 : i % 4];
新增if (i < n - k) ll = a[(i % 4) == 0 ? 4 : i % 4];
for (; i <= n; ++i) cout << "-1 ";→for (; i <= n; ++i) {
类型 常量 比较/边界 模/取余 输出 控制流

T3 超常班的走廊巡逻 1 次提交 · 分数轨迹 0

#时刻判定用时/内存改动幅度细粒度差异
119:10:24
+280′
0 Wrong Answer428ms
3.9 MiB
首交
相似度 1.000 · +0/-0 行
（首次提交本题）
第一次提交本题

T4 Sanhai 群岛的“优质”桥梁 5 次提交 · 分数轨迹 20 → 20 → 20 → 20 → 20

#时刻判定用时/内存改动幅度细粒度差异
116:44:11
+134′
20 Wrong Answer105ms
852 KiB
首交
相似度 1.000 · +0/-0 行
（首次提交本题）
第一次提交本题
216:50:56
+140′
20 Runtime Error1391ms
251.5 MiB
重写
相似度 0.470 · +35/-1 行
int n, a[N], b[N], ans;→int n, a[N], b[N], ans, ncnt;
新增void dfs(int u, int cnt) {
新增ncnt = max(ncnt, cnt);
新增if (u == 1) {
常量 比较/边界 控制流 输出
316:51:24
+141′
20 Runtime Error1282ms
250.9 MiB
局部修补
相似度 0.998 · +1/-1 行
--b[u];→--b[u - 1];
常量
416:51:54
+141′
20 Runtime Error1296ms
251 MiB
局部修补
相似度 0.878 · +2/-0 行
新增++b[u];
新增++b[u - 1];
常量 比较/边界 控制流
516:53:15
+143′
20 Runtime Error1307ms
250.9 MiB
局部修补
相似度 0.805 · +2/-4 行
删除++b[u];
--b[u - 1];→--b[u];
删除++b[u - 1];
memcpy(b, a, sizeof(a));→for (int i = 1; i < n; ++i) b[i] = a[i];
常量 比较/边界 控制流 下标

T5 [Wzhoi2026] 梦开始的地方 1 次提交 · 分数轨迹 0

#时刻判定用时/内存改动幅度细粒度差异
116:56:28
+146′
0 Time Exceeded≥59952ms
≥796 KiB
首交
相似度 1.000 · +0/-0 行
（首次提交本题）
第一次提交本题

Guagua111 15 次提交

T1 超常班叠叠乐 3 次提交 · 分数轨迹 10 → 0 → 100

#时刻判定用时/内存改动幅度细粒度差异
116:08:30
+98′
10 Wrong Answer153ms
8.2 MiB
首交
相似度 1.000 · +0/-0 行
（首次提交本题）
第一次提交本题
216:09:03
+99′
0 Wrong Answer165ms
8.2 MiB
结构性改动
相似度 0.709 · +5/-7 行
#define INF 0x3f3f3f3f→#define int long long
int n, a[10000005], dif[10000005], mx, ans;→int n, a[10000005], dif[10000005], mx;
int main() {→signed main() {
删除a[i] = mx - a[i];
类型 常量
316:09:32
+99′
100 Accepted2733ms
139.9 MiB
局部修补
相似度 0.880 · +5/-3 行
int n, a[10000005], dif[10000005], mx;→int n, a[10000005], dif[10000005], mx, ans;
新增a[i] = mx - a[i];
新增dif[i] = a[i] - a[i - 1];
新增if (dif[i] >= 0) ans += dif[i];
常量 比较/边界 下标 控制流 输出

T2 一般凹凸序列 5 次提交 · 分数轨迹 0 → 0 → 45 → 0 → 100

#时刻判定用时/内存改动幅度细粒度差异
115:03:42
+33′
0 Wrong Answer37ms
764 KiB
首交
相似度 1.000 · +0/-0 行
（首次提交本题）
第一次提交本题
215:08:50
+38′
0 Wrong Answer29ms
768 KiB
局部修补
相似度 0.888 · +8/-8 行
int i;→// int i;
cout << "1 ";→// for (i = 1; i + 3 <= n - k; i += 4) {
for (i = 2; i + 3 <= n - k; i += 4) {→// cout << "1 3 2 4 ";
cout << "3 2 4 1 ";→// }
常量 比较/边界 输出
315:13:40
+43′
45 Wrong Answer35ms
512 KiB
局部修补
相似度 0.892 · +6/-8 行
// int i;→int i;
// for (i = 1; i + 3 <= n - k; i += 4) {→for (i = 1; i + 3 <= n - k; i += 4) {
// cout << "1 3 2 4 ";→cout << "1 3 2 4 ";
// }→}
常量 比较/边界 输出
415:18:28
+48′
0 Compile Error-
-
局部修补
相似度 0.839 · +5/-3 行
新增int a[4] = {4, 1, 3, 2};
for (i = 1; i + 3 <= n - k; i += 4) {→for (i = 1; i <= n - k; i++) {
cout << "1 3 2 4 ";→cout << a[i % 4] << ' ';
for (; i <= n; i++) cout << 4 << ' ';→int k = a[(i - 1) % 4];
类型 常量 模/取余 比较/边界 输出
515:20:02
+50′
100 Accepted42ms
768 KiB
原样重交
相似度 1.000 · +0/-0 行
与上一发逐字节相同（MD5 一致）
逐字节相同

T3 超常班的走廊巡逻 4 次提交 · 分数轨迹 0 → 0 → 0 → 0

#时刻判定用时/内存改动幅度细粒度差异
116:35:12
+125′
0 Time Exceeded≥20558ms
≥512 KiB
首交
相似度 1.000 · +0/-0 行
（首次提交本题）
第一次提交本题
216:47:30
+137′
0 Wrong Answer1276ms
3.9 MiB
局部修补
相似度 0.939 · +7/-5 行
新增x++;
新增x++;
y = ((y - t) % (2 * n) + 2 * n) % 2 * n;→y = ((y - t) % (2 * n) + 2 * n) % (2 * n);
update(t1, 2 * n - y + 1, z);→update(t1, 2 * n - y, z);
比较/边界 常量 模/取余
316:55:33
+145′
0 Wrong Answer1348ms
6.7 MiB
结构性改动
相似度 0.720 · +11/-10 行
int n, q, t1[400005], t2[400005];→int n, q, t1[400005], t2[400005], p;
for (int i = x; i <= n; i += lowbit(i)) t[i] += k;→for (int i = x; i <= p + 1; i += lowbit(i)) t[i] += k;
新增p = 2 * (n - 1);
y = ((y - t) % (2 * n) + 2 * n) % (2 * n);→y = ((y - t) % p + p) % p;
常量 比较/边界 模/取余 输出 控制流
416:56:40
+146′
0 Wrong Answer1291ms
3.8 MiB
局部修补
相似度 0.821 · +19/-14 行
int n, q, t1[400005], t2[400005], p;→int n, q, t1[400005], t2[400005];
int lowbit(int x) {→int lowbit(int x) { return x & -x; }
删除return x & -x;
删除}
常量 比较/边界 模/取余 控制流

T4 Sanhai 群岛的“优质”桥梁 3 次提交 · 分数轨迹 0 → 0 → 20

#时刻判定用时/内存改动幅度细粒度差异
116:53:28
+143′
0 Wrong Answer106ms
888 KiB
首交
相似度 1.000 · +0/-0 行
（首次提交本题）
第一次提交本题
216:53:44
+143′
0 Wrong Answer99ms
1 MiB
局部修补
相似度 0.986 · +1/-1 行
cout << min(a[1], a[2]);→cout << max(a[1], a[2]);
316:54:15
+144′
20 Wrong Answer106ms
868 KiB
局部修补
相似度 0.907 · +1/-1 行
cout << max(a[1], a[2]);→cout << max(a[1] + min(a[1], a[2]), a[2] + min(a[1], a[2]));
常量

crkr 14 次提交

T1 超常班叠叠乐 9 次提交 · 分数轨迹 0 → 0 → 0 → 0 → 0 → 0 → 10 → 10 → 100

#时刻判定用时/内存改动幅度细粒度差异
114:57:08
+27′
0 Wrong Answer174ms
4.1 MiB
首交
相似度 1.000 · +0/-0 行
（首次提交本题）
第一次提交本题
215:02:27
+32′
0 Wrong Answer169ms
4.3 MiB
局部修补
相似度 0.866 · +4/-3 行
for(int i=n;i>=2;i--) {→for(int i=1;i<=n;i++)
a[i]-=a[i-1];→for(int i=2;i<=n;i++) {
ans+=abs(a[i]);→if(a[i]-a[i-1]>0)
新增ans+=a[i]-a[i-1];
常量 比较/边界 下标 控制流
316:01:05
+91′
0 Format Error-
-
局部修补
相似度 0.841 · +7/-10 行
int n,a[10000005],mx,ans;→int n,a[10000005],ans;
删除int _abs(int x) {
删除return x<0? -x:x;
删除}
常量 比较/边界 控制流 下标
416:01:17
+91′
0 Format Error-
-
原样重交
相似度 1.000 · +0/-0 行
与上一发逐字节相同（MD5 一致）
逐字节相同
516:01:41
+91′
0 Format Error-
-
原样重交
相似度 1.000 · +0/-0 行
与上一发逐字节相同（MD5 一致）
逐字节相同
616:03:48
+93′
0 Wrong Answer173ms
4.3 MiB
局部修补
相似度 0.936 · +3/-5 行
for(int i=1;i<n;i++) {→for(int i=0;i<n;i++) {
if(i>1)→if(a[i]>0)
a[i-1]-=a[i];→ans+=a[i]-a[i+1];
删除if(a[i]>0)
常量 下标 比较/边界
716:04:58
+94′
10 Wrong Answer171ms
4.2 MiB
局部修补
相似度 0.992 · +1/-1 行
if(a[i]>0)→if(a[i]-a[i+1]>0)
常量 下标
816:07:22
+97′
10 Wrong Answer177ms
4.4 MiB
局部修补
相似度 0.991 · +2/-2 行
a[0]=max(a[0],a[i]);→a[0]=a[n+1]=max(a[0],a[i]);
for(int i=0;i<n;i++) {→for(int i=0;i<=n;i++) {
常量
916:08:43
+98′
100 Accepted2851ms
70.2 MiB
局部修补
相似度 0.991 · +4/-3 行
int n,a[10000005],ans;→int n;
新增ll a[10000005],ans;
scanf("%d",&a[i]);→scanf("%lld",&a[i]);
printf("%d",ans);→printf("%lld",ans);
类型

T2 一般凹凸序列 3 次提交 · 分数轨迹 5 → 0 → 100

#时刻判定用时/内存改动幅度细粒度差异
115:13:04
+43′
5 Wrong Answer32ms
512 KiB
首交
相似度 1.000 · +0/-0 行
（首次提交本题）
第一次提交本题
215:22:40
+52′
0 Wrong Answer36ms
768 KiB
局部修补
相似度 0.933 · +9/-7 行
int n,k;→int n,k,i;
for(int i=1;i<=n;i++) {→for(i=1;i<=n;i+=4)
新增printf("1 3 2 4 ");
新增i-=k;
常量 比较/边界 输出 控制流
315:26:40
+56′
100 Accepted36ms
760 KiB
局部修补
相似度 0.854 · +12/-4 行
int n,k,i;→int n,k;
for(i=1;i<=n;i+=4)→for(int i=1;i<=n-k;i++) {
printf("1 3 2 4 ");→if((i-1)%4==0)
i-=k;→printf("1 ");
常量 比较/边界 模/取余 输出 控制流

T3 超常班的走廊巡逻 1 次提交 · 分数轨迹 0

#时刻判定用时/内存改动幅度细粒度差异
116:32:36
+122′
0 Runtime Error4ms
512 KiB
首交
相似度 1.000 · +0/-0 行
（首次提交本题）
第一次提交本题

T4 Sanhai 群岛的“优质”桥梁 1 次提交 · 分数轨迹 20

#时刻判定用时/内存改动幅度细粒度差异
116:57:50
+147′
20 Wrong Answer44ms
1.3 MiB
首交
相似度 1.000 · +0/-0 行
（首次提交本题）
第一次提交本题

钟如杉 4 次提交

T2 一般凹凸序列 4 次提交 · 分数轨迹 0 → 0 → 0 → 100

#时刻判定用时/内存改动幅度细粒度差异
114:57:33
+27′
0 Wrong Answer37ms
768 KiB
首交
相似度 1.000 · +0/-0 行
（首次提交本题）
第一次提交本题
215:02:58
+32′
0 Wrong Answer32ms
768 KiB
结构性改动
相似度 0.778 · +4/-2 行
if(i&1) cout<<1<<' ';→if(i%4==0) cout<<"1 ";
else cout<<2<<' ';→else if(i%4==1) cout<<"3 ";
新增else if(i%4==2) cout<<"2 ";
新增else cout<<"4 ";
常量 比较/边界 模/取余 输出
315:15:08
+45′
0 Compile Error-
-
局部修补
相似度 0.912 · +2/-1 行
for(int i=1;i<=n;i++) cout<<"1 ";→for(int i=1;i<=n;i++) cout<<i<<' ';
缩进
比较/边界 输出
415:19:48
+49′
100 Accepted40ms
768 KiB
重写
相似度 0.318 · +4/-6 行
删除#include <cstdio>
新增int a[5]={1,3,2,4};
if(i%4==0) cout<<"1 ";→cout<<a[i%4]<<' ';
删除else if(i%4==1) cout<<"3 ";
类型 常量 比较/边界 输出 控制流 模/取余

NaiLong 6 次提交

T2 一般凹凸序列 5 次提交 · 分数轨迹 0 → 0 → 0 → 0 → 100

#时刻判定用时/内存改动幅度细粒度差异
115:14:44
+44′
0 Wrong Answer43ms
768 KiB
首交
相似度 1.000 · +0/-0 行
（首次提交本题）
第一次提交本题
215:15:54
+45′
0 Compile Error-
-
局部修补
相似度 0.998 · +1/-1 行
}for(int i=k;i<=n;i++){→}for(int i=k;i<n;i++){
315:16:54
+46′
0 Compile Error-
-
原样重交
相似度 1.000 · +0/-0 行
与上一发逐字节相同（MD5 一致）
逐字节相同
415:18:26
+48′
0 Compile Error-
-
原样重交
相似度 1.000 · +0/-0 行
与上一发逐字节相同（MD5 一致）
逐字节相同
515:20:25
+50′
100 Accepted46ms
800 KiB
原样重交
相似度 1.000 · +0/-0 行
与上一发逐字节相同（MD5 一致）
逐字节相同

T4 Sanhai 群岛的“优质”桥梁 1 次提交 · 分数轨迹 0

#时刻判定用时/内存改动幅度细粒度差异
116:55:02
+145′
0 Wrong Answer14ms
512 KiB
首交
相似度 1.000 · +0/-0 行
（首次提交本题）
第一次提交本题

徐浩然 6 次提交

T1 超常班叠叠乐 4 次提交 · 分数轨迹 0 → 0 → 0 → 0

#时刻判定用时/内存改动幅度细粒度差异
114:46:54
+16′
0 Wrong Answer489ms
15.7 MiB
首交
相似度 1.000 · +0/-0 行
（首次提交本题）
第一次提交本题
214:51:34
+21′
0 Wrong Answer484ms
15.8 MiB
结构性改动
相似度 0.662 · +11/-10 行
int n;→int n , m = 1;
ll mx , ans1 , ans2;→ll mx , cnt;
ll a[N] , b[N];→ll a[N] , b[N] , ans[N];
int i = 1;→for (int i = 1; i <= n; i ++) {
常量 比较/边界 下标 控制流
314:52:47
+22′
0 Wrong Answer166ms
15.9 MiB
局部修补
相似度 0.910 · +3/-0 行
新增ios_base::sync_with_stdio(0);
新增cin.tie(nullptr);
新增cout.tie(nullptr);
常量 输出
415:01:00
+31′
0 Wrong Answer177ms
15.8 MiB
局部修补
相似度 0.994 · +1/-1 行
b[i] = mx - a[i];→b[i] = abs(mx - a[i]);

T2 一般凹凸序列 2 次提交 · 分数轨迹 5 → 95

#时刻判定用时/内存改动幅度细粒度差异
115:34:24
+64′
5 Wrong Answer40ms
768 KiB
首交
相似度 1.000 · +0/-0 行
（首次提交本题）
第一次提交本题
215:56:26
+86′
95 Wrong Answer40ms
768 KiB
结构性改动
相似度 0.630 · +11/-3 行
int n , k , i = 1;→int n , k , i = 1 , j;
新增int a[5] = {1 , 3 , 2 , 4};
for ( ; i <= n; i ++)→while (i - 2 <= n - k - 2) {
cout << i - 3 << ' ';→cout << a[i % 4 - 1] << ' ';
常量 比较/边界 控制流 模/取余 输出

0. 先给全组画一张思维地图

把 116 次提交按"改动幅度"归类之后，这 9 个人的思维轨迹分成三种典型形态，各自的问题完全不同：

类型特征典型行为代表人物
换模型型卡住 → 推倒重来 → 换一个模型相似度会掉到 0.55 以下（出现"重写"），换个模型往往一次就过张恩博、钟如杉、（后期的）Vicco_Li、Guagua111(T2/T3)
磨参数型模型已经对了，但不会定位失败原因连续多发的相似度都在 0.95 以上，只在数值/边界/类型上打转crkr（T1 磨了 71 分钟，最后发现是 int）、Guagua111（T1 三发）、NaiLong
增量推广型最危险模型是错的，但他不是去修 bug，而是把错模型包装得更"通用"第 2 发的改动看起来更有道理，其实离真相更远徐浩然（T1）、Vicco_Li（T1 前 13 发）

另一个共性：全组的思维起点几乎一样——T1 都从"分段/分块"起步，T2 都从样例给的 1 3 2 4 起步，T4 都从 a₁+a₂ 起步。这说明他们有共同的训练痕迹；但也正因为同源，共同的错误也同源（同一道题上 4 个人不约而同地交了 a1+a2、2 个人不约而同地栽在 int 溢出）。

1. 逐人思路轨迹

张恩博

U79 · 220 分（并列第 1）· 24 次提交 · 跨度 1h52m换模型型

T1 超常班叠叠乐 —— 6 发 / 92 分钟

14:46–14:55 · 3 发模型 ①「把缺口按 0 切成若干段，答案是每段峰值之和」
14:52 / 14:55两次提交只把 cin 换成 scanf、加了个换行 —— 模型没动，两次仍然 0 分
14:55–15:54 · 冷冻 59 分钟转去打 T2
15:54回来只把上一发的换行去掉，又是 0 分 —— 说明他此时并不知道错在哪
16:15 · 换模型模型 ②「首元素补 max，其余累加相邻下降量」（差分思想），但漏了尾部
16:19 · 补 2 行 → AC补上 diff[n+1]=maxn-arr[n] 并把循环跑到 n+1；耗时从 184ms 跳到 2965ms（数组换成 ll）

T2 一般凹凸序列 —— 10 发 / 30 分钟

15:19–15:24 · 4 发模型「1/50001/2 交替铺 + 尾部填大数」，但尾部写的是 cout<<1e9——1e9 是 double 字面量，输出成 1e+09，直接 0 分
15:20其中一发是原样重交（逐字节相同）
15:26 · 65 分终于发现不是数值问题：循环边界改成 n-k-1、尾部下标从 0 起
15:29 · 95 分尾部多补一个 <<b<<
15:32 / 15:47 / 15:47补 n<3、k==0 两个边界分支，中间还反复调空格
15:50 · AC把多余输出删掉

T4 Sanhai 群岛的“优质”桥梁 —— 8 发 / 9 分钟

16:30–16:33 · 6 发没有模型，纯猜公式：Σ|相邻差| → arr[2] → 2·min(a1,a2) → a1+a2（这一发拿到 20 分，是白送的 n=3 子任务）
16:36:42 · 换模型 ★模型 ③「奇偶性分类」：奇数取 a[i]、偶数取 a[i]-1 累加 —— 这就是正解的核心，但最后多写了个 +1，0 分
16:38:41 · 停手只把 ans+1 改成 ans，仍是 0 分，此后再没提交。距结束还有 22 分钟
轨迹画像：三段式，每段都靠"换模型"过关，但换完不做样例验算。T1 的模型 ① 从 14:46 一直带到 15:54（68 分钟），这期间他改的全是输入输出；T4 是全组唯一一次真正摸到 T4 正解核心的人，可惜只差 2 个字符就收手了。他的问题不是想不出来，是不肯多花 5 分钟验一遍。

Vicco_Li

U78 · 220 分（并列第 1）· 25 次提交 · 跨度 2h12m增量推广 + 不会调试

T1 —— 12 发 / 110 分钟（全组单题投入最大）

14:44–14:57 · 6 发模型 ①「遇到 max 就把本段最大缺口累加一次」——6 发全部在这一个模型里换哨兵（-1→-1e9）、换符号（max/min）、把 int 改 long long、末尾补 a[n+1]。相似度全部 >0.97，模型一次没换
14:57–15:43 · 冷却 46 分钟转去打 T2
15:43回来把哨兵换成 -1e18
15:48 / 16:05 / 16:09 · ★连续三次提交逐字节完全相同的代码（16:09 那次只改了空白）——这是"再交一次看会不会变"的典型
16:19再换一次哨兵方向（1e18 + min），仍在同一个模型里
16:35 · 推倒重来 → AC模型 ②「逐位比较：首位补 maxv-a[1]，其后累加下降量」——一次就过，耗时 2634ms/70MiB

T2 —— 7 发 / 21 分钟（他全场效率最高的一题）

15:18 · 40 分模型「3 + (k−1) 个 2 + 0 + 一串 2」——靠数值构造，能拿部分分
15:22–15:27 · 换模型改成标准的 1 3 2 4 循环 + 尾部复制
15:31 / 15:32 · 70 分补 n-k-2==0 与 <0 两个分支
15:36 · 45 分（退步）把尾部填 -1，分数反而掉了
15:39 · AC换成 lst±1：按倒数第二个数与最后一个数的大小关系选方向，保证接缝处的三元组必坏——全组对"接缝"理解最深的一份

T4 —— 5 发 / 9 分钟

16:44 · 20 分只写 n==3 分支输出 a1+a2（白送分）
16:50:56 · 换模型 ★改写成 DFS 回溯：在链上枚举所有走法、用容量数组记录每条桥的剩余次数求最长 —— 模型其实是正解的模型，但链上要的是奇偶性分类，不是枚举
16:50–16:53 · 4 发全 RE在回溯恢复上反复犯错（--b[u] 写成 --b[u-1]，然后加了又删 ++b[u]），内存 251MB
轨迹画像：他的模型切换次数是全组最少的（T1 只在第 19 发换过一次），但一旦换对就能过。真正的短板是调试方法论缺失——原样重交 3 次、在哨兵值上打转 6 次。T4 那发 DFS 说明他的直觉其实好于其他人（他想到"这是一次行走 + 每条桥有次数预算"），只是没走到"奇偶性"这一步。

Guagua111

U81 · 220 分（并列第 1）· 15 次提交 · 跨度 1h53m模型早到、参数慢磨

T2 —— 5 发 / 17 分钟（T2 组里效率最高）

15:03模型 ①「1 3 2 4 循环 + 尾部 i+4」
15:08 · ★ 探针提交把正式代码整段注释掉，只交一句 cout<<-1;——全组唯一一个用"最小提交"去试探判题行为的人
15:13 · 45 分恢复正式代码，尾部统一填 4
15:18 · 换模型改成 a[4]={4,1,3,2} 查表 + 记录末值复制（判题机报 CE）
15:20 · 原样重交 → AC那次 CE 是判题机侧的，代码没问题

T1 —— 3 发 / 62 秒（模型一次到位，死在实现）

16:08:30 · 10 分模型一次就写对（缺口数组取正差分和），但 ans 是 int → 溢出
16:09:03改成 #define int long long 时，手一抖把整个计算循环删空了 → 0 分
16:09:32 · AC51 秒后把循环补回来

T3 —— 4 发 / 21 分钟（全组唯一把参数链条补齐的人）

16:35 · 死循环模型「键 (y±t) + 镜像插入到 BIT」已经对了，但 BIT 从 0 下标起步，lowbit(0)=0 → 死循环 TLE
16:47下标统一 +1 起（死循环解掉），模数仍是 2n
16:55 · 关键一步模数改成 p=2(n-1) —— 这一步直接对应"走廊两端是 0 和 N−1 的折返"
16:56写出折叠函数 f(x)（取模 + 翻折），并把镜像也过一遍 f —— 离正解只差"查询区间跨 0 时拆成两段"

T4 —— 3 发 / 47 秒

16:53–16:54在 min(a1,a2) → max(a1,a2) → a1+min(a1,a2) 之间摇摆三发拿 20 分
轨迹画像：全组建模能力最稳、参数收敛最有序的一位。T2 的探针提交说明他懂"控制变量"；T3 四发是一条单调收敛的链条（下标 → 模数 → 折叠 → 镜像），每一发都在缩小包围圈。他的分丢在实现细节（溢出、手抖、死循环）而不是思路上——这类人只要配一次 code review 就能上一个大台阶。

crkr

U82 · 220 分（并列第 1）· 14 次提交 · 跨度 2h一发定生死

T1 —— 9 发 / 71 分钟（算法第 2 发就对，剩下全在跟类型和环境搏斗）

14:57模型 ①「从后往前差分取 |Δ|」
15:02 · 换模型模型 ②「缺口数组再取正差分和」——第二发思路就已经完全正确，但 ans 是 int → 溢出
16:01:05 / 16:01:17 / 16:01:41 · ★连交三发都被判「题目配置错误。找不到输入文件 1.in。」——36 秒内白交三次，不是他的问题
16:03–16:07 · 10 分重写（首元素补 max、补 a[n+1]、改判断条件），拿到 10 分
16:08:43 · AC唯一的实质改动：把 int a[] 换成 ll a[]。相似度 0.93，其余全是环境故障

T2 —— 3 发 / 14 分钟（效率最高）

15:13 · 5 分模型「1 3 2 4 循环 + i-=k 后查表」
15:22重写成两段循环
15:26 · AC边界改成 n-k

T3 —— 1 发 / 4 毫秒

16:32:36 · 唯一一发模型（用大偏移 1e8 把 W/E 坐标分开 + 镜像查询）其实已接近正解，但 scanf 少读一个参数 t，加上 2×100200005 个 long long ≈ 1.6GB 静态数组 → 4ms 就 RE。此后再没提交过 T3

T4 —— 1 发 / 终点前 2 分钟

16:57:50直接 printf("%lld", a[1]+a[2]) → 20 分收工
轨迹画像：能力不差、试错意愿全组最低。T2 三发拿下、T1 算法第二发就对、T3 的建模方向接近正解——但他对每道题的尝试次数都极少（T3、T4 各只有 1 发），而且提交前不做本地自测（少读一个参数、1.6GB 数组、int 溢出，这三件事只要在本地跑一次样例就全暴露）。他的问题不是不会，是"交出去再说"。

钟如杉

U80 · 100 分（第 5）· 4 次提交 · 跨度 22 分钟先保底再跳跃

T2 —— 4 发 / 22 分钟，全程只碰这一题

14:57只写 k==0 与 k==n-2 两种极端情况（把子任务当全题交）
15:02k==0 分支改成 1 3 2 4 循环
15:15 · 判题机 CE代码本身没问题，同一时间窗另有 4 人 CE
15:19:48 · AC直接跳到最终的完整构造（前 k+1 个同值 + 其余走 1 3 2 4 循环），一次到位
轨迹画像：全组提交最少的人（4 次，别人平均 12 次）。前两发是"安全牌"（先把两个极端情况写对），第 4 发是一次完整的思维跳跃。他没在 T1/T3/T4 上浪费一次提交——要么是时间没到，要么是他清楚自己做不出来就不碰。这种"低提交量 + 高完成度"的模式，在只要求保分时很划算，但遇到需要试错的题就会吃亏。

NaiLong

U99 · 100 分（第 5）· 6 次提交 · 跨度 1h40m一次写对、也不折腾

T2 —— 5 发 / 6 分钟（其中 3 发是判题机的问题）

15:14:44手工状态机推 1 3 2 4——第一发代码就是对的
15:15:54 / 15:16:54 / 15:18:26 · ★同一份代码（后 4 发 MD5 完全一致）被判 Compile Error ×3——判题机编译服务不稳定
15:20:25 · AC第三次提交同一份代码就过了

T4 —— 1 发

16:55:02cout<<n+6;——明确的放弃式提交
轨迹画像：思路一次成型，不回头、不验证。这场他只认真做了 1 道题，另一道题用一个猜测收尾。从他账号历史（全站仅 6 条记录）看，他平时也几乎不刷题——这类人不是"做题状态差"，是"参与度低"。

徐浩然

U83 · 95 分（第 7，全场唯一没到 100）· 6 次提交 · 跨度 1h09m在错模型里做增量推广

T1 —— 4 发 / 15 分钟（4 发从未触及真正的错因）

14:46:54 · 全场第一发模型 ①「把缺口按 0 切成两段，答案取两段最大值之和」
14:51:34 · ★ 关键错误他把模型 ① 推广成"按 0 切成 m 段、段内取最大、再求和"——看起来更一般、更"对"，但错因完全一样（同一个段里出现两次高峰仍然只算一次）。这不是修 bug，是把错模型包装得更像对的
14:52:47只加了快读快写
15:01:00 · 收尾把 b[i]=mx-a[i] 改成 abs(mx-a[i])——b 本来就非负，完全等价，什么也没改。之后放弃 T1

T2 —— 2 发 / 22 分钟

15:34 · 5 分朴素版：1 3 2 4 循环 + 余下直接输出 i-3
15:56 · 95 分换成 a[] 循环 + j 记录末值复制——思路和其它 7 人完全一致且正确。败在实现：while(i<=n-k-3) 一次吐 4 个数，当 n-k 恰好是 4 的倍数时余数段被整段跳过，j 保持全局初值 0，尾部变成 0
轨迹画像：全场唯一没上 100 的人，也是思维轨迹最需要警惕的一个样本。他的 T1 四发相似度都 >0.95——改了 4 次，一次都没碰到"多峰"这个真正的错误点；第 2 发的"推广"反而让他更自信。T2 则相反：思路对的，95 分只是因为"每 4 个一吐"的写法把余数段吃掉了。一句话：他的思路不错、验证习惯为零。如果 T1 第 2 发他不是写"更通用的分段"，而是回头手算一遍样例 2（3 1 2 → 2），这场名次会完全不同。

2. 轨迹层面的三条总结

  1. 决定分数的是「换模型的时机」，不是改了多少次。95 次提交里只有 17 次属于结构性改动或重写， 而每一次分数跃升（张恩博 T1 第 15 发、Vicco_Li T1 第 19 发、Guagua111 T2 第 4 发、钟如杉 T2 第 4 发） 都发生在这 17 次里。其余 78 次几乎全是在同一个模型里调数值。
  2. 三种轨迹形态需要三种不同的干预。
    • 换模型型（张恩博、钟如杉）：缺的是「换完模型验一遍样例」的习惯——张恩博 T4 只差 2 个字符、T1 漏了尾部各一次。
    • 磨参数型（crkr、Guagua111 的 T1）：缺的是本地自测——少读一个参数、1.6GB 数组、int 溢出，三件事跑一次样例就全暴露。
    • 增量推广型（徐浩然、Vicco_Li 的 T1）：缺的是「回头质疑模型本身」。他们把错误模型改得越来越「通用」，越改越自信。
  3. 共同的短板是验证环节整体缺失。T2 上 8 人交了 37 发，分数是「调」出来的； T4 上有 4 个人拿到白送的 20 分后就停住了——没有一个人回头问「为什么 n=3 恰好是 a₁+a₂」。 那一步需要的是解释现象，而不是再试一个公式。

完整时间线

7 名学生比赛当天共 94 次提交，另有 1 次赛后补题（带标记）。「赛中」列是距开赛（14:30）的分钟数。

#时刻赛中选手题判定这一发在干什么
114:46:45+16′张恩博T10 Wrong Answer开局就交：把「还差多少层」按 0 切成两段，答案取两段各自最大值之和 —— 错模型（峰一多就漏算）
214:52:13+22′张恩博T10 Wrong Answer把 cin 换 scanf、ans 显式初始化，逻辑一行没动
314:55:00+25′张恩博T10 Wrong Answer只加了个换行，继续没碰逻辑
415:19:52+49′张恩博T20 Wrong Answer转 T2：1/50001/2 交替铺，尾部 cout<<1e9 —— 1e9 是 double 字面量，输出成 1e+09，直接 0 分
515:20:15+50′张恩博T20 Wrong Answer★ 与上一发逐字节相同，原样重交
615:21:18+51′张恩博T20 Wrong Answer把 1e9 写成 1000000000
715:24:46+54′张恩博T20 Wrong Answer改成 1000000000-1（在猜数值上限）
815:26:38+56′张恩博T265 Wrong Answer循环边界改 n-k-1、尾部下标从 0 起 —— 第一次拿到分，65
915:29:03+59′张恩博T295 Wrong Answer尾部补一个 <<b<< —— 95
1015:32:20+62′张恩博T295 Wrong Answer补 if(n<3) 输出 -1 的边界分支
1115:47:33+77′张恩博T295 Wrong Answer补 if(k==0) 分支，但尾部多打了一个数
1215:47:55+77′张恩博T295 Wrong Answer把多余空格去掉再交一次
1315:50:16+80′张恩博T2100 Accepted去掉多余输出 → AC（T2 共 10 发、30 分钟）
1415:54:28+84′张恩博T10 Wrong Answer回 T1：只把换行去掉
1516:15:56+105′张恩博T10 Wrong Answer推倒重来，换成「差分取正和」的正确思路，但漏了首元素和尾元素
1616:19:01+109′张恩博T1100 Accepted补上 diff[n+1]=maxn-arr[n] → AC（T1 共 6 发、跨 92 分钟）
1716:30:16+120′张恩博T40 Wrong AnswerT4 首交：Σ|相邻差|
1816:30:31+120′张恩博T40 Wrong Answer16 秒后重交一发（同样思路）
1916:31:55+121′张恩博T40 Wrong Answer输出换成 arr[2]
2016:32:40+122′张恩博T40 Wrong Answer换成 2*min(arr[2],arr[3])
2116:32:56+122′张恩博T40 Wrong Answer只把 2 改成 2LL（改类型）
2216:33:44+123′张恩博T420 Wrong Answer换成 arr[2]+arr[3] → 20 分
2316:36:42+126′张恩博T40 Wrong Answer★ 转向奇偶性：奇数取 a[i]、偶数取 a[i]-1，然后 ans+1
2416:38:41+128′张恩博T40 Wrong Answer去掉 +1 → 仍是 0。16:38 停手，此时距比赛结束还有 22 分钟
2514:44:30+14′Vicco_LiT10 Wrong AnswerT1 首交：「遇到 max 就把当前段的最大缺口累加一次」的段模型（错）
2614:48:45+18′Vicco_LiT10 Wrong Answer哨兵 -1e9 + 加条件 a[i-1]!=maxv，同一模型
2714:49:48+19′Vicco_LiT10 Wrong Answer把 n 从 int 改成 long long（与本题错误无关）
2814:50:51+20′Vicco_LiT10 Wrong Answer改成累加 nwmaxv、缺口改存 maxv-a[i]，继续试参数
2914:53:05+23′Vicco_LiT10 Wrong Answer把 max 换 min、哨兵换 1e9（方向反了）
3014:57:44+27′Vicco_LiT10 Wrong Answer末尾补 a[n+1]=maxv、重写循环 —— 同一模型第 6 次，仍 0 分
3115:18:38+48′Vicco_LiT240 Wrong Answer转 T2：首交，构造「3 + (k-1)个2 + 0 + 一串2」→ 40 分
3215:22:01+52′Vicco_LiT20 Wrong Answer换成 1 3 2 4 循环 → 0
3315:27:59+57′Vicco_LiT20 Wrong Answer边界改成 n-k → 0
3415:31:02+61′Vicco_LiT270 Wrong Answer改成 a[] 查表取值 → 70
3515:32:23+62′Vicco_LiT270 Wrong Answer补 n-k-2==0 与 <0 两个分支 → 70
3615:36:25+66′Vicco_LiT245 Wrong Answer尾部填 -1 → 45（更差，退回）
3715:39:49+69′Vicco_LiT2100 Accepted尾部改成 lst±1（按倒数第二个数与最后一个数的大小选方向，保证接口必坏）→ AC。T2 共 7 发、21 分钟
3815:43:09+73′Vicco_LiT10 Wrong Answer重开 T1：换哨兵 -1e18
3915:48:43+78′Vicco_LiT10 Wrong Answer★ 与上一发逐字节相同，原样重交
4016:05:43+95′Vicco_LiT10 Wrong Answer★ 与上一发逐字节相同，原样重交
4116:09:01+99′Vicco_LiT10 Wrong Answer★ 与上一发逐字节相同，原样重交（三连空转，共 21 分钟）
4216:19:45+109′Vicco_LiT10 Wrong Answer再换哨兵方向（1e18/min）
4316:35:02+125′Vicco_LiT1100 Accepted彻底换成正解写法（逐位比较，首元素补 maxv-a[1]）→ AC。T1 共 12 发、跨 110 分钟
4416:44:11+134′Vicco_LiT420 Wrong AnswerT4：只写 n==3 分支（a1+a2）→ 20
4516:50:56+140′Vicco_LiT420 Runtime Error★ 改交 DFS 回溯：在链上枚举所有走法求最长，模型其实是对的，但指数级、吃到 251MB → RE
4616:51:24+141′Vicco_LiT420 Runtime Error修手误 --b[u] → --b[u-1]
4716:51:54+141′Vicco_LiT420 Runtime Error补上回溯恢复 ++b[u]
4816:53:15+143′Vicco_LiT420 Runtime Error又把回溯恢复删掉、memcpy 换手写循环
4916:56:28+146′Vicco_LiT50 Time ExceededT5 交一发 O(len²) 枚举 gcd → TLE；赛后 19:10 又补了一发 T3，仍 WA
5019:10:24+280′ 赛后补题Vicco_LiT30 Wrong Answer
5115:03:42+33′Guagua111T20 Wrong AnswerT2 首交：1 3 2 4 循环 + 尾部 i+4（越界构造）
5215:08:50+38′Guagua111T20 Wrong Answer★ 探针提交：把正式代码整段注释掉，只交一句 cout<<-1;
5315:13:40+43′Guagua111T245 Wrong Answer恢复正式代码，尾部统一填 4 → 45
5415:18:28+48′Guagua111T20 Compile Error重写成 a[4]={4,1,3,2} + 末值复制 —— 判题机报 Compile Error
5515:20:02+50′Guagua111T2100 Accepted★ 与上一发完全相同，重交 → AC（那次 CE 是判题机侧的）
5616:08:30+98′Guagua111T110 Wrong AnswerT1 首交：思路完全正确，但 ans 是 int → 溢出，只拿 10 分
5716:09:03+99′Guagua111T10 Wrong Answer加 #define int long long，但手抖把整个计算循环删空了 → 0
5816:09:32+99′Guagua111T1100 Accepted51 秒后补回循环 → AC
5916:35:12+125′Guagua111T30 Time ExceededT3 首交：BIT 从 0 下标起步 → lowbit(0)=0 死循环 TLE
6016:47:30+137′Guagua111T30 Wrong Answer下标统一 +1 起（死循环解掉），模数仍是 2n
6116:53:28+143′Guagua111T40 Wrong Answer模数换成 p=2(n-1)（关键一步），但区间没做折叠
6216:53:44+143′Guagua111T40 Wrong Answer写出折叠函数 f(x)（取模+翻折+镜像）→ 仍 WA（离正解只差区间跨 0 的处理）
6316:54:15+144′Guagua111T420 Wrong AnswerT4：min(a1,a2)
6416:55:33+145′Guagua111T30 Wrong Answer改 max(a1,a2)
6516:56:40+146′Guagua111T30 Wrong Answer改成 max(a1+min(a1,a2), a2+min(a1,a2))，化简即 a1+a2 → 20 分，收工
6614:57:08+27′crkrT10 Wrong AnswerT1 首交：套刷题模板，从后往前差分取 |Δ|
6715:02:27+32′crkrT10 Wrong Answer改成缺口数组取正差分和（思路已经对了）但 int 溢出 → 0
6815:13:04+43′crkrT25 Wrong AnswerT2 首交（该记录页无代码，判定 5 分）
6915:22:40+52′crkrT20 Wrong AnswerT2 重写：1 3 2 4 循环 + i-=k 后查表
7015:26:40+56′crkrT2100 Accepted循环拆两段、边界改 n-k → AC
7116:01:05+91′crkrT10 Format Error★ 判题机报「题目配置错误。找不到输入文件 1.in。」—— 环境故障，白交
7216:01:17+91′crkrT10 Format Error★ 同上
7316:01:41+91′crkrT10 Format Error★ 同上（三连撞上环境故障）
7416:03:48+93′crkrT10 Wrong Answer重写：首元素补 max，但循环写成 i<n 且条件写错 → 0
7516:04:58+94′crkrT110 Wrong Answer条件改成 a[i]-a[i+1]>0 → 10
7616:07:22+97′crkrT110 Wrong Answer补上 a[n+1]（首尾都填 max）→ 10（还差类型）
7716:08:43+98′crkrT1100 Accepted把数组与 ans 从 int 换成 ll → AC。整场 T1 唯一的实质改动就是加宽类型
7816:32:36+122′crkrT30 Runtime ErrorT3 唯一一发：2×1.6GB 静态数组 + scanf 少读一个 t → RE（4ms 就挂）
7916:57:50+147′crkrT420 Wrong Answer收比赛前最后一发 T4：a[1]+a[2] → 20 分
8014:57:33+27′钟如杉T20 Wrong AnswerT2 首交：只处理 k==0 与 k==n-2 两种极端
8115:02:58+32′钟如杉T20 Wrong Answerk==0 分支改成 1 3 2 4 循环
8215:15:08+45′钟如杉T20 Compile Error★ 判题机报 Compile Error（代码本身没问题，同一时间窗另有 4 人 CE）
8315:19:48+49′钟如杉T2100 Accepted直接换成最终正确形态：前 k+1 个同值 + 其余走 1 3 2 4 循环 → AC
8415:14:44+44′NaiLongT20 Wrong AnswerT2 首交（记录页只显示判题机提示，无代码）
8515:15:54+45′NaiLongT20 Compile Error★ 与后一发逐字节相同 → Compile Error
8615:16:54+46′NaiLongT20 Compile Error手工状态机推 1 3 2 4，尾部复制末值
8715:18:26+48′NaiLongT20 Compile Error★ 与上一发逐字节相同 → 又是 Compile Error
8815:20:25+50′NaiLongT2100 Accepted★ 同一份代码第 3 次提交 → AC。代码从头到尾没问题，是判题机编译服务不稳定
8916:55:02+145′NaiLongT40 Wrong AnswerT4：cout<<n+6; —— 放弃式提交
9014:46:54+16′徐浩然T10 Wrong Answer全场第一发（14:46:54）：按 0 切成两段，答案取两段最大值之和
9114:51:34+21′徐浩然T10 Wrong Answer把两段推广成 m 段：遇 0 开新段、段内取最大、再求和 —— 仍是同一个错模型
9214:52:47+22′徐浩然T10 Wrong Answer只加了快读快写，逻辑没动
9315:01:00+31′徐浩然T10 Wrong Answer把 b[i]=mx-a[i] 改成 abs(mx-a[i])（b 本来就非负，无意义）→ 之后放弃 T1
9415:34:24+64′徐浩然T25 Wrong AnswerT2 首交：1 3 2 4 循环、余下直接输出 i-3 → 5 分
9515:56:26+86′徐浩然T295 Wrong Answer重写成 a[] 循环 + j 记录末值复制 → 95 分（余数段被 4 整除时整段跳过）

T1 超常班叠叠乐（P2713）

题意：一排 n 个格子，第 i 个格子已经堆了 aᵢ 层人。每次可以选一段连续区间整体 +1， 问最少多少次操作能让所有格子一样高（显然要和最高的那个一样）。

正解骨架：把「还差多少层」记作轮廓 b[i] = max − a[i] ≥ 0， 一次操作等价于在轮廓上放一条高度 1 的水平线段，于是答案就是轮廓的「上升量之和」：

答案 = Σ max(0, b[i] − b[i−1])   （b[0] = 0）
     = (max − a[1]) + Σ max(0, a[i−1] − a[i])

数据范围：n ≤ 10⁷，aᵢ ≤ 10⁹ —— 答案可达 10¹⁶，必须开 64 位。 子任务：n≤10 得 10 分、n≤10³ 得 20 分、n≤10⁵ 得 30 分、n≤10⁷ 得 40 分。

这次踩的坑：两人拿到「逻辑正确但 ans 是 int」的 10 分； 一个人错在模型本身（把答案当成「按 0 切段后每段最大值之和」，多峰时漏算）。

T2 一般凹凸序列（P2758）

题意：输出一个长度 n、值在 [0,10⁹] 的整数数列，使 n−2 个连续三元组中恰好 n−k−2 个是 「凹凸三元组」（三个数两两不等且中间那个最大或最小）；无解输出 −1。

正解骨架：先把前 n−k 个位置铺成完美凹凸序列 1,3,2,4,1,3,2,4,… （相邻差的符号严格交替，每个三元组都合法），再让尾部 k 个位置「变平」（等于前一个值）。 这样只有「交替段与平段的接缝」那一个三元组报废，其余 k−1 个坏三元组落在平段内部，坏数恰好 = k。

注意：题目里的 −1 分支在 0 ≤ k ≤ n−2 范围内不可达（k=0 用交替序列，k=n−2 用全等序列）， 是本题唯一的干扰项。

这次踩的坑：8 人交了 37 发，分数是「调」出来的；cout<<1e9 会输出 1e+09； 一个人卡在「每 4 个一次性输出」导致余数段被跳过。

T3 超常班的走廊巡逻（P2662）

题意：0..N−1 号教室的走廊，学员「能走则走、不能走则原地掉头」。 指令 W t y z（时刻 t 从 y 向西放 z 人）、E t y z（向东）、Q t y z （问时刻 t 教室 [y,z) 内总人数）。t 单调递增。

正解骨架（三步，缺一不可）：

数据范围：N ≤ 2×10⁵，Q ≤ 8×10⁴，t ≤ 10⁸。这次踩的坑：树状数组从 0 下标起步导致 lowbit(0)=0 死循环；模数写成 2n（应为 2(N−1)）； 东西方向的键符号写反；静态数组开了 1.6GB。

T4 Sanhai 群岛的“优质”桥梁（P2616）

题意：n 个岛排成一条链，第 i 座桥最多通行 aᵢ 次。可以从任意岛出发来回走， 求最多能通过多少次桥。

正解骨架：把一次行走看成链上的游走，则——起点 s 到终点 t 之间的桥一定被走奇数次， 其余被走偶数次；因此路上的桥取「≤aᵢ 的最大奇数」，路外的桥取「≤aᵢ 的最大偶数」， 再保证被使用的桥连成一段区间即可。

为什么 n=3 时答案恰好是 a₁+a₂：两条桥无论奇偶怎么搭配，总能凑出「一奇一偶」的分配 （一奇一偶、两奇、两偶三种情况都是 a₁+a₂ 最大），所以 20% 的子任务可以直接白拿。

这次踩的坑：4 人拿到 20 分后就停手，没有人把这条路走到「奇偶性分类」； 另有一人改写成 DFS 枚举所有走法（模型对、复杂度错），4 发全部 RE。

附录 A · 判题机异常记录（复盘时应剔除）

时刻选手题判定说明
15:15:08钟如杉T2Compile Error代码本身没问题；同一窗口另有 4 次 CE
15:15:54 / 15:16:54 / 15:18:26NaiLongT2CE ×3连续 3 发提交逐字节相同的代码，第 3 次就 AC
15:18:28Guagua111T2Compile Error2 分钟后同一份代码 AC
16:01:05 / 16:01:17 / 16:01:41crkrT1Format Error ×3「题目配置错误。找不到输入文件 1.in。」

附录 B · 统计口径

项目说明
统计范围7 名参赛学生：比赛当天 94 次提交 + 赛后补题 1 次（Vicco_Li 于 19:10 又交了一发 T3）。
「提交次数」包含判题机故障导致的失败提交；做「提交效率」分析时建议剔除附录 A 里的 8 次。
「改动幅度」同一名选手同一道题，本次提交与上一次提交的代码相似度（去掉全部空白后做字符级比对，1.000 表示完全相同或仅空白差异）。
「改动类型」逐字节相同 = 原样重交；仅空白不同 = 仅空白/缩进；相似度 ≥0.8 = 局部修补；0.55–0.8 = 结构性改动；<0.55 = 重写。
「语义标签」对变更片段做正则归类：类型 / 常量 / 比较边界 / 模运算 / 输出 / 下标 / 控制流。
数据来源比赛成绩表、题目页与提交记录页；所有代码均在本地用 g++ 重新编译并对拍验证过。