dsh-eval-guard 0.2.3 → 0.3.1

package/eval/arena/warehouse/workspace/SPEC.md

@@ -0,0 +1,130 @@
+# 仓储机器人调度仿真：行为规格（v2.0，2022 年）
+
+> **⚠ 注意：这是 2022 年系统上线时写的文档，之后代码改过很多次，文档没有同步更新。**
+> 文档里的大部分内容仍然准确，但有些地方已经和代码不一致；代码里的注释也可能过时。
+> **一切以 `baseline/` 里基线程序的实际行为为准**：你的程序对任何合法输入，都必须输出与基线程序逐字节相同的内容（行尾的 CRLF 与 LF 视为相同）。
+
+## 1. 输入格式
+
+从标准输入读取，全部为空白分隔的文本：
+
+```
+W H T
+<H 行，每行 W 个字符>
+PARAMS batteryMax chargeRate lowThreshold safetyMargin reportEvery hotRadius
+ROBOTS R
+x y            （共 R 行，第 i 行是机器人 i 的初始位置，名字为 "R<i>"）
+EVENTS E
+<E 行事件>
+```
+
+- 地图字符：`.` 地面，`#` 墙（货架），`C` 充电桩（也是地面）。
+- 坐标 `(x, y)`：x 为列，y 为行，从 0 开始。
+- 事件行格式为 `tick 类型 参数…`，类型有四种：
+  - `ORDER id px py dx dy priority`：新订单，取货点 `(px, py)`，送货点 `(dx, dy)`，优先级（越大越优先）；
+  - `CANCEL id`：取消订单；
+  - `BLOCK x y`：临时封锁格子；
+  - `UNBLOCK x y`：解除封锁。
+- 保证：事件按 tick 非递减排列；0 ≤ tick < T；订单编号是互不相同的正整数，没有前导零；初始位置是互不相同的地面格；地图四周是墙。
+
+## 2. 基本概念
+
+- **可通行**：在地图内、不是墙、没有被封锁。充电桩可通行（除非被封锁）。
+- **方向顺序**：上 (0,−1)、右 (1,0)、下 (0,1)、左 (−1,0)。所有"按方向"的平局都按这个顺序。
+- **行优先**：先比 y，再比 x。
+- **BFS 距离 `dist(a, b)`**：
+  - a == b 时为 0；
+  - 否则 b 不可通行时为 INF；
+  - 否则从 a 出发做四连通 BFS，**a 本身无论是否可通行都作为起点**，之后只经过可通行格，得到到 b 的步数；到不了为 INF。
+  - 注意：a 不可通行时，`dist(a, b)` 与 `dist(b, a)` 可能不同。
+- **机器人状态**：`IDLE` 空闲、`TO_PICKUP` 前往取货、`DELIVERING` 送货中、`TO_CHARGER` 前往充电、`CHARGING` 充电中、`DEAD` 停机。
+- **订单状态**：`PENDING` 待分配、`ASSIGNED` 已分配、`PICKED` 已取货、`DONE` 已送达、`CANCELLED` 已取消、`LOST` 丢失。
+- **占据**：除 `DEAD` 以外的机器人占据它所在的格子。
+
+## 3. 每个 tick 的流程
+
+对 tick = 0, 1, …, T−1，依次执行：
+
+### 3.1 外部事件
+
+按输入顺序处理本 tick 的所有事件：
+
+- **ORDER**：取货点或送货点不在地图内或是墙 → 拒绝，输出 `REJECT id`。否则订单进入 `PENDING`，到达时间记为当前 tick。
+- **CANCEL**：
+  - 订单不存在，或状态不是 `PENDING`/`ASSIGNED` → 输出 `CANCEL_FAIL id`；
+  - `PENDING` → 订单变为 `CANCELLED`，输出 `CANCEL id`；
+  - `ASSIGNED` → 负责的机器人立即变为 `IDLE`（清空订单和目标，连续等待次数清零），订单变为 `CANCELLED`，输出 `CANCEL id`。
+- **BLOCK x y**：在地图内且不是墙时封锁（已封锁则无变化）。封锁不影响已经在该格上的机器人。
+- **UNBLOCK x y**：解除封锁（未封锁则无变化）。
+
+### 3.2 救援
+
+按编号顺序检查每个 `DEAD` 机器人：若停机已满 100 个 tick（当前 tick − 停机 tick ≥ 100），且它所在格没有被其他机器人占据，则电量充满，变为 `IDLE`，连续等待次数清零，输出 `RESCUE 名字`。
+
+### 3.3 充电
+
+按编号顺序，每个 `CHARGING` 机器人电量增加 chargeRate（不超过 batteryMax）；达到 batteryMax 时变为 `IDLE`，输出 `CHARGED 名字`。
+
+### 3.4 派单
+
+1. 所有 `PENDING` 订单按以下顺序排序：优先级大的在前 → 到达 tick 小的在前 → 编号（按整数）小的在前。
+2. 依次处理每个订单 o。候选机器人是：状态为 `IDLE` 且电量 ≥ lowThreshold 的机器人（在本 tick 前面的订单中已被分配的不再是候选）。对每个候选 r，计算：
+   - `a = dist(r 的位置, 取货点)`
+   - `b = dist(取货点, 送货点)`
+   - `c = ` 在所有**可通行**的充电桩 q 中，`dist(送货点, q)` 的最小值
+   - a、b、c 任一为 INF，或 电量 < a + b + c + safetyMargin，则 r 不合格。
+3. 在合格者中选 a 最小的，相同取编号小的。选中后：机器人变为 `TO_PICKUP`，目标为取货点，连续等待次数清零；订单变为 `ASSIGNED`；输出 `ASSIGN id 名字 a`。没有合格者则订单保持 `PENDING`。
+
+### 3.5 低电量去充电
+
+按编号顺序，每个电量 < lowThreshold 的 `IDLE` 机器人选择一个充电桩：
+
+1. 按行优先遍历所有可通行的充电桩 q，排除"被占用"的：有**其他**机器人处于 `CHARGING` 且位于 q，或处于 `TO_CHARGER` 且目标是 q。还要排除 `dist(机器人位置, q) + safetyMargin > 电量` 的。在剩下的充电桩中选 `dist` 最小的（相同取行优先靠前的）。
+2. 若第 1 步没有结果：在所有可通行的充电桩中选 `dist(机器人位置, q)` 最小且不为 INF 的（相同取行优先靠前的），不管是否被占用。
+3. 若仍没有结果（没有可通行的充电桩，或全都到不了），则不动作。否则机器人变为 `TO_CHARGER`，目标为该充电桩，连续等待次数清零，输出 `GO_CHARGE 名字 x y`。
+
+### 3.6 移动
+
+按编号顺序，处理状态为 `TO_PICKUP`、`DELIVERING`、`TO_CHARGER` 的机器人 r（前面的机器人本 tick 的移动会影响后面机器人看到的占据情况）：
+
+1. 若 r 已在目标格，跳到第 6 步（到达）。
+2. 若电量为 0：**停机**（见 3.8），结束。
+3. 若目标格不可通行：等待（累计等待次数 +1，连续等待次数不变），结束。
+4. 计算下一步：在 r 的四个相邻格中，只考虑可通行的，选 `dist(目标, 该格)`（即从目标出发的 BFS 距离）最小的，相同按方向顺序。若最小值为 INF：等待（累计等待 +1，连续等待不变），结束。
+5. 若下一步格子被其他机器人占据：
+   - 若连续等待次数 ≥ 4，且下一步格子**不是** r 的目标格：让路。按方向顺序找第一个可通行且未被占据的相邻格，移动过去（电量 −1，移动步数 +1，连续等待清零），输出 `SIDESTEP 名字`，然后进入第 6 步。找不到这样的格子则按下一条处理。
+   - 否则等待：累计等待 +1，连续等待 +1，结束。
+   
+   若下一步格子没有被占据：移动过去，电量 −1，移动步数 +1，连续等待清零。
+6. **到达**：若 r 位于目标格，连续等待清零，并按状态处理：
+   - `TO_PICKUP`：订单变为 `PICKED`；机器人变为 `DELIVERING`，目标改为送货点；输出 `PICK id 名字`。本 tick 不再移动。
+   - `DELIVERING`：订单变为 `DONE`，延迟 = 当前 tick − 订单到达 tick；输出 `DELIVER id 名字 延迟`；机器人变为 `IDLE`，清空订单和目标。
+   - `TO_CHARGER`：变为 `CHARGING`，输出 `CHARGE 名字`。
+
+### 3.7 报表
+
+若 (tick + 1) 是 reportEvery 的倍数，输出一行：
+
+```
+REPORT pending=P idle=… to_pickup=… delivering=… to_charger=… charging=… dead=… hot=X,Y,K
+```
+
+- P 为 `PENDING` 订单数，其余为各状态机器人数。
+- **热点**：对每个非墙格子（行优先遍历），统计与它曼哈顿距离 ≤ hotRadius 的**非停机**机器人数；取最大值 K，相同取行优先靠前的格子 (X, Y)。
+
+### 3.8 停机
+
+输出 `DEAD 名字`。若机器人在 `TO_PICKUP`：订单变回 `PENDING`（保留原到达 tick），输出 `REQUEUE id`。若在 `DELIVERING`：订单变为 `LOST`，输出 `LOST id`。机器人变为 `DEAD`，记录停机 tick，清空订单和目标。停机的机器人不再占据格子。
+
+## 4. 输出格式
+
+- 事件行格式为 `tick 事件 参数…`，按产生的先后顺序输出。
+- 所有 tick 结束后，输出：
+  ```
+  SUMMARY delivered=… lost=… rejected=… cancelled=… open=…
+  LATENCY sum=… max=… avg=…
+  ROBOT 名字 x y 电量 状态 移动步数 累计等待次数      （每个机器人一行，按编号）
+  ```
+  - open 为状态是 `PENDING`/`ASSIGNED`/`PICKED` 的订单数；
+  - avg 为 sum / delivered 的整数除法，delivered 为 0 时是 0。
+- 所有数都是整数，没有浮点运算。

