BFS算法解决跳房子问题：最短路径与剪枝优化

sylph mini

1. 问题背景与核心挑战

跳房子问题源自CCF-CSP认证考试第36次认证的第四题，是一个典型的图论搜索问题。题目描述了一排编号从1到n的格子，玩家从格子1出发，目标是到达格子n或更远的位置。每个格子i有两个关键属性：

k[i]：表示从该格子最多可以向前跳跃的步数（可选1~k[i]步）
a[i]：表示跳到该格子后会自动回退的步数

这个问题的独特之处在于它结合了BFS（广度优先搜索）和剪枝优化两个重要算法思想，同时引入了"跳跃+回退"的非常规移动机制，使得传统的路径搜索算法需要特别调整才能正确求解。

2. 算法选择与核心思路

2.1 为什么选择BFS？

BFS是解决最短路径问题的经典算法，特别适合这种网格或图结构中的路径搜索。其核心优势在于：

层级扩展特性：BFS会逐层探索所有可能的路径，当第一次到达目标点时，所经历的步数必然是最小的。
完整性保证：只要存在解，BFS一定能找到，不会遗漏任何可能的路径。
实现简单：使用队列数据结构即可清晰表达搜索过程。

在跳房子问题中，我们需要找到从起点到终点的最少跳跃次数，这正是BFS最擅长的场景。

2.2 状态表示设计

我们使用一个结构体来表示搜索过程中的状态：

cpp复制struct node {
    int pos;   // 当前所在的格子编号
    int step;  // 已经跳跃的次数
};

这种表示方法简洁明了，包含了决定问题状态的两个关键维度：当前位置和已走步数。队列中的每个节点都代表一个可能的状态，记录着"我在哪"和"走了多少步"这两个核心信息。

2.3 跳跃与回退机制

从当前位置t.pos出发的跳跃规则分为三步：

选择跳跃步数i：可以从1到k[t.pos]中选择任意整数步
计算目标位置：target = t.pos + i
应用回退机制：final_pos = target - a[target]

这个回退机制使得问题变得复杂，因为最终到达的位置不仅取决于跳跃的距离，还取决于目标格子的回退属性。这种非线性移动是算法需要特别处理的关键点。

3. BFS实现细节与优化

3.1 基础BFS框架

基础BFS实现遵循标准模式：

初始化队列，放入起点(位置1，步数0)
循环处理队列直到为空：
- 取出队首元素
- 检查是否到达终点
- 生成所有可能的下一步状态并入队
如果队列为空仍未找到解，返回-1

3.2 终点判断优化

在传统BFS中，我们通常在取出节点时检查是否到达终点。但在这里可以做一个小优化：

cpp复制if(t.pos + k[t.pos] >= n) { 
    cout << t.step + 1 << endl;
    return;
}

这个判断基于一个观察：如果当前位置的最大跳跃距离可以直接到达或越过终点，那么只需要再跳一次就能完成任务。这样可以在某些情况下提前终止搜索，节省计算资源。

3.3 剪枝策略详解

剪枝是提高算法效率的关键。本问题采用了独特的从远到近遍历配合访问标记的剪枝策略：

从大到小遍历跳跃步数：即从k[t.pos]开始递减到1
访问标记策略：标记的是中间目标位置(t.pos + i)，而非最终位置
剪枝条件：如果t.pos + i已被访问过，则终止当前循环

这种剪枝有效的关键在于：

从远到近遍历时，如果较远的点已被访问，那么更近的点很可能也被访问过
标记中间位置而非最终位置，避免了回退导致的非单调性问题

为什么不能标记最终位置？
因为回退机制会导致最终位置与跳跃距离之间没有单调关系。一个较远的跳跃可能因为大回退而落到很近的位置，如果仅因为最终位置被访问过就剪枝，可能会错过更优路径。

3.4 复杂度分析

设格子总数为n：

时间复杂度：O(n)，每个格子最多被处理一次
空间复杂度：O(n)，用于存储访问标记和队列

相比无剪枝的BFS，这种优化可以显著减少不必要的计算，特别是在存在大量回退的情况下。

4. 关键实现细节与易错点

4.1 访问标记的正确使用

cpp复制for(int i = k[t.pos]; i >= 1; i--) {
    if(vis[t.pos + i]) break;
    vis[t.pos + i] = 1;
    q.push({t.pos + i - a[t.pos + i], t.step + 1});
}

注意这里有几个关键细节：

循环变量i从k[t.pos]递减到1
检查的是t.pos + i是否被访问过
入队的是回退后的最终位置

4.2 边界条件处理

需要特别注意几种边界情况：

起点就是终点(n=1)
最大跳跃距离为0的情况
回退导致位置小于1的情况（题目通常保证不会发生）

4.3 常见错误与调试

在实际编码中，容易出现以下错误：

错误标记最终位置：如使用vis[final_pos]而非vis[t.pos+i]
循环方向错误：从1到k[t.pos]递增遍历会破坏剪枝逻辑
回退数组索引错误：误用a[i]而非a[t.pos+i]
步数计数错误：忘记在入队时+1

调试时可以打印中间状态，特别是每次跳跃的目标位置和最终位置，验证算法逻辑是否符合预期。

5. 完整代码解析

以下是带详细注释的完整实现：

cpp复制#include<bits/stdc++.h>
using namespace std;
#define endl '\n'
const int N = 1e5 + 5;

int a[N], k[N], vis[N]; // 回退数组、跳跃数组、访问标记

struct node {
    int pos, step; // 当前位置，已走步数
};

void solve() {
    int n; cin >> n;
    for(int i = 1; i <= n; i++) cin >> a[i];
    for(int i = 1; i <= n; i++) cin >> k[i];
    
    queue<node> q;
    q.push({1, 0}); // 初始状态：位置1，步数0
    vis[1] = 1;     // 标记起点已访问
    
    while(!q.empty()) {
        auto t = q.front(); q.pop();
        
        // 提前终止条件：当前最大跳跃可到终点
        if(t.pos + k[t.pos] >= n) {
            cout << t.step + 1 << endl;
            return;
        }
        
        // 从最大步数开始尝试
        for(int i = k[t.pos]; i >= 1; i--) {
            int target = t.pos + i;
            
            // 剪枝：如果中间目标已访问，跳过更小的i
            if(vis[target]) break;
            
            vis[target] = 1; // 标记中间目标
            int final_pos = target - a[target];
            q.push({final_pos, t.step + 1});
        }
    }
    
    cout << -1 << endl; // 无法到达
}

int main() {
    ios::sync_with_stdio(0), cin.tie(0);
    solve();
    return 0;
}