dsh-eval-guard 0.2.3 → 0.3.1

package/eval/arena/land/tournament/sparring.cpp

@@ -0,0 +1,356 @@
+// 陪练 bot（sparring）：只以编译好的程序发给选手，源码不外发。
+// 策略：每回合重新规划"出圈-横移-回家"路线，按引擎规则模拟圈地收益；
+// 用所有对手到各格的最短步数估计被切断的风险；能安全切断对手时主动出击；避开撞头。
+#include <bits/stdc++.h>
+using namespace std;
+
+const int DX[4] = {0, 0, -1, 1};
+const int DY[4] = {-1, 1, 0, 0};
+const char DC[4] = {'U', 'D', 'L', 'R'};
+
+int W, H, MT, N, ME, MOVE_MS, INIT_MS, S;
+struct Pl { int x, y, d, tl, area, deaths; };
+vector<Pl> pl;
+vector<int> own, tr, prot;
+vector<pair<int, int>> spawn;
+int turnNo;
+vector<int> lastPos;
+vector<char> outP;
+chrono::steady_clock::time_point t0;
+
+double elapsed() { return chrono::duration<double, milli>(chrono::steady_clock::now() - t0).count(); }
+inline int cid(int x, int y) { return y * W + x; }
+inline int nb(int c, int d) {
+    int x = c % W + DX[d], y = c / W + DY[d];
+    if (x < 0 || x >= W || y < 0 || y >= H) return -1;
+    return cid(x, y);
+}
+
+bool readState() {
+    string tok;
+    if (!(cin >> tok)) return false;
+    cin >> turnNo;
+    pl.assign(N, {});
+    for (int i = 0; i < N; i++) {
+        int id; char d; Pl q;
+        cin >> tok >> id >> q.x >> q.y >> d >> q.tl >> q.area >> q.deaths;
+        q.d = string("UDLR").find(d);
+        pl[id] = q;
+    }
+    cin >> tok;
+    for (int y = 0; y < H; y++) {
+        string row; cin >> row;
+        for (int x = 0; x < W; x++) own[cid(x, y)] = row[x] == '.' ? -1 : row[x] - '0';
+    }
+    cin >> tok;
+    for (int y = 0; y < H; y++) {
+        string row; cin >> row;
+        for (int x = 0; x < W; x++) tr[cid(x, y)] = row[x] == '.' ? -1 : row[x] - '0';
+    }
+    cin >> tok;
+    return true;
+}
+
+// ---------- per-turn fields ----------
+vector<vector<int>> edist;   // edist[j][c]: steps for enemy j to reach c (ignores obstacles)
+vector<int> threat;          // min over active enemies
+vector<int> ehome;           // enemy j: steps home avoiding its own trail (INF if inside)
+vector<char> danger;         // cells an enemy head may enter next turn (or occupies now)
+const int INF = 1e9;
+
+void bfsFrom(int src, vector<int>& dist) {
+    dist.assign(S, INF);
+    deque<int> q; dist[src] = 0; q.push_back(src);
+    while (!q.empty()) {
+        int c = q.front(); q.pop_front();
+        for (int d = 0; d < 4; d++) {
+            int n = nb(c, d);
+            if (n >= 0 && dist[n] == INF) { dist[n] = dist[c] + 1; q.push_back(n); }
+        }
+    }
+}
+
+int homeDist(int j) {
+    int src = cid(pl[j].x, pl[j].y);
+    if (own[src] == j) return 0;
+    vector<int> dist(S, INF);
+    deque<int> q; dist[src] = 0; q.push_back(src);
+    while (!q.empty()) {
+        int c = q.front(); q.pop_front();
+        if (own[c] == j) return dist[c];
+        for (int d = 0; d < 4; d++) {
+            int n = nb(c, d);
+            if (n >= 0 && dist[n] == INF && tr[n] != j) { dist[n] = dist[c] + 1; q.push_back(n); }
+        }
+    }
+    return INF;
+}
+
+void computeFields() {
+    edist.assign(N, {});
+    threat.assign(S, INF);
+    ehome.assign(N, INF);
+    danger.assign(S, 0);
+    for (int j = 0; j < N; j++) {
+        if (j == ME || outP[j]) continue;
+        int h = cid(pl[j].x, pl[j].y);
+        bfsFrom(h, edist[j]);
+        for (int c = 0; c < S; c++) threat[c] = min(threat[c], edist[j][c]);
+        ehome[j] = pl[j].tl > 0 ? homeDist(j) : 0;
+        danger[h] = 1;
+        for (int d = 0; d < 4; d++) {
+            if (d == (pl[j].d ^ 1)) continue;
+            int n = nb(h, d);
+            if (n >= 0) danger[n] = 1;
+        }
+    }
+}
+
+// ---------- candidate evaluation ----------
+bool isDuel() { return N == 2; }
+double enemyW() { return isDuel() ? 2.0 : 1.35; }
+int K() { return isDuel() ? 22 : 12; }
+int MARGIN() { return isDuel() ? 1 : 2; }
+
+vector<int> mark, seen;
+int stampM = 1, stampS = 1;
+vector<int> bq;
+
+struct Cand {
+    vector<int> moves;
+    double score = -1e18, gain = 0;
+    int T = 0, margin = -INF;
+    bool ok = false;
+};
+
+// Walk `moves`, then (if the loop is not closed yet) take the shortest path home.
+Cand evaluate(vector<int> moves) {
+    Cand r;
+    int c = cid(pl[ME].x, pl[ME].y), dir = pl[ME].d;
+    stampM++;
+    vector<pair<int, int>> trail;  // (cell, time placed)
+    for (int k = 0; k < S; k++) if (tr[k] == ME) { mark[k] = stampM; }
+    int existing = pl[ME].tl;
+    bool closed = false, hadTrail = existing > 0;
+    size_t used = 0;
+    double bonus = 0;
+    for (; used < moves.size(); used++) {
+        int m = moves[used];
+        if (m == (dir ^ 1)) return r;
+        int n = nb(c, m);
+        if (n < 0 || mark[n] == stampM) return r;
+        if (tr[n] >= 0 && tr[n] != ME) bonus += 6;  // cutting an enemy trail
+        c = n; dir = m;
+        if (own[c] == ME) {
+            if (hadTrail) { closed = true; used++; break; }
+        } else {
+            mark[c] = stampM; trail.push_back({c, (int)used + 1}); hadTrail = true;
+        }
+    }
+    moves.resize(used);
+    if (!closed) {
+        if (!hadTrail) return r;
+        // BFS home avoiding marked trail; first step may not reverse `dir`
+        stampS++;
+        vector<int> par(0);
+        static vector<int> from, fdir;
+        from.assign(S, -1); fdir.assign(S, -1);
+        bq.clear();
+        seen[c] = stampS; bq.push_back(c);
+        int goal = -1;
+        for (size_t qi = 0; qi < bq.size() && goal < 0; qi++) {
+            int u = bq[qi];
+            for (int d = 0; d < 4; d++) {
+                if (u == c && d == (dir ^ 1)) continue;
+                int n = nb(u, d);
+                if (n < 0 || seen[n] == stampS || mark[n] == stampM) continue;
+                seen[n] = stampS; from[n] = u; fdir[n] = d; bq.push_back(n);
+                if (own[n] == ME) { goal = n; break; }
+            }
+        }
+        if (goal < 0) return r;
+        vector<int> tail;
+        for (int u = goal; u != c; u = from[u]) tail.push_back(fdir[u]);
+        reverse(tail.begin(), tail.end());
+        int t = moves.size();
+        int u = c;
+        for (int d : tail) {
+            u = nb(u, d); t++;
+            moves.push_back(d);
+            if (own[u] != ME) { mark[u] = stampM; trail.push_back({u, t}); }
+        }
+    }
+    int T = moves.size();
+    if (T > MT - turnNo) return r;
+    // safety: every trail cell (existing ones too) must stay out of enemy reach until closure
+    int margin = INF;
+    for (int k = 0; k < S; k++) if (tr[k] == ME) margin = min(margin, threat[k] - T);
+    for (auto& [cell, tp] : trail) margin = min(margin, threat[cell] - T);
+    // gain: flood from the border with (my land + trail) as walls
+    stampS++;
+    bq.clear();
+    auto wall = [&](int k) { return own[k] == ME || mark[k] == stampM; };
+    for (int x = 0; x < W; x++) for (int y : {0, H - 1}) {
+        int k = cid(x, y);
+        if (!wall(k) && seen[k] != stampS) { seen[k] = stampS; bq.push_back(k); }
+    }
+    for (int y = 0; y < H; y++) for (int x : {0, W - 1}) {
+        int k = cid(x, y);
+        if (!wall(k) && seen[k] != stampS) { seen[k] = stampS; bq.push_back(k); }
+    }
+    for (size_t qi = 0; qi < bq.size(); qi++) {
+        int u = bq[qi];
+        for (int d = 0; d < 4; d++) {
+            int n = nb(u, d);
+            if (n >= 0 && !wall(n) && seen[n] != stampS) { seen[n] = stampS; bq.push_back(n); }
+        }
+    }
+    double gain = 0, ew = enemyW();
+    for (int k = 0; k < S; k++) {
+        bool take = (mark[k] == stampM && own[k] != ME) || (!wall(k) && seen[k] != stampS);
+        if (!take || (prot[k] >= 0 && prot[k] != ME)) continue;
+        gain += own[k] >= 0 ? ew : 1.0;
+    }
+    r.moves = moves; r.T = T; r.margin = margin; r.gain = gain + bonus;
+    r.ok = true;
+    r.score = r.gain / (T + K());
+    return r;
+}
+
+vector<int> plan;
+
+bool better(const Cand& a, const Cand& b) {  // a better than b
+    bool sa = a.margin >= MARGIN(), sb = b.margin >= MARGIN();
+    if (sa != sb) return sa;
+    if (sa) return a.score > b.score;
+    if (a.margin != b.margin) return a.margin > b.margin;
+    return a.T < b.T;
+}
+
+// ---------- hunting ----------
+int huntMove() {
+    int me = cid(pl[ME].x, pl[ME].y);
+    // BFS from my head avoiding my trail
+    vector<int> dist(S, INF), first(S, -1);
+    deque<int> q; dist[me] = 0; q.push_back(me);
+    while (!q.empty()) {
+        int u = q.front(); q.pop_front();
+        for (int d = 0; d < 4; d++) {
+            if (u == me && d == (pl[ME].d ^ 1)) continue;
+            int n = nb(u, d);
+            if (n < 0 || dist[n] != INF || tr[n] == ME) continue;
+            if (u == me && danger[n]) continue;
+            dist[n] = dist[u] + 1; first[n] = u == me ? d : first[u]; q.push_back(n);
+        }
+    }
+    bool inside = own[me] == ME;
+    int limit = isDuel() ? (inside ? 16 : 8) : (inside ? 10 : 5);
+    int best = -1, bestD = INF;
+    for (int j = 0; j < N; j++) {
+        if (j == ME || outP[j] || pl[j].tl == 0) continue;
+        for (int c = 0; c < S; c++) {
+            if (tr[c] != j || dist[c] > limit || dist[c] > ehome[j] || dist[c] >= bestD) continue;
+            // other enemies must not be able to punish the chase
+            int other = INF;
+            for (int k = 0; k < N; k++)
+                if (k != ME && k != j && !outP[k]) other = min(other, edist[k][c]);
+            if (other <= dist[c] + 2) continue;
+            // my existing trail must survive the chase
+            bool safe = true;
+            for (int k = 0; k < S && safe; k++)
+                if (tr[k] == ME && threat[k] <= dist[c] + 3) safe = false;
+            if (!safe) continue;
+            best = first[c]; bestD = dist[c];
+        }
+    }
+    return best;
+}
+
+int decide() {
+    t0 = chrono::steady_clock::now();
+    double budget = turnNo == 0 ? 300 : min(22.0, MOVE_MS * 0.44);
+    for (int j = 0; j < N; j++) {
+        int p = cid(pl[j].x, pl[j].y);
+        if (turnNo > 1 && p == lastPos[j] && pl[j].tl == 0 && j != ME) outP[j] = 1;
+        lastPos[j] = p;
+    }
+    computeFields();
+    int me = cid(pl[ME].x, pl[ME].y);
+
+    int h = huntMove();
+    if (h >= 0) { plan.clear(); return h; }
+
+    Cand best;
+    auto consider = [&](const vector<int>& mv) {
+        Cand c = evaluate(mv);
+        if (c.ok && (!best.ok || better(c, best))) best = c;
+    };
+    // continue the previous plan (with a small preference)
+    if (!plan.empty()) {
+        Cand c = evaluate(plan);
+        if (c.ok) { c.score *= 1.08; best = c; }
+    }
+    consider({});  // straight home when outside
+    int maxL1 = max(W, H) / 2, maxL2 = 16;
+    for (int L1 = 1; L1 <= maxL1 && elapsed() < budget; L1++) {
+        for (int d0 = 0; d0 < 4; d0++) {
+            if (d0 == (pl[ME].d ^ 1)) continue;
+            for (int s = 0; s < 2; s++) {
+                int d1 = d0 < 2 ? 2 + s : s;
+                for (int L2 = 1; L2 <= maxL2; L2++) {
+                    vector<int> mv(L1, d0);
+                    mv.insert(mv.end(), L2, d1);
+                    consider(mv);
+                    // box: come back parallel to the first leg for L1 steps, then home
+                    vector<int> mv2 = mv;
+                    mv2.insert(mv2.end(), L1, d0 ^ 1);
+                    consider(mv2);
+                }
+            }
+        }
+    }
+    int move = -1;
+    if (best.ok && !best.moves.empty()) {
+        plan.assign(best.moves.begin() + 1, best.moves.end());
+        move = best.moves[0];
+    }
+    // final safety: never hit a wall / own trail; avoid head-on cells if possible
+    auto legal = [&](int d) {
+        if (d == (pl[ME].d ^ 1)) return false;
+        int n = nb(me, d);
+        return n >= 0 && tr[n] != ME;
+    };
+    if (move < 0 || !legal(move) || danger[nb(me, move)]) {
+        int alt = -1, altScore = -INF;
+        for (int d = 0; d < 4; d++) {
+            if (!legal(d)) continue;
+            int n = nb(me, d);
+            int sc = (danger[n] ? -1000 : 0) + (own[n] == ME ? 50 : 0) + min(threat[n], 50);
+            if (move == d) sc += 30;
+            if (sc > altScore) { altScore = sc; alt = d; }
+        }
+        if (alt >= 0 && alt != move) { move = alt; plan.clear(); }
+        if (move < 0) move = pl[ME].d;
+    }
+    return move;
+}
+
+int main() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+    string tok;
+    cin >> tok >> W >> H >> MT >> N >> ME >> MOVE_MS >> INIT_MS;
+    S = W * H;
+    spawn.resize(N);
+    for (int i = 0; i < N; i++) { int id, x, y; cin >> tok >> id >> x >> y; spawn[id] = {x, y}; }
+    own.assign(S, -1); tr.assign(S, -1); prot.assign(S, -1);
+    mark.assign(S, 0); seen.assign(S, 0);
+    for (int i = 0; i < N; i++)
+        for (int y = spawn[i].second - 1; y <= spawn[i].second + 1; y++)
+            for (int x = spawn[i].first - 1; x <= spawn[i].first + 1; x++) prot[cid(x, y)] = i;
+    lastPos.assign(N, -1); outP.assign(N, 0);
+    while (readState()) {
+        int d = decide();
+        cout << turnNo << ' ' << DC[d] << endl;
+    }
+}

