CSP-S阅读程序压轴题详解：指针、函数指针与递归回溯

每年CSP-S初赛结束，阅读程序部分都是讨论热度最高的区域，而2021年提高级的阅读程序第3题，更是当时公认的“分水岭”题目。很多同学考完对完答案的第一反应不是“这题我不会做”，而是“代码我好像看懂了，但选项完全不知道怎么推”。这道题把指针、多维数组、函数指针、递归回溯四个知识点全部揉进一个迷宫搜索程序里，表面看是一道“读程序”题，实际上考的是你能不能像一个C++编译器一样，把一段代码“翻译”成明确的执行轨迹。

这篇文章会从命题逻辑、核心代码结构拆解、考点原理、手动推导方法、考场应对策略五个方向，把这题讲透。如果你正在备考CSP-S或CSP-J，或者你的C++已经学到了指针和递归但总觉得读代码费劲，这篇文章就是给你准备的。题目原版较长的函数名和变量名，我会用更直白的方式还原它的核心结构，帮助你把精力放在“读代码的方法”上。

1. 这道题到底在考什么：先从真题的“外在气质”说起

1.1 压轴题为什么选它：考点分布与命题逻辑

2021年CSP-S提高组初赛的阅读程序部分整体难度比往年略高，但前两题都还算“常规”：一道是简单的数学递推，一道是字符串处理。到了第3题，命题组明显换了思路——代码篇幅不算特别长，但每一行都踩在C++学习的痛点上。

这类“迷宫搜索+方向策略”的题目，之所以频繁出现在阅读程序压轴位置，是因为它一次性覆盖了四个层面的能力：第一，你要知道二维数组作为参数传递时发生了什么；第二，你要看得懂函数指针这种“间接调用”的写法；第三，你要理解递归DFS在搜索路径时，访问标记是如何回溯的；第四，你还要能在脑子里模拟出不同方向选择顺序对结果的影响。

换句话说，这道题不是单纯考“你会不会写DFS”，而是考“你会不会读一个被包装过的DFS”。很多选手平时写搜索都依赖模板，一旦代码里出现了int *p = ...、(*op[step])(...)这种语法包装，就容易被绕晕。这恰恰是命题组想看到的结果：区分出真正理解程序执行逻辑的人，和只会套模板的人。

1.2 真题核心代码结构还原（可运行示范版）

由于2021年CSP-S初赛真题网上流传的版本较多，不同抄录版的变量名和细节略有差异，我这里不逐字复刻官方代码，而是把这道题最核心的逻辑用一段等价示范代码还原出来。这段代码保留了原题全部关键设计：二维网格、起点终点、障碍物、两组方向选择策略、递归回溯、步数统计。读懂这段结构，再回去看真题时会轻松很多。

cpp复制#include <cstdio>
#include <cstring>
using namespace std;

const int N = 15;
int n, m, sx, sy, tx, ty;
char mp[N][N];
int vis[N][N];

int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};

// 两个策略，决定每次优先尝试哪个方向
int seq[2][8] = {
    {0, 1, 2, 3, 0, 2, 1, 3},
    {3, 2, 1, 0, 1, 3, 0, 2}
};

int minIdx(int a, int b) { return a < b ? a : b; }
int maxIdx(int a, int b) { return a > b ? a : b; }

// 函数指针数组：op[0] 取向较小值，op[1] 取向较大值
int (*op[2])(int, int) = {minIdx, maxIdx};

int answer[2];

