洛谷 P1825 Corn Maze S：BFS 迷宫最短路径完全解析

最新推荐文章于 2026-06-25 18:32:41 发布

原创最新推荐文章于 2026-06-25 18:32:41 发布 · 1.3k 阅读

8 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#宽度优先 #算法 #c++ #CSP-J/S

CSP-J/S高频考点突破专栏收录该内容

164 篇文章

订阅专栏

题目分析

问题描述

在一个 N×M 的玉米迷宫网格中（2 ≤ N, M ≤ 300），奶牛需要从起点 @ 出发到达终点 =。迷宫包含以下元素：

墙壁：# 表示，不可通行
草地：. 表示，可通行，移动耗时1单位
传送装置：大写字母 A-Z 表示，双向传送且耗时0
起点：@
终点：=

核心挑战：正确处理传送装置的瞬时传送机制，在BFS框架下保证找到最短路径。

算法核心：BFS与传送装置处理

算法选择依据

BFS（广度优先搜索）是解决无权图最短路径问题的经典算法。在本问题中，迷宫网格可视为图结构，节点为网格点，边为移动或传送关系。BFS按距离起点步数递增的顺序遍历节点，确保首次到达终点即为最短路径。

关键难点：传送装置处理

传送装置的特殊性在于：

双向性：从任一端可瞬间到达另一端
零耗时：传送不增加步数
强制使用：如果奶牛踩到滑梯的任一端，她必须使用滑梯

完整AC代码解析

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

struct pos
{
    int x,y,step;    //step指到达这个点所需的最少步数 
    pos()
    {
        x=y=-1;        //初始化成为一个非法坐标以便后续的赋值 
        step=0;        //开始前是0步 
    }
};

struct spt        // spread_point传送点 
{
    pos p1,p2;    //两个配对的传送点    
};

pos s,f;    //起点和终点的坐标 
int n,m;    //地图长和宽 
char a[305][305];    //地图 
bool v[305][305];    //标记数组 
int dx[] = {0,1,0,-1};    
int dy[] = {1,0,-1,0};    //四个方向的移动 
spt spts[200];        //传送点 
queue<pos> q;        //bfs队列 

bool check(int x,int y)
{
    if(x<0||x>n||y<0||y>m||a[x][y]=='#'||v[x][y]==1)
        return 0;
    return 1;
}        

//合法判断函数 
void bfs()
{
    v[s.x][s.y]=1;
    pos t;
    t.x=s.x,t.y=s.y,t.step=0;
    q.push(t);
    while(!q.empty())
    {
        pos tmp=q.front();
        q.pop();
        int x=tmp.x,y=tmp.y,step=tmp.step; 
        
        if(tmp.x==f.x&&tmp.y==f.y)
        {
            cout<<tmp.step;
            return;
        }
        
        for(int i=0; i<4; i++)
        {
            int xx=x+dx[i];
            int yy=y+dy[i];
            if(check(xx,yy))
            {
                pos val;
                if(a[xx][yy]<'A'||a[xx][yy]>'Z')
                {
                    val.x=xx,val.y=yy,val.step=step+1;
                    v[xx][yy]=1;
                }
                else
                {
                    if(xx==spts[a[xx][yy]-'A'].p1.x&&yy==spts[a[xx][yy]-'A'].p1.y)
                    {
                        val.x=spts[a[xx][yy]-'A'].p2.x;
                        val.y=spts[a[xx][yy]-'A'].p2.y;
                        val.step=step+1;
                    }
                    else
                    {
                        val.x=spts[a[xx][yy]-'A'].p1.x;
                        val.y=spts[a[xx][yy]-'A'].p1.y;
                        val.step=step+1;
                    }
                }
                q.push(val);
            }
        }
    }
}

int main()
{
    cin>>n>>m;
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            cin>>a[i][j];
            if(a[i][j]=='@')
            {
                s.x=i;
                s.y=j;
            }
            if(a[i][j]=='=')
            {
                f.x=i;
                f.y=j;
            }
            if(a[i][j]>='A'&&a[i][j]<='Z')
            {
                int c=a[i][j]-'A';
                if(spts[c].p1.x==-1&&spts[c].p1.y==-1)
                {
                    spts[c].p1.x=i;        
                    spts[c].p1.y=j;
                }
                else
                {
                    spts[c].p2.x=i;
                    spts[c].p2.y=j;
                }
            }
        }
    }
    bfs();
}

代码详解

1. 数据结构设计

struct pos {
    int x, y, step;
};

struct spt {
    pos p1, p2;
};

spt spts[200]; // 传送点存储

位置结构体：存储坐标(x,y)和到达该点的步数
传送点结构体：为每个字母存储一对坐标，表示传送装置的两个端点
访问标记数组：v[x][y] 避免重复处理同一位置

2. BFS核心逻辑

void bfs() {
    // 初始化队列和标记
    while (!q.empty()) {
        // 终止条件判断
        if (到达终点) {
            cout << 步数;
            return;
        }
        
        // 四个方向移动探索
        for (四个方向) {
            if (检查合法性) {
                if (是传送装置) {
                    // 处理传送逻辑
                } else {
                    // 常规移动处理
                }
            }
        }
    }
}

3. 关键处理细节

传送装置处理：

if (a[xx][yy] >= 'A' && a[xx][yy] <= 'Z') {
    if (当前点是传送装置的第一端点) {
        val.x = 第二端点x;
        val.y = 第二端点y;
    } else {
        val.x = 第一端点x;
        val.y = 第一端点y;
    }
    val.step = step + 1;
}