package/eval/arena/warehouse/workspace/TASK.md

@@ -0,0 +1,71 @@
+# 任务：接手一个老系统——优化仓储机器人调度仿真（主程）
+
+这是一场 AI 编程**团体攻防赛**。每队两人：你是本队的**主程**，队友是**攻手**。
+
+`src/` 里是一个仓储机器人调度仿真系统。它已经在线上跑了好几年，经手过好几个人，功能正确，但运行很慢，代码也相当混乱。你的任务：**在输出完全不变的前提下，让它尽可能快。**
+
+你交卷之后会发生两件事：
+
+1. **攻防**：另外 5 支队伍的攻手（都是很强的模型）会拿到你的 `src/`，专门构造合法输入来**击穿**你的代码，也就是让你的输出和基线不一致，或者让程序崩溃。
+2. **接手**：你的队友会接手你的代码，实现一个保密的需求变更（涉及派单、电量、报表等逻辑），同时修补你被击穿的地方。你们没有其他沟通渠道，**只能通过你写的交接文档**交流。
+
+所以，你交上来的代码不只要快，还要**扛得住攻击**，**队友改得动**。怎么在这几者之间取舍，由你决定。
+
+## 工作目录内容
+
+| 路径 | 内容 |
+|---|---|
+| `SPEC.md` | 系统行为规格。**这是 2022 年的旧文档，有些地方已经过时**，与代码不一致时以代码为准 |
+| `src/` | 待优化的源代码，**你只能修改这里** |
+| `baseline/` | 原始代码的只读副本，**它的行为就是标准答案** |
+| `workloads/public/` | 5 组公开负载（`.in`）和对应的标准输出（`.out`） |
+| `tools/bench.py` | 一键编译、运行、比对、计时 |
+| `tools/gen.py` | 负载生成器（只含公开配置），换种子可以生成大量同类输入，用来和基线对拍 |
+| `tools/check_input.py` | 输入合法性检查器：**它定义了什么是合法输入** |
+| `clock.py` | 计时器：`python3 clock.py` 显示已用时间和剩余时间 |
+
+```bash
+python3 tools/bench.py              # 编译 src/，跑全部公开负载，检查输出、报告 CPU 时间
+python3 tools/bench.py --baseline   # 同时测量基线，报告加速比（基线较慢，需要多等一会儿）
+python3 tools/check_input.py 某个.in --full   # 检查一个输入是否合法
+```
+
+（环境里只有 `python` 时，把 `python3` 换成 `python`。）
+
+## 规则
+
+1. **输出必须与基线程序逐字节相同**（`\r\n` 与 `\n` 视为相同），对**任何能通过 `tools/check_input.py --full` 的输入**都是如此，而不只是公开负载。**行为以基线代码为准**：基线里看起来像 bug 的地方，只要会影响输出，就必须原样保留。
+2. 你可以任意修改 `src/`：改写、重构、增删文件、完全重写都可以。
+3. 编译命令固定为：`g++ -O2 -std=c++20 src/*.cpp`（Windows 上额外加 `-static`）。不能更改编译参数，只能使用 C++ 标准库。
+4. 程序只能读标准输入、写标准输出。不得读写任何文件，不得联网，不得在两次运行之间缓存任何信息。
+5. 内存上限 1 GB。计时使用进程的 **CPU 总时间**（所有线程相加），多线程不会带来加分。
+6. 不要修改 `baseline/`、`workloads/`、`tools/`；正式评测使用出题方自己的副本。
+7. **交卷前在 `src/HANDOFF.md` 写一份交接文档**，给接手的队友看。写什么由你决定（比如代码结构、你发现的怪行为、优化思路、哪里有风险、想改某类逻辑该动哪里）。这份文档也会参与可维护性评审。
+
+## 攻防规则（你会被怎么攻击）
+
+- 攻手提交的击穿用例必须通过 `python3 tools/check_input.py 用例.in`（不带 `--full`），也就是规模更小的上限：W, H ≤ 60，T ≤ 3000，机器人 ≤ 40，事件 ≤ 20000；其余约定和正式负载相同。
+- 用例在你的程序上输出与基线不一致、程序崩溃或运行超过 60 秒，就算**被击穿**。
+- 攻手能看到你的全部 `src/`（包括 `HANDOFF.md`），也有基线和生成器。
+
+## 评分方式（主程个人部分）
+
+- **优化效果**：用若干组**隐藏负载**评测（参数与公开负载不同，规模更大，上限：W, H ≤ 200；机器人 ≤ 300；T ≤ 20000；事件 ≤ 200000）。每组：输出有任何不同、崩溃、超内存或比基线还慢 → 0 分；否则 `100 × ln(加速比) ÷ ln(本期所有主程在这组上的最大加速比)`。取各组平均。
+- **抗击穿**：被越少的攻手击穿越好。但抗击穿分要**乘以你的优化效果分**：完全不改代码虽然打不穿，也拿不到这部分分。
+- **可维护性**：赛后由 3 个裁判模型匿名评审你的 `src/`（含 `HANDOFF.md`），看结构是否清楚、怪行为有没有注明、需求变更好不好改、优化逻辑是否清晰、技术债有没有清理。
+- 团队总分还包括攻手的表现。你的代码质量直接影响队友接手的难度。
+
+## 时间限制
+
+- 时间预算约 **30 分钟**，请自己把握进度，做完就可以结束。超过 45 分钟会被强制停止，以当时的 `src/` 为准。
+- **`python3 clock.py` 可以随时查看已经用了多久、还剩多久**（从主办方开赛的时刻算起）。不要重新解压 `workspace.zip`。
+- 工作时只能读写当前 `workspace` 文件夹里的文件，不要访问这个文件夹以外的任何内容。
+- 结束时的 `src/` 就是你的提交。一个"更快但输出有错"的版本在对应负载上是 0 分，还会被攻手轻松击穿。结束前请确认输出与基线完全一致。
+
+## 工作方式
+
+- 你可以使用本环境中的所有工具：阅读代码、编译、运行、计时、写测试脚本、做剖析（profiling）等。**不能联网搜索。**
+- 自己的脚本和中间文件请放在当前文件夹里（比如新建 `work/`），不要用 `/tmp` 或系统临时目录：在 Windows 上 bash 和 Python 看到的 `/tmp` 不是同一个地方。
+- 请独立完成，**不要向用户提问**，也不要等待用户确认；遇到不确定的地方，以基线代码的行为为准。
+- 建议：先读基线代码和 `SPEC.md`，弄清楚代码真正的行为（注意文档和注释可能过时），再找出瓶颈、逐步优化；每一步都用 `bench.py` 确认输出仍然完全正确。公开负载只有 5 组，建议用 `tools/gen.py` 换种子、改参数生成更多输入，再自己构造一些边界情况（极小地图、极低电量、频繁封路……），与基线对拍。攻手一定会这么做。
+- 完成后，确认 `python3 tools/bench.py` 显示全部正确、`src/HANDOFF.md` 已写好，然后用几句话总结你做了什么，结束任务。