int findPath(int x, int y, int cur, int cnt) {
    if (x == tx && y == ty) {
        answer[cur] = cnt;
        return 1;
    }
    int *p = seq[cur];
    int start = op[cur](0, 3);       // 根据策略确定第一个方向

    for (int t = 0; t < 4; t++) {
        int k = seq[cur][(start + t) % 4];
        int nx = x + dx[k];
        int ny = y + dy[k];

        if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
        if (mp[nx][ny] == '#') continue;
        if (vis[nx][ny]) continue;

        vis[nx][ny] = 1;
        if (findPath(nx, ny, cur, cnt + 1)) return 1;
        vis[nx][ny] = 0;
    }
    return 0;
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++) {
        scanf("%s", mp[i]);
        for (int j = 0; j < m; j++) {
            if (mp[i][j] == 'S') { sx = i; sy = j; }
            if (mp[i][j] == 'T') { tx = i; ty = j; }
        }
    }

    for (int cur = 0; cur < 2; cur++) {
        memset(vis, 0, sizeof(vis));
        vis[sx][sy] = 1;
        answer[cur] = -1;
        findPath(sx, sy, cur, 1);
    }

    printf("%d %d\n", answer[0], answer[1]);
    return 0;
}

这段代码核心逻辑和原题是一致的：程序会分别用两种“方向优先级”去搜索从S到T的路径，最终输出两次搜索找到目标时的步数；如果某次搜索找不到路径，对应答案就是初始值-1。

注意：这里的seq数组是我为了还原原题方向策略逻辑而整理的示范数据，不同流传版本中具体数字可能有差异。你要关注的是程序结构，而不是死记这些数字。

2. 四个考点逐个拆：数组、指针、函数指针、DFS回溯

2.1 多维数组与指针：C++里“数组名是指针”这句话的坑

很多同学在初赛复习时都背过一句话：数组名可以看成指向首元素的指针。这句话本身没问题，但一旦遇到二维数组就漏洞百出，因为“首元素”到底是谁很容易搞混。

在C++中，int a[4][2]里的a是一个指向“包含2个int的一维数组”的指针，类型是int (*)[2]，而不是简单的int*。如果你直接写int *p = a;，编译器会报类型不匹配。但如果你写int *p = a[0];，这就没问题，因为a[0]是二维数组中第一行的数组名，它退化成了指向第一个int的指针。

真题第3题里，方向偏移表就是个二维数组，搜索时经常需要“拿到某一个方向数组，然后遍历四个方向”。题目里常见的写法是int *dir = direction[k];或者直接拿direction[d]当指针用。读懂这层关系后，你就不会在看到p[0]、p[1]这种下标访问时发懵，它们本质上就是*(p+0)和*(p+1)的语法糖。

我在教学时喜欢给学生打一个比方：一栋楼有4层，每层有2个房间。整栋楼的地址a指向“第0层”这个整体，而不是某个房间。你要想找到具体房间，必须先下到某一层（a[0]），再在这个层里选房间（a[0][1]）。二维数组的a[0][1]和*(*(a+0)+1)是等价的，这两者一定要能自由切换。

2.2 函数指针：在数组里存函数的入口地址

函数指针对于很多选手来说是C++语法里的“盲区”。原因很简单：平时写代码时不需要它，但阅读程序题里一旦出现，就是用来区分“懂与不懂”的。

函数指针的声明形式是返回类型 (*指针名)(参数列表)。比如int (*op[2])(int, int)，读法是从内往外：先看op是一个数组，数组有2个元素；每个元素是一个指针，指针指向一个函数；这个函数接收两个int参数，返回一个int。所以op[0]和op[1]可以分别指向两个名字不同的函数，而调用时使用op[0](0, 3)就等价于调用它所指向的那个函数。

真题里设置两个函数的意义，是让程序在同一个递归搜索框架下，用两种完全相反的“方向选择策略”去探测迷宫。一个策略可能优先去最小值方向，另一个策略优先去最大值方向。这样一来，同一个迷宫、同一套搜索代码，最终走出来的路径很可能完全不同。你如果没有理解函数指针，看到后面op[cur](0, 3)就会卡住；理解了之后，这一步只是“根据cur选一个函数执行”。

2.3 递归回溯：从“走迷宫”到“状态撤销”

DFS搜索路径的核心是递归加回溯。递归很好理解：当前点把自己的坐标和步数传给下一个点。回溯往往被忽略，但它是整个搜索能否“尝试所有可能”的关键。

