NOIP棋盘问题：BFS与动态规划结合的最优路径算法

1. 题目背景与需求分析

P3956 [NOIP 2017 普及组] 棋盘是一道经典的广度优先搜索（BFS）与动态规划结合的题目。题目描述一个m×m的棋盘，每个格子可能是红色、黄色或无色。玩家从左上角(1,1)出发，到达右下角(m,m)，移动规则如下：

• 每次移动只能向相邻的四个方向（上下左右）移动一格
• 经过的格子必须有颜色（不能停留在无色格子）
• 移动时如果颜色相同则不花费金币，颜色不同则花费1金币
• 可以使用魔法将下一个无色的临时变为指定颜色（花费2金币），但魔法不能连续使用

这个题目考察的是在复杂移动规则下的最优路径查找能力，需要同时考虑颜色变化、魔法使用等多个约束条件。

2. 解题思路与算法选择

2.1 为什么选择BFS+优先队列

传统的BFS适合无权图的最短路径，但本题中不同移动方式有不同的"代价"（金币花费），因此需要使用优先队列（即Dijkstra算法思想）来保证每次扩展的都是当前最小花费的路径。

与纯Dijkstra不同的是，本题的状态不仅包含位置信息，还需要记录：

1. 当前颜色（影响下一次移动的花费）
2. 是否使用了魔法（影响能否再次使用）
3. 累计花费（决定队列优先级）

2.2 状态定义与转移

我们定义状态结构体：

cpp复制struct State {
    int x, y;       // 当前位置
    int color;      // 当前颜色（0红，1黄，-1无色）
    bool usedMagic; // 是否刚使用过魔法
    int cost;       // 累计花费
    
    // 重载<运算符用于优先队列
    bool operator<(const State& other) const {
        return cost > other.cost; // 小顶堆
    }
};

状态转移需要考虑四种情况：

1. 移动到红色格子
2. 移动到黄色格子
3. 移动到无色格子（必须使用魔法）
4. 不能移动的情况（边界检查、无色格子不能停留）

3. 代码实现详解

3.1 输入处理与初始化

cpp复制#include <iostream>
#include <vector>
#include <queue>
#include <climits>
using namespace std;

const int MAX_M = 100;
const int INF = INT_MAX;

int m, n;
int board[MAX_M + 1][MAX_M + 1];  // 棋盘颜色
int dist[MAX_M + 1][MAX_M + 1][3][2];  // 距离数组

// 方向数组：上右下左
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};

3.2 核心BFS实现

cpp复制int bfs() {
    // 初始化距离为无穷大
    for(int i = 1; i <= m; ++i)
        for(int j = 1; j <= m; ++j)
            for(int c = 0; c < 3; ++c)
                for(int k = 0; k < 2; ++k)
                    dist[i][j][c][k] = INF;
    
    priority_queue<State> pq;
    
    // 初始状态：位于(1,1)，颜色为棋盘颜色，未使用魔法，花费0
    int initColor = board[1][1];
    if(initColor == -1) return -1;  // 起点无色直接返回
    
    pq.push({1, 1, initColor, false, 0});
    dist[1][1][initColor][0] = 0;
    
    while(!pq.empty()) {
        State curr = pq.top();
        pq.pop();
        
        // 到达终点
        if(curr.x == m && curr.y == m) {
            return curr.cost;
        }
        
        // 如果当前花费大于已知最小花费，跳过
        if(curr.cost > dist[curr.x][curr.y][curr.color][curr.usedMagic]) {
            continue;
        }
        
        // 尝试四个方向
        for(int i = 0; i < 4; ++i) {
            int nx = curr.x + dx[i];
            int ny = curr.y + dy[i];
            
            // 边界检查
            if(nx < 1 || nx > m || ny < 1 || ny > m) continue;
            
            int nextColor = board[nx][ny];
            bool useMagic = false;
            int addCost = 0;
            
            // 情况1：目标格子有颜色
            if(nextColor != -1) {
                if(nextColor == curr.color) {
                    addCost = 0;
                } else {
                    addCost = 1;
                }
                useMagic = false;
            }
            // 情况2：目标格子无色且未使用魔法
            else if(!curr.usedMagic) {
                nextColor = curr.color;  // 使用魔法变为当前颜色
                addCost = 2;
                useMagic = true;
            }
            // 情况3：目标格子无色且已使用魔法，不能移动
            else {
                continue;
            }
            
            int newCost = curr.cost + addCost;
            // 如果新状态花费更小，则更新
            if(newCost < dist[nx][ny][nextColor][useMagic]) {
                dist[nx][ny][nextColor][useMagic] = newCost;
                pq.push({nx, ny, nextColor, useMagic, newCost});
            }
        }
    }
    
    return -1;  // 无法到达
}

