🤖 B4352 迷宫探险

一、什么是交互题?

大部分题目是这样的:你的程序先一次性把所有输入读完,然后开始计算,最后输出答案。

交互题不一样。它把"输入"和"输出"交错在了一起:你输出一行,评测机看到你说了什么,再回你一行;你再决定下一步说什么……就像和一个看不见的人玩对话游戏。

输入: 5 3
        13 7 9 11 6

输出: 9

你:   GO
机器: SUCC
你:   LEFT
机器: W
你:   GO
机器: FAIL
...

本题给你的"对话工具"

二、把题目"翻译"回普通题想一想

假如题目把整个迷宫直接给你,这就是一道再普通不过的"找连通块"题:

5 7
#######
#..#..#
#.S#..#
#...#.#
#######

从 S 出发,DFS 四个方向,不是墙就递归——五分钟就写完了:

void dfs(int x, int y) {
    vis[x][y] = 1;
    for (int d = 0; d < 4; d++) {
        int nx = x + dx[d], ny = y + dy[d];
        if (g[nx][ny] == '#') continue;  // ← 关键:看一眼数组
        if (vis[nx][ny]) continue;
        dfs(nx, ny);
    }
}

三、动画演示:机器人怎么 DFS

下面这个迷宫,机器人从 S 出发,我们模拟一遍 DFS 的过程。注意看红色箭头——那是机器人的真实位置和朝向,它每发一条指令就真的会动。

四、核心难点:物理回溯

普通 DFS 里,递归函数返回的瞬间,就好像"人自动回来了"——其实只是变量 x, y 不再使用了。但机器人不会自动回来。

void dfs(int x, int y) {
    ...
    dfs(nx, ny);
    // 函数返回, x,y 自然还是父节点
    // 什么都不用做 ✓
}

void dfs(int x, int y) {
    ...
    dfs(nx, ny);
    // 机器人还停在儿子节点!
    turn_to((d + 2) % 4);  // 转 180°
    GO;                    // 走回来
    turn_to(d);            // 转回原方向
}

五、完整代码(数组版,更适合信奥)

下面是一份信奥学生最熟悉的写法——纯二维数组,不用 STL 容器。关键设计在注释里:

#include <bits/stdc++.h>
using namespace std;

/*
  方向编号 (0:N 1:E 2:S 3:W):
       0
    3     1
       2
*/
const int N = 210;          // 105*2, 留出"起点在正中"的余量
int a[N][N];                // 0:未探索  1:墙  2:可达 —— 一个数组搞定
int dir_now;                // 当前朝向
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, 1, 0, -1};

// ========= 三种基础交互动作 =========
int dir_id(const string &s) {
    if (s == "N") return 0;
    if (s == "E") return 1;
    if (s == "S") return 2;
    return 3;
}
void turn_left()  { cout << "LEFT"  << endl; string fb; cin >> fb; dir_now = dir_id(fb); }
void turn_right() { cout << "RIGHT" << endl; string fb; cin >> fb; dir_now = dir_id(fb); }
string go_forward(){ cout << "GO"   << endl; string fb; cin >> fb; return fb; }

// 转到目标方向(简单起见全用 right 转, 反正 LEFT/RIGHT 不限次数)
void turn_to(int target) {
    while (dir_now != target) turn_right();
}

// ========= DFS 主体 =========
void dfs(int x, int y) {
    a[x][y] = 2;                          // 当前格标为可达
    for (int d = 0; d < 4; d++) {
        int nx = x + dx[d], ny = y + dy[d];
        if (a[nx][ny] != 0) continue;     // ★ 非 0 = 已探明 (墙或空地都跳过)

        turn_to(d);
        string fb = go_forward();          // 用操作代替"看数组"
        if (fb == "FAIL") {
            a[nx][ny] = 1;                 // 标墙, 下次循环自动跳过
        } else {
            // a[nx][ny] 会在 dfs 进入时被标成 2
            dfs(nx, ny);
            // ★ 物理回溯三件套: 转身 → 走回 → 转回
            turn_to((d + 2) % 4);
            go_forward();
            turn_to(d);
        }
    }
}

// ========= 主函数 =========
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    // 1. 初始朝向未知, 随便转一下评测机就告诉你了
    turn_left();

    // 2. 起点放数组正中, 四周预留 100+ 格
    dfs(105, 105);

    // 3. 输出地图: 找出包含所有探明格的最小矩形
    cout << "END" << endl;
    int x1 = N, y1 = N, x2 = 0, y2 = 0;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            if (a[i][j] > 0) {            // 探明过的格子
                x1 = min(x1, i); y1 = min(y1, j);
                x2 = max(x2, i); y2 = max(y2, j);
            }
        }
    }
    cout << x2 - x1 + 1 << " " << y2 - y1 + 1 << endl;
    for (int i = x1; i <= x2; i++) {
        for (int j = y1; j <= y2; j++) {
            // 题目要求: 不可达的格子统一当墙输出
            cout << (a[i][j] == 2 ? '.' : '#');
        }
        cout << '\n';
    }
    return 0;
}