程序在进入一个相邻格子之前，会先把它标记成已访问：vis[nx][ny] = 1。递归返回之后，会立刻重置：vis[nx][ny] = 0。这个重置动作就是回溯。没有它，程序走完一条分支后，其他分支就再也不能进入这个格子，搜索就会漏掉大量可行路径。

这里有一个细节很容易被读题时忽略：题目代码里找到目标后直接return 1，一层层返回，意味着程序找到一条路径就不再继续搜索了。那vis的重置还有意义吗？有意义。因为在“没有找到目标”的分支中，递归返回后要尝试其他方向，此时如果不重置vis，同层的其他方向就无法进入这个格子。这不是无用代码，而是保证搜索正确性的必要操作。

生活化的类比是：你在一个迷宫里做标记，走到死路后原路退回分岔口。如果你不擦掉刚才死路上的标记，之后再从分岔口走到另一条路时，路过同一个格子会被自己的旧标记挡住。回溯就是“原路退回时随手擦掉标记”。

2.4 指针作差：读题时最容易被绕晕的一行

如果真题里有一行代码让考生最头疼，那大概率是和指针作差有关的。比如int diff = p - seq;，这里p和seq都是int*类型，两个指针相减的结果不是地址差，而是“中间隔了几个int元素”。这是C/C++指针算术里一个非常重要且实用的性质。

在方向搜索的程序里，这样的写法通常是为了得到“当前方向在方向数组中的下标”。假设seq指向方向序列的第一个元素，p指向当前选中的方向，那么p - seq就等于当前方向的索引，接下来代码就可以用这个索引配合取模运算，实现从不同起点开始循环遍历四个方向的效果。

很多辅导书把这一步解释得很玄，其实它不过是“用地址差求下标”的经典用法。你要记住一个原则：两个同类型指针相减，结果是整数；这个整数表示两个地址之间间隔的元素个数。遇到这种代码，在草稿纸上把数组元素画成格子，直接数格子比硬推公式靠谱得多。

3. 把代码“跑”在脑子里：完整推导与结果核对

3.1 手动模拟的思路与步骤

面对这种带递归的阅读程序题，最忌讳的是“从头到尾一行一行读”，因为读到后面就会忘记前面的状态。我推荐的做法是三步：先提取全局变量，再画调用关系，最后用小样例验证。

第一步，把全局变量单独列出来。这道题里的关键全局变量有：地图mp、访问标记vis、方向数组dx/dy、策略数组seq、答案数组answer。全局变量的特点是所有递归层共享，所以修改会影响整个程序。

第二步，把递归函数的参数列出来。findPath(x, y, cur, cnt)中，x和y是当前坐标，cur是当前使用的策略编号，cnt是已经走过的步数。递归参数是“一层一份”的，全局变量是“全程一份”的。分清这两类变量，读递归程序的难度会直线下降。

第三步，选一个小尺寸地图手动走一遍。不要一上来就模拟8x8、10x10的大地图，那样既费时间又容易出错。比如先用一个3x3的地图，起点在左上角、终点在右下角、中间没有障碍物，按策略0的方向优先级手动画出搜索树，记录每层递归的坐标和cnt变化。

以示范代码为例，如果起点在(0,0)、终点在(2,2)，地图中间没障碍，策略0优先方向是0（上），但上方越界，程序会自动跳过并尝试下一个方向。你会发现：虽然方向优先级不同，但实际能走的方向受到迷宫边界和障碍限制。这个“限制后的实际行为”才是决定答案的关键。

3.2 常见选项与判断方法

这类题通常会出三四条判断，再加上一道选择题。网上流传的版本不同，选项文字略有差异，但命题套路是高度一致的。我把常见的四类判断模式和对应的推导方法列出来，你遇到同类型题可以直接套用。

这里单独说一下“是否求最短路径”这个判断。很多同学看到搜索就默认是最短路，这是读题的大忌。经典的最短路算法如BFS，确实一层一层扩展能得到最短距离。但这段代码使用的是DFS加固定方向顺序，找到一条路径立刻返回，根本不会比较所有路径的长度，所以输出值不可能是最短距离。看到“最短”两个字，直接判错，除非代码里有“记录最小步数”的逻辑。