package/eval/arena/warehouse/workspace/baseline/common.h

@@ -0,0 +1,88 @@
+// common.h  ---  WMS 仓储调度  公共头文件
+// 所有人都 include 这个，别乱改！！！ (2022 老王)
+// 2023-03 张: 加了一些全局变量
+// 2023-11 张: 加了 FAST_BFS 开关
+// 2024-06 实习生: 加了注释（部分）
+#ifndef COMMON_H_WMS
+#define COMMON_H_WMS
+
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <string>
+#include <vector>
+#include <map>
+#include <set>
+#include <list>
+#include <queue>
+#include <algorithm>
+#include <cstdlib>
+#include <cstdio>
+#include <cstring>
+#include <utility>
+
+using namespace std;
+
+#define BIGNUM 1000000000
+#define MAXR 512
+#define FLAG_FAST_BFS 0      // 缓存版 BFS，见 old_stuff.cpp，线上先别开
+#define FLAG_VERBOSE 0
+#define USE_NEW_DISPATCH 1   // 0 = 用 old_stuff.cpp 里的旧派单
+
+// 地图 ===========================================
+extern int W, H, T;
+extern vector<string> MAP;            // MAP[y][x]
+extern set<pair<int, int> > BLK;      // 封锁的格子 (x,y)
+
+// 参数 ===========================================
+extern int PRM[6];   // 0 满电 1 充电速度 2 低电量 3 安全余量 4 报表间隔 5 热点半径
+
+// 机器人（老王说 struct 太慢，所以拆成数组） ======
+extern int NR;
+extern vector<int> RX, RY, RB, RTX, RTY, RWS, RDS;   // 位置 电量 目标 连续等待 停机时刻
+extern vector<long long> RWT, RTR;                    // 累计等待 移动步数
+extern vector<string> RST;                            // 状态
+extern vector<string> ROID;                           // 订单号
+
+// 订单 ===========================================
+// ORD[id] = {px, py, dx, dy, prio, arrival, status, robotName}
+extern map<string, vector<string> > ORD;
+extern vector<string> PEND;    // 待派订单
+
+// 事件 & 日志 =====================================
+extern vector<string> EVT;     // 原始事件行
+extern vector<string> LOGBUF;
+
+// 统计 ===========================================
+extern long long CNT[8];   // 0 送达 1 丢失 2 拒绝 3 取消 4 延迟和 5 延迟最大  6,7 没用
+
+// util.cpp
+vector<string> SPLIT(const string& s);
+int S2I(const string& s);
+string I2S(long long v);
+string RNAME(int i);
+bool OK(int x, int y);           // 能不能走
+bool INMAP(int x, int y);
+bool ISWALL(int x, int y);
+bool OCC(int x, int y, int except);
+vector<vector<int> > BFS(int sx, int sy);
+vector<vector<int> > BFS2(int sx, int sy);
+int DIST(int ax, int ay, int bx, int by);
+int CHG_DIST(int x, int y);
+pair<int, int> CHG_NEAR(int x, int y);
+vector<pair<int, int> > ALL_CHG();
+void writeLog(int t, const string& msg);
+void writeRaw(const string& msg);
+void dumpLog();
+int findRobot(const string& name);
+
+// sim.cpp
+void ReadAll(istream& in);
+void RunSim();
+void Finish();
+
+// old_stuff.cpp
+vector<vector<int> > bfs_fast_cached(int sx, int sy);
+void oldDispatch(int t);
+
+#endif