3.3 主函数与输入输出

cpp复制int main() {
    cin >> m >> n;
    
    // 初始化棋盘为无色
    for(int i = 1; i <= m; ++i)
        for(int j = 1; j <= m; ++j)
            board[i][j] = -1;
    
    // 读入有颜色的格子
    for(int i = 0; i < n; ++i) {
        int x, y, c;
        cin >> x >> y >> c;
        board[x][y] = c;  // 0红，1黄
    }
    
    int result = bfs();
    cout << result << endl;
    
    return 0;
}

4. 关键优化与注意事项

4.1 状态剪枝的重要性

在BFS过程中，同一个位置可能被多次访问（不同颜色、不同魔法使用状态），必须记录所有可能的状态组合。我们使用四维数组dist[x][y][color][usedMagic]来记录到达每个状态的最小花费，当发现更优路径时才继续扩展。

4.2 魔法使用的特殊处理

魔法使用有两个限制：

1. 只能在无色格子上使用
2. 不能连续使用

这需要在状态转移时特别处理：

• 如果当前已经使用了魔法，则不能再次使用
• 使用魔法后，临时颜色变为当前格子的颜色

4.3 边界条件检查

几个容易忽略的边界情况：

1. 起点或终点本身是无色格子（直接返回-1）
2. 棋盘大小为1×1的特殊情况（花费为0）
3. 所有路径都需要使用魔法的情况

5. 调试技巧与常见错误

5.1 典型错误分析

1. 状态记录不全：只记录位置不记录颜色和魔法使用状态，导致错误的最优解。

   • 解决：确保状态包含所有必要信息（x,y,color,usedMagic,cost）

2. 优先级队列使用错误：忘记重载<运算符或方向错误，导致不是最小堆。

   • 解决：正确实现operator<，使cost小的优先级高

3. 魔法使用逻辑错误：允许连续使用魔法或在不该使用时使用。

   • 解决：严格检查usedMagic标志

5.2 测试用例设计

建议测试以下情况：

text复制// 样例1：正常情况
5 7
1 1 0
1 2 0
2 2 1
3 3 1
3 4 0
4 4 1
5 5 0
// 预期输出：8

// 样例2：必须使用魔法
3 3
1 1 0
2 2 1
3 3 0
// 预期输出：4

// 样例3：无法到达
3 1
1 1 0
// 预期输出：-1

5.3 性能优化建议

1. 使用更高效的数据结构：可以用deque实现0-1 BFS，当花费为0时从队首插入，花费>0时从队尾插入。

2. 提前终止：当从队列中取出终点状态时可以直接返回，不必处理剩余队列。

3. 内存优化：对于大棋盘，可以改用动态分配内存或更紧凑的状态表示方法。

6. 算法扩展与变种思考

6.1 其他解法对比

1. DFS+记忆化：理论上可行，但不如BFS直观，且难以保证最先找到最优解。

2. 纯动态规划：由于移动方向不受限（可以来回走），存在后效性问题，不适合直接用DP。

3. A*算法：可以尝试用曼哈顿距离作为启发函数，但在本题中效果提升不明显。

6.2 题目变种思考

1. 魔法使用次数限制：改为最多使用k次魔法，而不仅是不连续使用。

   • 解法：将usedMagic改为剩余魔法次数，状态变为dist[x][y][color][magicLeft]

2. 多颜色扩展：增加更多颜色，不同颜色转换有不同花费。

   • 解法：增加颜色维度，修改状态转移时的花费计算

3. 收集物品路径：棋盘上有必须收集的物品，求收集所有物品的最短路径。

   • 解法：增加状态维度记录物品收集情况，变为带状态的BFS

7. 竞赛技巧与时间管理

1. 快速编码：提前准备好BFS模板，包括方向数组、优先队列定义等。

2. 调试策略：先测试小样例，特别是边界情况（1×1棋盘、全无色等）。

3. 时间分配：建议在30-40分钟内完成编码，留出时间测试和调试。

4. 代码复用：将BFS核心部分封装成函数，保持主函数简洁。

在实际竞赛中遇到此类题目时，建议按照以下步骤：

1. 仔细阅读题目，明确所有移动规则和限制条件
2. 设计合适的状态表示方法
3. 确定状态转移的所有可能情况
4. 实现BFS框架，特别注意优先级队列的使用
5. 测试各种边界情况
6. 优化代码结构和性能（如有时间）