package/eval/arena/land/workspace/RULES.md

@@ -0,0 +1,114 @@
+# 圈地对战：规则与通信协议
+
+规则以 `engine/game.py` 为准；本文档与代码描述的是同一套行为。如有疑问，以代码为准。
+
+## 1. 两种赛制
+
+比赛有两种赛制，**你的同一个 bot 两种都要参加**，由开局信息里的玩家数 `N` 区分：
+
+| 赛制 | 玩家数 N | 棋盘 | 回合数 | 出生点 |
+|---|---|---|---|---|
+| **单挑** | 2 | 40 × 40 | 600 | 玩家 1 = 玩家 0 绕棋盘中心旋转 180° |
+| **混战** | 4 | 48 × 48 | 600 | 玩家 k = 玩家 0 绕棋盘中心顺时针旋转 k × 90° |
+
+- 坐标 `(x, y)`：x 为列（向右增大），y 为行（向下增大），都从 0 开始。
+- 玩家 0 的出生点由地图种子随机生成（单挑距边界至少 4 格，混战至少 5 格）；任意两个出生点的曼哈顿距离至少 16。初始方向也按同样的旋转对应。
+- 初始领地：以出生点为中心的 **5 × 5** 方块。
+- 保护区：以出生点为中心的 **3 × 3** 方块。保护区永远属于该玩家，任何方式都无法占领。
+- 两种赛制的规则完全相同，只有玩家数和棋盘大小不同。**不要假设只有一个对手**：混战里有 3 个对手，任何一个都可能切断你。
+
+## 2. 每回合流程
+
+所有玩家**同时**行动。每回合按以下顺序结算：
+
+1. **确定方向**：每名玩家给出 `U`（上，y−1）、`D`（下，y+1）、`L`（左，x−1）、`R`（右，x+1）之一。
+   - 选择与当前方向**相反**的方向（掉头）视为无效，继续沿当前方向前进。
+   - 超时、输出格式错误，同样沿当前方向前进。
+2. **撞墙**：目标格超出棋盘，该玩家阵亡。
+3. **撞头**：两名玩家的目标格相同，或两人互换位置（A 走到 B 当前格、同时 B 走到 A 当前格），**双方都阵亡**。三人或更多人走进同一格，全部阵亡。
+4. **切断轨迹**：若某玩家的目标格上有轨迹，**该轨迹的主人阵亡**（走进自己的轨迹则是自己阵亡）。
+   - 本步判定使用本回合移动前的轨迹。
+   - 玩家在领地外时，头部所在格也是其轨迹的一部分，所以走到对手当前头部所在格（对手在领地外时）也会切断对手。
+   - 切断者本人如果同时满足第 2、3 条，也会阵亡。
+5. **阵亡处理**：阵亡玩家的轨迹全部清除，立即传送回出生点，方向恢复为初始方向。**领地保留。** 阵亡玩家本回合不再移动。
+6. **移动**：存活玩家移动到目标格。
+   - 目标格**不是**自己的领地（中立格或对手领地）：该格加入自己的轨迹。
+   - 目标格**是**自己的领地，且当前有轨迹：本回合圈地（见下）。
+7. **圈地**：对每个本回合圈地的玩家 P，计算：
+   - P 的全部轨迹格变为 P 的领地；
+   - **被围区域**：把 P 的领地和轨迹看作墙，从棋盘边界向内做四连通泛洪，泛洪到达不了的非墙格，全部变为 P 的领地（可以包括中立格和对手领地）。
+   - 例外：对手的保护区永远不会改变归属。
+   - 多名玩家同一回合都圈地时，每人的结果都基于圈地前的棋盘计算，然后同时生效；同一格被两人或更多人同时围住，则保持原归属不变。
+   - 圈地后 P 的轨迹清空。
+   - 对手的轨迹格被 P 圈住时，该格归属变为 P，但对手的轨迹仍在，对手不会因此阵亡。
+
+## 3. 胜负
+
+- 600 回合结束后按**领地格数**排名，格数多者名次靠前，格数相同则名次并列。
+  - 单挑：领地多者胜，相同则平局。
+  - 混战：4 人排出第 1–4 名。
+- 只看名次，**领先多少不影响结果**。
+- 判负：
+  - 程序崩溃、退出，或无法写入；
+  - 单局内超时与格式错误累计达到 **10 次**。
+  - 单挑中判负：该局立即结束，另一方获胜（双方同时判负则平局）。
+  - 混战中判负：该玩家立即出局，排在所有未判负玩家之后（多人判负则并列）。出局玩家的轨迹清除，它停在出生点不再移动，也不会再阵亡；它的领地留在棋盘上，可以被其他玩家圈走（保护区除外）。其余玩家继续比赛。
+
+## 4. 通信协议
+
+bot 是一个独立进程，从 **stdin** 读取，向 **stdout** 输出。所有消息都是以 `\n` 结尾的文本行，以空白分隔。
+
+### 4.1 开局（只发送一次）
+
+```
+INIT
+W H MAX_TURNS N MY_ID MOVE_MS INIT_MS
+SPAWN 0 x0 y0
+SPAWN 1 x1 y1
+...（共 N 行）
+```
+
+- 单挑：`W=40 H=40 MAX_TURNS=600 N=2`；混战：`W=48 H=48 MAX_TURNS=600 N=4`。两种赛制都是 `MOVE_MS=50 INIT_MS=2000`。
+- `MY_ID` 是你的编号（0 到 N−1）。
+
+### 4.2 每回合（t = 0, 1, …, MAX_TURNS−1）
+
+```
+TURN t
+P 0 x y dir trail_len area deaths
+...（共 N 行，玩家 0 到 N−1）
+OWNER
+<H 行，每行 W 个字符>
+TRAIL
+<H 行，每行 W 个字符>
+END
+```
+
+- `P` 行：玩家编号、头部坐标、当前方向（`U/D/L/R`）、轨迹长度、领地格数、累计阵亡次数。
+- `OWNER` 网格：第 y 行第 x 个字符表示格 `(x, y)` 的领地归属：`.` 中立，`0`–`3` 为对应玩家。
+- `TRAIL` 网格：`.` 无轨迹，`0`–`3` 为对应玩家的轨迹。
+- 回合 t 的状态是第 t 次移动**之前**的局面。
+- 混战中已出局的玩家仍然有 `P` 行：坐标是它的出生点，轨迹长度 0。
+
+### 4.3 回应
+
+每收到一个回合，输出一行：
+
+```
+t DIR
+```
+
+`t` 是该回合编号，`DIR` 是 `U`/`D`/`L`/`R`。**每次输出后必须 flush**（C++ 中 `std::endl` 或 `std::cout.flush()`）。
+
+- 时限：第 0 回合 **2000 ms**（含程序启动），之后每回合 **50 ms**，从状态发出开始计时。裁判有少量容差，不要依赖它。
+- 超时：本回合沿当前方向前进，记 1 次错误。迟到的回应（回合号小于当前回合）会被静默丢弃。
+- 格式错误的行：记 1 次错误，本回合沿当前方向前进。
+- 所有调试信息请写到 **stderr**；stdout 只能输出回应行。
+- 注意：如果你的程序持续算得太慢，读取就会落后于裁判，后续每个回合都会超时。
+
+## 5. 对手与地图
+
+- 地图只由种子决定（出生点、初始方向），没有障碍物。
+- 单挑：每对选手在同一批地图上对战，每张图交换出生位各打一局。
+- 混战：每轮把所有参赛 bot 随机分成若干桌，每桌 4 个 bot；同一桌在同一张图上轮换座位打 4 局，每个 bot 每个座位各坐一次。
+- 对手包括其他 AI 模型编写的 bot，以及两个基准 bot（`anchors/` 下的 random 与 greedy）。

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