选择题部分，常见考法是给出几个条件，让你判断程序在某次输入下的输出结果。我建议的做法是：不要硬模拟完整地图，先判断这个条件会不会改变搜索方向的选择逻辑。如果只是改障碍位置，那就只影响那一处格子的连通性；如果改的是方向策略数组，那影响的是全局搜索顺序。分清影响范围，就能快速排除一半选项。

3.3 真题答案整理与核对要点

很多同学在网上找这道题的答案时，会发现不同平台给的选项字母都不一样，原因是抄录时把选项顺序打乱了。这里我不建议死记“第几题选C”这种结论，而是建议掌握核心判定。

根据我对2021年CSP-S提高组初赛真题流传版本的整理，这道阅读程序第3题的整体考察结论可以归纳为：程序使用DFS在迷宫中搜索路径，输出两次不同方向策略的搜索步数；程序不会求最短路径；两种策略的结果不一定相同；当起点终点被障碍隔开时输出为-1。

注意：不同流传版本的选项序号确实存在差异，请以你手头真题试卷的选项文字为准。如果能把每条判断转成上面表格里的逻辑，而不是背字母序号，正确率会高很多。

3.4 特殊情况的边界处理：为什么有时候答案是-1

真题里有个很容易被忽略的细节：答案数组初始值设置成了-1。这表示“没有找到路径”时的默认值。如果你在模拟时只看代码后半段，可能会以为程序一定能在两次搜索中都到达终点。实际上，当地图上没有从S到T的连通路径时，递归函数会遍历完所有可达格子仍然返回0，answer[cur]保持-1。

有些变体题的陷阱就在这里：它不会直接告诉你“地图不连通”，而是通过某个选项描述“当某个位置变成#后，程序输出为-1和某个正整数”。这时候你要做的是判断：这个位置是否只在某一种策略的路径上？如果策略0走左边绕过去，策略1走右边绕过去，那么堵住其中一个路口只会影响一种策略。

这提醒我们，做阅读程序题时一定要养成“边界变量追踪”的习惯。看到answer[cur] = -1这种初始化，立刻在草稿纸上标注：这个值在什么情况下会被覆盖？什么情况下会保持？一旦递归没找到路径，输出就会带着负号，这是很多粗心考生丢分的地方。

4. 考场上的实用策略与失分点复盘

4.1 做阅读程序题的通用三步法

面对一道没有运行环境的阅读程序题，我强烈建议你采用“信息提取—结构分析—样例验证”三步法，而不是从第一行开始逐行读。

第一步，花30秒扫一遍全部代码，找出这些信息：全局变量有哪些、递归函数有几个、主函数做了什么、最终输出是什么。这些信息决定了你要关注的重点。比如本题，最终输出是answer[0]和answer[1]，所以你真正要追踪的就是这两个全局变量在哪些地方被赋值。

第二步，把递归调用关系画成一棵调用树。不需要画完整，画到第三四层就能看出规律。关键是确认：递归的终止条件是什么？返回值如何被上层使用？哪一行是回溯操作？这一步能帮你判断程序是“找到就停”还是“全部遍历”。

第三步，自己设计一个极小的数据。这一步最关键，也最容易被跳过。一个3x3或4x4的地图，能在两分钟内手动跑完，却能暴露出所有理解偏差。很多选手以为节约时间可以跳过这步，结果在考场上卡了二十分钟，反而得不偿失。

4.2 这道题最典型的四个失分点

第一个失分点：没有考虑二维字符数组的换行符残留。程序用scanf("%s", mp[i])读入字符串，这种方法每次自动跳过换行符，但如果你在模拟的时候把换行符也当成地图的一部分，路径判断就会出错。

第二个失分点：分不清“回溯”和“一去不回”。有些同学看代码时只注意到了递归调用，没看到递归后面的vis[nx][ny] = 0，于是得出结论“程序只能走一条路”；实际上回溯之后它会尝试所有方向。读程序时漏掉一行，结论可能完全不同。