六、交互题怎么本地调试?(重点)

普通题可以直接复制样例进去跑。交互题不行——评测机的反馈是根据你的指令实时算出来的,你没法提前把所有反馈写好。手动敲 SUCC/FAIL 来调试小迷宫还行,稍微大一点根本顶不住。

第一步:封装 send() 函数

把散落的"输出指令 + 读反馈"统一收进一个函数:

// ⛔ 不要再这样写散装的:
cout << "GO" << endl;
string fb; cin >> fb;

// ✅ 改成统一封装:
string fb = send("GO");

send() 内部根据宏切换是真发还是假发:

string send(const string &cmd) {
#ifdef LOCAL
    return fake_judge(cmd);    // 本地: 走假裁判
#else
    cout << cmd << endl;        // 提交: 真的发给评测机
    string fb;
    cin >> fb;
    return fb;
#endif
}

第二步:写假裁判 fake_judge

它要做评测机做的事:维护机器人的真实位置和朝向、维护真实迷宫,根据指令算出反馈。

// ===== 仅本地用,提交时这段被 #ifdef 屏蔽 =====
#ifdef LOCAL
// 1. 把你想测的迷宫写死在这里
vector<string> REAL_MAZE = {
    "#####",
    "#...#",
    "#.#.#",
    "#...#",
    "#####"
};
// 2. 机器人的真实状态(你设定, 程序"不知道")
int real_r = 1, real_c = 1;   // 真实起点
int real_d = 2;               // 真实初始朝向 0:N 1:E 2:S 3:W
const char* DNAME[4] = {"N","E","S","W"};
const int DR[4] = {-1,0,1,0};
const int DC[4] = {0,1,0,-1};

string fake_judge(const string &cmd) {
    if (cmd == "LEFT")  { real_d = (real_d + 3) % 4; return DNAME[real_d]; }
    if (cmd == "RIGHT") { real_d = (real_d + 1) % 4; return DNAME[real_d]; }
    if (cmd == "GO") {
        int nr = real_r + DR[real_d];
        int nc = real_c + DC[real_d];
        if (REAL_MAZE[nr][nc] == '#') return "FAIL";
        real_r = nr; real_c = nc;
        return "SUCC";
    }
    return "?";
}
#endif

第三步:动画看清两种模式的数据流

下面这个演示展示了同一条指令 GO 在两种模式下的流向。切换模式,点"发送指令",看数据怎么跑:

第四步:本地编译运行

$ g++ -DLOCAL -O2 sol.cpp -o sol     # 加 -DLOCAL 开启假裁判
$ ./sol                               # 一键跑,看输出对不对

$ g++ -O2 sol.cpp -o sol              # 不加 -DLOCAL = 提交模式
$ echo "N" | ./sol                    # 手动敲反馈调试也行

第五步(进阶):可视化机器人轨迹

在 fake_judge 里加一行 cerr(注意是 cerr 不是 cout,不会污染交互流),就能看到机器人每一步的轨迹:

string fake_judge(const string &cmd) {
    string fb = /* ...如上... */;
    cerr << "[裁判] 指令 " << cmd << " → 反馈 " << fb
         << "  机器人在 (" << real_r << "," << real_c << ") 朝 "
         << DNAME[real_d] << "\n";
    return fb;
}

三件套总结

📦 完整可本地测试的代码模板

把前面所有东西整合起来:一份代码既能本地一键跑测试,又能原样提交到洛谷。这就是你应该真正写在自己电脑上的版本。

#include <bits/stdc++.h>
using namespace std;

/* ==========================================================
   B4352 迷宫探险 — 自带本地测试框架
   本地调试:  g++ -DLOCAL -O2 sol.cpp -o sol && ./sol
   提交洛谷:  直接复制全部代码, 不用改任何东西
   ========================================================== */

const int N = 210;
int a[N][N];                 // 0:未探索 1:墙 2:可达
int dir_now;                 // 0:N 1:E 2:S 3:W
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, 1, 0, -1};
const char* DNAME[4] = {"N","E","S","W"};

int dir_id(const string &s) {
    if (s == "N") return 0;
    if (s == "E") return 1;
    if (s == "S") return 2;
    return 3;
}

/* ==========================================================
   ↓↓↓ 仅本地用的"假裁判", 提交时整段被宏屏蔽 ↓↓↓
   ========================================================== */
#ifdef LOCAL
// 你想测的迷宫写在这里 (随便改, # 是墙, . 是空地)
vector<string> REAL_MAZE = {
    "#######",
    "#..#..#",
    "#.#...#",
    "#...#.#",
    "#.#.#.#",
    "#...#.#",
    "#######"
};
// 机器人的"真实"初始状态 (你自己设, 程序不知道)
int real_r = 1, real_c = 1;   // 真实起点行/列
int real_d = 2;               // 真实初始朝向 (S)
int judge_go_cnt = 0;         // 统计 GO 次数, 看是否超限