package/eval/arena/warehouse/workspace/baseline/main.cpp

@@ -0,0 +1,27 @@
+// WMS 仓储机器人调度仿真  v3.2
+// 从标准输入读场景，往标准输出写日志
+#include "common.h"
+
+// 全局变量都在这里定义 ===============
+int W = 0, H = 0, T = 0;
+vector<string> MAP;
+set<pair<int, int> > BLK;
+int PRM[6];
+int NR = 0;
+vector<int> RX, RY, RB, RTX, RTY, RWS, RDS;
+vector<long long> RWT, RTR;
+vector<string> RST;
+vector<string> ROID;
+map<string, vector<string> > ORD;
+vector<string> PEND;
+vector<string> EVT;
+vector<string> LOGBUF;
+long long CNT[8] = {0, 0, 0, 0, 0, 0, 0, 0};
+
+int main() {
+    ReadAll(cin);
+    RunSim();
+    Finish();
+    dumpLog();
+    return 0;
+}

package/eval/arena/warehouse/workspace/baseline/old_stuff.cpp

@@ -0,0 +1,87 @@
+// old_stuff.cpp
+// 旧代码，先留着，万一要回滚  —— 张 2023-03
+//
+// 2023-11 张：加了 bfs_fast_cached，按起点缓存 BFS 结果，本地测快了十倍！
+//            线上还没开（FLAG_FAST_BFS），等有空再全面测一下
+// 2024-02 李：FIXME 开了之后有个负载结果对不上，没查出来，先关着
+#include "common.h"
+
+extern int DX4[4];
+extern int DY4[4];
+
+static map<pair<int, int>, vector<vector<int> > > g_bfsCache;
+static int g_cacheHit = 0, g_cacheMiss = 0;
+
+vector<vector<int> > bfs_fast_cached(int sx, int sy) {
+    pair<int, int> key = make_pair(sx, sy);
+    map<pair<int, int>, vector<vector<int> > >::iterator it = g_bfsCache.find(key);
+    if (it != g_bfsCache.end()) {
+        g_cacheHit++;
+        return it->second;
+    }
+    g_cacheMiss++;
+    vector<vector<int> > d(H, vector<int>(W, BIGNUM));
+    queue<pair<int, int> > q;
+    d[sy][sx] = 0;
+    q.push(key);
+    while (!q.empty()) {
+        pair<int, int> p = q.front();
+        q.pop();
+        for (int k = 0; k < 4; k++) {
+            int nx = p.first + DX4[k], ny = p.second + DY4[k];
+            if (!OK(nx, ny)) continue;
+            if (d[ny][nx] != BIGNUM) continue;
+            d[ny][nx] = d[p.second][p.first] + 1;
+            q.push(make_pair(nx, ny));
+        }
+    }
+    if (g_bfsCache.size() > 5000) g_bfsCache.clear();   // 防止内存爆
+    g_bfsCache[key] = d;
+    return d;
+}
+
+// 旧版派单（2022 老王）。新版在 sim.cpp，这个不用了
+// 旧版是按订单到达顺序派的，没有优先级
+void oldDispatch(int t) {
+    vector<string> done;
+    for (int oi = 0; oi < (int)PEND.size(); oi++) {
+        string id = PEND[oi];
+        int px = S2I(ORD[id][0]), py = S2I(ORD[id][1]);
+        int best = BIGNUM, who = -1;
+        for (int i = 0; i < NR; i++) {
+            if (RST[i] != "IDLE") continue;
+            int a = DIST(RX[i], RY[i], px, py);
+            if (a < best) {
+                best = a;
+                who = i;
+            }
+        }
+        if (who < 0) continue;
+        RST[who] = "TO_PICKUP";
+        ROID[who] = id;
+        RTX[who] = px;
+        RTY[who] = py;
+        ORD[id][6] = "ASSIGNED";
+        ORD[id][7] = RNAME(who);
+        done.push_back(id);
+        writeLog(t, "ASSIGN " + id + " " + RNAME(who) + " " + I2S(best));
+    }
+    for (int k = 0; k < (int)done.size(); k++) {
+        PEND.erase(find(PEND.begin(), PEND.end(), done[k]));
+    }
+}
+
+#if 0
+// 想改成按区域派单，没写完
+void zoneDispatch(int t) {
+    int zones = 4;
+    for (int z = 0; z < zones; z++) {
+        // TODO
+    }
+}
+#endif
+
+// 调试用
+void dumpCacheStat() {
+    cerr << "cache hit " << g_cacheHit << " miss " << g_cacheMiss << endl;
+}