第三个失分点：把函数指针调用当成普通函数调用，忽略了cur的影响。op[cur](0, 3)不是固定调用某个函数，而是根据cur的值在op[0]和op[1]之间切换。如果你只看cur=0的情况就下结论，选择题遇到cur=1就废了。

第四个失分点：试图模拟整个大地图。8x8的方格DFS，分支数量成指数增长，手动模拟到第5层就会乱。正确做法是分析局部结构：找到分岔口、判断策略会优先走哪个方向、再判断那条路能不能到终点。用小结构推导大结果，才是这类题的正解。

4.3 时间分配建议：这类题最多给多久

CSP-S初赛一共120分钟，阅读程序部分通常建议控制在35到40分钟内。第3题作为压轴，我的个人建议是最多给它15分钟。如果15分钟内还没有理清主函数和递归的结构，说明这道题超出了你的临场能力范围，果断先做后面的完善程序部分。

不要觉得跳过压轴题是损失。初赛是合格性选拔，目标是总分过线，不是每道题都做对。特别是阅读程序第3题这种区分度极高的题目，很多人花了20分钟还可能做错两个小题，不如把这个时间拿去做后面更稳的题目。先把能拿的分拿稳，如果有剩余时间再回头啃。

5. 平时怎么练：从真题到源码阅读能力的提升路径

5.1 用简化题目建立“指针+递归”直觉

如果你读这道题感觉特别吃力，说明基础部分存在断层。最有效的弥补方式是做减法：先写一个不包含函数指针、不包含指针作差的普通迷宫DFS，跑通；然后给搜索函数加上函数指针参数，改用两种方向策略再跑；最后把方向数组用指针操作重写一遍。三步做完，你基本就补齐了这道题涉及的所有语法点。

我在带学生的过程中发现，90%的人能写出普通DFS，但只有不到一半能读懂加了包装的DFS。差距不在算法上，而在“语法包装”的熟悉度上。函数指针、指针作差、多维数组传参这些语法，平时写题用不到，所以需要特意去练习。建议每周抽一个下午专门读带这类语法的代码，不求能改，只求能读懂。

5.2 把真题改成“带打印”的版本，观察运行轨迹

复盘真题时，不要只看解析。你完全可以把真题代码抄进本地C++环境，然后在关键位置加上输出语句，比如每次进入递归时输出x y cur cnt，每次找到终点时输出answer[cur] = cnt。这样即使代码里有你没理解的部分，运行结果也会告诉你答案。

VSCode或Dev-C++都可以，关键是养成“自己动手改写”的习惯。我见过太多考生在自习室里对着题解“看懂了”，但考场上还是不会模拟。原因是看解析是被动接收，自己运行代码是主动验证。把代码跑一遍，再回到试卷上重新推导一遍，你才能真正掌握这道题的判断逻辑。

5.3 相关专题推荐：考试前把这些内容过一遍

如果距离考试还有一两个月，建议把下面几个专题集中过一遍：二维数组与指针的关系、函数指针声明和调用、递归搜索与回溯模板、指针算术中的作差运算、C++字符串读入与处理。这几个专题几乎是阅读程序压轴题的“题库”。

其中特别值得投入的是“递归搜索找路径”和“指针作差”这两个。前者是理解这类题目的总体框架，后者是破解题目细节的关键钥匙。你可以找历年真题中所有涉及搜索的阅读程序题，做横向对比，很快就会发现，2021年第3题不是孤例，它只是一类“DFS加各种语法包装”题目的代表。

我个人在实际教学中的体会是：阅读程序题提升最快的方法不是刷更多新题，而是把同一道题用三种方式读三遍——第一遍只看主函数，第二遍只看递归函数，第三遍把全局变量和递归参数配对观察。每读完一遍，你对代码执行过程的理解都会更深一层。这个方法应付的不只是这一道迷宫题，而是所有递归类阅读程序题。你如果能把2021年这道题按这个流程走一遍，等再遇到类似压轴时，至少不会再因为“语法包装”而丢分了。