迷宫问题

描述

定义一个二维数组：

int maze[5][5] = {
0, 1, 0, 0, 0,
0, 1, 0, 1, 0,
0, 0, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
};

它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

输入

一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。

输出

左上角到右下角的最短路径，格式如样例所示。

样例输入

0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

样例输出

(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)

分析题目可得：

数据是标准5*5矩阵，但是数与数中间有空格
需要输出的是路线
输出的坐标逗号后有空格

注意这些坑点，就可以愉快的解题了~\(≧▽≦)/~

作为一道需要求最短路线的迷宫，当然是用广度优先搜索比较方便。选好了模板，鉴于此题需要输出路线，模板上需要修改几点：

1：需要在数组上添加上一步结点的坐标（father）可以使用结构体储存；

2：需要添加一个数组储存答案（从出口往回找）：

解题步骤分析

一：基本变量
1：地图*2（结构体，含坐标和结界）
2：队列（bfs必备）
3：answer数组(存答案)
4：计数器（记answer数组下标）
5：方向变量（走迷宫用）
6：……

二：程序基本框架

int main（）(主程序框架)

1：输入数据
2：初始化
3: bfs()
4：find()
5：输出
6：return

void bfs（）(广搜基本框架)

1：初始化
2：判边界与墙
3：判重
4：记录
5：出队

void find（）(找答案函数)

1；存数组
2：判到达
3：递归（上一步）

附代码一份

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<queue>
using namespace std;
struct data{
    int lx,ly;
    bool flag;
}M[10][10];
int map[10][10],f[4][2]={{1,0},{0,1},{-1,0},{0,-1}};
int ans[30][2],tot;
queue<int>X;
queue<int>Y;
void find(int x,int y)
{
    ans[++tot][0]=x;
    ans[tot][1]=y;
    if(x==0 && y==0)
        return ;
    find(M[x][y].lx,M[x][y].ly);
}
void bfs()
{
    while(!X.empty() && !Y.empty())
    {
        for(int i=0;i<4;i++)
        {
            int tx=X.front(),ty=Y.front();
            tx+=f[i][0];
            ty+=f[i][1];
            if(tx<0 || ty<0 || tx>4 || ty>4)continue;
            if(!map[tx][ty] && M[tx][ty].flag)
            {
                X.push(tx);
                Y.push(ty);
                M[tx][ty].flag=0;
                M[tx][ty].lx=X.front();
                M[tx][ty].ly=Y.front();
            }
        }
        X.pop();
        Y.pop();
    }
}
int main()
{
    for(int i=0;i<5;i++)
        for(int j=0;j<5;j++)
        {
            cin>>map[i][j];
            M[i][j].flag=1;
        }
    X.push(0);
    Y.push(0);
    bfs();
    find(4,4);
    for(int i=tot;i>=1;i--)
        printf("(%d, %d)\n",ans[i][0],ans[i][1]);
}

IN THE END

除了使用FIFO队列（queue）,此题还可用动态数组+模拟队列做。
有兴趣可以看一下：OpenJudge 2.5 7084：迷宫问题,比较一下两者的优缺点。