string fake_judge(const string &cmd) {
    string fb;
    if (cmd == "LEFT")       { real_d = (real_d + 3) % 4; fb = DNAME[real_d]; }
    else if (cmd == "RIGHT") { real_d = (real_d + 1) % 4; fb = DNAME[real_d]; }
    else if (cmd == "GO") {
        judge_go_cnt++;
        int nr = real_r + dx[real_d];
        int nc = real_c + dy[real_d];
        if (REAL_MAZE[nr][nc] == '#') fb = "FAIL";
        else { real_r = nr; real_c = nc; fb = "SUCC"; }
    }
    // 用 cerr 输出调试轨迹, 不污染交互流
    cerr << "[裁判] " << cmd << " → " << fb
         << "  机器人(" << real_r << "," << real_c
         << ") 朝" << DNAME[real_d] << "\n";
    return fb;
}
#endif
/* ↑↑↑ 假裁判结束 ↑↑↑ */

// ========= 统一的交互入口 =========
string send(const string &cmd) {
#ifdef LOCAL
    return fake_judge(cmd);          // 本地: 走假裁判
#else
    cout << cmd << endl;              // 提交: 真发给评测机
    string fb;
    cin >> fb;
    return fb;
#endif
}

// ========= 三种基础动作(全都走 send) =========
void turn_left()    { dir_now = dir_id(send("LEFT")); }
void turn_right()   { dir_now = dir_id(send("RIGHT")); }
string go_forward() { return send("GO"); }

void turn_to(int target) {
    while (dir_now != target) turn_right();
}

// ========= DFS 主体 =========
void dfs(int x, int y) {
    a[x][y] = 2;
    for (int d = 0; d < 4; d++) {
        int nx = x + dx[d], ny = y + dy[d];
        if (a[nx][ny] != 0) continue;
        turn_to(d);
        string fb = go_forward();
        if (fb == "FAIL") {
            a[nx][ny] = 1;
        } else {
            dfs(nx, ny);
            turn_to((d + 2) % 4);
            go_forward();
            turn_to(d);
        }
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    turn_left();         // 转一下,得到初始朝向
    dfs(105, 105);       // 起点放数组正中

    // 输出地图
    cout << "END" << endl;
    int x1 = N, y1 = N, x2 = 0, y2 = 0;
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            if (a[i][j] > 0) {
                x1 = min(x1, i); y1 = min(y1, j);
                x2 = max(x2, i); y2 = max(y2, j);
            }
    cout << x2 - x1 + 1 << " " << y2 - y1 + 1 << endl;
    for (int i = x1; i <= x2; i++) {
        for (int j = y1; j <= y2; j++)
            cout << (a[i][j] == 2 ? '.' : '#');
        cout << '\n';
    }

#ifdef LOCAL
    cerr << "\n[裁判] 共调用 GO " << judge_go_cnt << " 次 (上限 50000)\n";
#endif
    return 0;
}

本地跑起来是什么样?

把上面代码存成 sol.cpp,本地编译跑一下:

$ g++ -DLOCAL -O2 sol.cpp -o sol
$ ./sol

[裁判] LEFT → E  机器人(1,1) 朝E
[裁判] RIGHT → S  机器人(1,1) 朝S
[裁判] GO → SUCC  机器人(2,1) 朝S
[裁判] RIGHT → W  机器人(2,1) 朝W
[裁判] GO → FAIL  机器人(2,1) 朝W
[裁判] RIGHT → N  机器人(2,1) 朝N
[裁判] GO → SUCC  机器人(1,1) 朝N
...
END
7 7
#######
#..#..#
#.#...#
#...#.#
#.#.#.#
#...#.#
#######

[裁判] 共调用 GO 36 次 (上限 50000)

七、为什么不会超过 5×10⁴ 次 GO?

设可达空地有 R 个(题目里 R ≤ 100×100 = 10000)。

• 每条 DFS 树边只会"去一次、回一次",共 2(R-1) 次成功 GO。
• 每个相邻墙最多撞一次,共不超过 4R 次失败 GO。
• 总计:约 6R ≤ 60000——但实际紧得多,远低于 5×10⁴ 限制。

八、本质思考:交互题到底特殊在哪?

很多同学学完一道交互题后,会觉得"交互题就是普通题加了几句控制指令的代码"。这话对了一半——表面上确实是。但还有更深的一层,搞清楚以后对所有交互题都受用。

✅ 表面差别:多了"控制器"的代码

从代码形态看,确实只是在 DFS 外面包了一层操控:

if (g[nx][ny] == '#') continue;
dfs(nx, ny);

turn_to(d);                  // ← 多了
string fb = go_forward();    // ← 多了
if (fb == "FAIL") ...
else {
    dfs(nx, ny);
    物理回溯三件套;            // ← 多了
}

🎯 本质差别:两件更深的事

📐 三种题型的"信息流"对比

🍳 一句生活化的比喻

🧠 为什么这种思维以后还会反复遇到?

B4352 不仅是道 DFS 题,它在教你一个会受用终身的思维模式:

九、知识点总结

十、迁移训练