@@ -0,0 +1,46 @@
+# 任务：编写圈地对战 bot
+
+为"圈地对战"写一个尽可能强的 C++ bot。它会和其他 AI 模型写的 bot 进行 **1 对 1 单挑**和 **4 人混战**两种赛制的对局，两种都计分。
+
+完整规则和通信协议见 `RULES.md`，规则以 `engine/game.py` 为准。
+
+## 工作目录
+
+| 路径 | 内容 |
+|---|---|
+| `RULES.md` | 规则与通信协议 |
+| `clock.py` | 计时器：`python3 clock.py` 显示已用时间 |
+| `engine/` | 规则引擎 `game.py`、本地裁判 `referee.py` |
+| `anchors/` | 两个基准 bot（random、greedy） |
+| `starter/bot.cpp` | 起步模板，已实现协议读写 |
+| `viewer/viewer.html` | 回放查看器（给人看的） |
+| `submission/` | 最终 bot 放在 `submission/bot.cpp` |
+
+本地对战（`.cpp` 会自动编译；没有 `python3` 就用 `python`）：
+
+```bash
+python3 engine/referee.py submission/bot.cpp anchors/greedy.cpp --games 10                                     # 单挑
+python3 engine/referee.py submission/bot.cpp anchors/greedy.cpp anchors/greedy.cpp anchors/random.cpp --games 8  # 混战
+```
+
+其他参数见 `python3 engine/referee.py -h`。
+
+## 提交要求
+
+1. 单个文件 `submission/bot.cpp`，同一个程序要能打单挑和混战（根据开局的 `N` 判断）。
+2. 编译命令 `g++ -O2 -std=c++20 bot.cpp`，只用 C++ 标准库，单线程，内存 512 MB 以内。
+3. bot 程序不得访问网络或读写文件，不得在对局之间保存信息。
+4. 每回合 50 ms，第 0 回合 2000 ms。崩溃或单局累计 10 次超时/格式错误判负。正式比赛会在同一台机器上同时进行多局，CPU 负载比你本地测试时高，请为每回合的计算时间留足余量。
+5. 工作时只能读写当前 `workspace` 文件夹里的文件，不要访问这个文件夹以外的任何内容。
+
+## 评分
+
+单挑循环赛 + 多轮随机分桌的混战，只看名次。每种赛制用 Bradley-Terry 模型拟合实力值，greedy 基准 = 0 分、本期最强者 = 100 分；两种赛制的分数加权合成总分，单挑的权重不低于混战。
+
+对手是其他 AI 模型写的 bot 和两个基准 bot，可能还有出题方的参考 bot。两个基准 bot 很弱，只用来确认程序能正常运行，打赢它们说明不了你的 bot 有多强；怎样检验和提高强度，由你自己决定。
+
+## 时间
+
+时间预算约 **60 分钟**，请自己把握进度，做完就可以结束。超过 90 分钟会被强制停止，以当时的 `submission/bot.cpp` 为准。`python3 clock.py` 可以查看从解压到现在已经过了多久。
+
+不能联网搜索，不要向用户提问，独立完成。结束时用几句话总结你的策略。