走迷宫问题 算法竞赛入门经典

思路分析：

本题可以采取BFS的方式进行解题，我们把每一个节点的下一层节点全部遍历完，并让它们不再次遍历（设置标志数组）。bfs的解决方法是利用队列知识，每次读取一个数据，并让该数据出队，然后把该节点的子节点依次入队，直到最后遍历完毕。

下面贴上代码：

#include<iostream>
#include<queue>
#include<string.h>
using namespace std;
#define MAXN 105
int dx[] = {-1, 1, 0, 0}, dy[] = {0, 0, -1, 1};
char name[] = {'U', 'D', 'L', 'R'};
int q[MAXN * MAXN]; //队列，保存当前结点编号
int vis[MAXN][MAXN], nMap[MAXN][MAXN];
int m, n; //行、列数
int dir[MAXN * MAXN];
int fa[MAXN][MAXN], dis[MAXN][MAXN], last_dir[MAXN][MAXN];
void funcInit();
void bfs(int x, int y);
void funcInput();
void print_path(int x, int y);
int main()
{
    funcInput();
    funcInit();
    bfs(0, 0);
    print_path(m - 1, n - 1);
    return 0;
}
void funcInit()
{
    for(int i=0;i!=n;i++)
    for(int j=0;j!=m;j++)
    {
        vis[i][j]=0;dis[i][j]=0;
    }
}
void bfs(int x,int y)
{
    int front=0,rear=0;
    vis[x][y]=1;
    int u=x*m+y;
    fa[x][y] = u; //起点元素的父亲为它本身
    q[rear++]=u;//第一个元素入队
    while(front<rear)
    {
        u=q[front++];//第一个元素出队
          x=u/m,y=u%m;
        for(int i=0;i<4;i++)//把出队节点上下左右可以访问的元素依次入队
        {
            int nx=x+dx[i],ny=y+dy[i];
            if(nx>=0&&nx<n&&ny<n&&ny>=0&&!vis[nx][ny]&&!nMap[nx][ny])//在数据范围内并且不是障碍且未被访问过
            {
                vis[nx][ny]=1;//标记为被访问
                fa[nx][ny]=u;//设置父节点
                int v=nx*m+ny;
                q[rear++]=v;//自身入队
                dis[nx][ny]=dis[x][y]+1;//距离在父节点的基础上加1
                last_dir[nx][ny]=i;//记录父节点到子节点的移动方向

            }
        }
    }
}
void funcInput()
{
    int i, j;
    cin>>m>>n;
    for (i = 0; i != m; ++i)
    {
        for (j = 0; j != n; ++j)
        {
            cin>>nMap[i][j];
        }
    }
}
void print_path(int x,int y)
{
    int c=0;
    while(1)
    {
     int fx=fa[x][y]/m;
      int fy=fa[x][y]%m;
      if(fx==x&&fy==y)
         break;
         dir[c++]=last_dir[fx][fy];//把移动方向赋值给数组dir，以便输出路径
    }
    while(c--)
   {

       cout<<name[dir[c]];
        cout<<'
';
    }
    cout<<"最短路径长度为:"<<dis[m-1][n-1]<<endl;
}

注意：需要自己看懂BFS大致模板。