一千题，No.0005（迷宫问题）

描述

小明置身于一个迷宫，请你帮小明找出从起点到终点的最短路程。

小明只能向上下左右四个方向移动。

输入描述

输入包含多组测试数据。输入的第一行是一个整数T，表示有T组测试数据。

每组输入的第一行是两个整数N和M（1<=N,M<=100）。

接下来N行，每行输入M个字符，每个字符表示迷宫中的一个小方格。

字符的含义如下：

‘S’：起点

‘E’：终点

‘-’：空地，可以通过

‘#’：障碍，无法通过

输入数据保证有且仅有一个起点和终点。

输出描述

对于每组输入，输出从起点到终点的最短路程，如果不存在从起点到终点的路，则输出-1。

用例输入 1 

1
5 5
S-###
-----
##---
E#---
---##

用例输出 1 

9

思路解析：

DFS：

1，判断所处点是否为终点，如果是，则判断最小步数然后开始回退。

2，如果不是则以固定顺序判断是否可走，如果可走则在判断里直接开始递归，如果不可走就是已经无路可走（无法到达终点），则回退到上一步继续开始递归，直到回退到第一步退出程序。

3，判断最短路径是否改变，如果改变则证明可以到达，如果未改变则证明不可到达，如果有多个迷宫需要将最短路径重置为无限值。

c++代码如下：

#include <bits/stdc++.h>

using namespace std;

char arrA[999][999];//存储迷宫
int arrB[999][999];//存储是否访问
int min = 999999;//存储最短路径
int bx,by;//开始点位
int ex,ey;//结束点位

//DFS主要使用递归
void DFS(int x,int y,int step)
{
    if(x == ex && y == ey)
    {
        if(step<::min)
        {
            ::min = step;
        }
        return;//回退到上一步
    }

    //右
    if(arrA[x][y+1] != '#' && arrB[x][y+1] == 0)
    {
        arrB[x][y+1] = 1;//将上一步置为1表示走过了
        DFS(x,y+1,step+1);//递归
        arrB[x][y+1] = 0;//从上一步出来，需要将上一步重新置为空
    }
    //下
    if(arrA[x+1][y] != '#' && arrB[x+1][y] == 0)
    {
        arrB[x+1][y] = 1;
        DFS(x+1,y,step+1);
        arrB[x+1][y] = 0;
    }
    //左
    if(arrA[x][y-1] != '#' && arrB[x][y-1] == 0)
    {
        arrB[x][y-1] = 1;
        DFS(x,y-1,step+1);
        arrB[x][y-1] = 0;
    }
    //上
    if(arrA[x-1][y] != '#' && arrB[x-1][y] == 0)
    {
        arrB[x-1][y] = 1;
        DFS(x-1,y,step+1);
        arrB[x-1][y] = 0;
    }
    return;//如果无路可走就回退，如果回退的时第一步就会退出程序
}

int main()
{
    memset(arrB,0, sizeof(arrB));//将B数组全置为0
    int n;
    cin >> n;
    while(n--)
    {
        ::min = 999999;//多次样例需要重置min
        int x,y;
        cin >> x >> y;
        memset(arrA,'#',999*999);
        for(int i = 1;i<=x;++i)
        {
            for(int j = 1;j<=y;++j)
            {
                cin >> arrA[i][j];
                if(arrA[i][j] == 'E')
                {
                    ex = i;
                    ey = j;
                }
                if(arrA[i][j] == 'S')
                {
                    bx = i;
                    by = j;
                    arrB[i][j] = 1;//需要将开始点设置为已经走过了
                }
            }
        }
        DFS(bx,by,0);
        if(::min != 999999)
        {
            cout << ::min << endl;
        }
        else
        {
            cout << -1 << endl;
        }
    }
    return 0;
}

BFS：

1，将起点入队；

2，将队列首位所有可走但是为走过的点入队，并且如果点为终点时不需要入队；

3，队首出队；

4，一直循环2，3步如果点为终点时判断最小路径，直到队列为空

5，如果最短路径为无限大则没有答案；

c++代码如下:

#include <bits/stdc++.h>

using namespace std;

char arrA[999][999];
int arrB[999][999];
int ex,ey;
int min = 999999;

struct point
{
    point(int a,int b,int c)
    :_x(a)
    ,_y(b)
    ,_step(c)
    {
    }
    int _x;
    int _y;
    int _step;
};

void BFS(vector<point> &v)
{
    while(!v.empty())
    {
        //赋初值更好操作
        int x = v.begin()->_x;
        int y = v.begin()->_y;
        int step = v.begin()->_step;

        //保存最短路径
        if(step < ::min && x == ex && y == ey)
        {
            ::min = step;
        }
        else//如果不是终点才可以入队，否则会出浪费时间
        {
            //右
            if(arrA[x][y+1] != '#' && arrB[x][y+1] == 0)
            {
                arrB[x][y+1] = 1;
                point new_p = point(x,y+1,step+1);
                v.push_back(new_p);
            }
            //下
            if(arrA[x+1][y] != '#' && arrB[x+1][y] == 0)
            {
                arrB[x+1][y] = 1;
                point new_p = point(x+1,y,step+1);
                v.push_back(new_p);
            }
            //左
            if(arrA[x][y-1] != '#' && arrB[x][y-1] == 0)
            {
                arrB[x][y-1] = 1;
                point new_p = point(x,y-1,step+1);
                v.push_back(new_p);
            }
            //上
            if(arrA[x-1][y] != '#' && arrB[x-1][y] == 0)
            {
                arrB[x-1][y] = 1;
                point new_p = point(x-1,y,step+1);
                v.push_back(new_p);
            }
        }
        //队首出队
        v.erase(v.begin());
    }
}

int main()
{
    memset(arrB,0, 999*999*4);//将B数组全置为0
    int n;
    cin >> n;
    while(n--)
    {
        ::min = 999999;//每次输入都需要重置
        vector<point> v;//用于存储队列
        int x,y;
        cin >> x >> y;
        memset(arrA,'#',999*999);
        for(int i = 1;i<=x;++i)
        {
            for(int j = 1;j<=y;++j)
            {
                cin >> arrA[i][j];
                if(arrA[i][j] == 'E')
                {
                    ex = i;
                    ey = j;
                }
                if(arrA[i][j] == 'S')
                {
                    arrB[i][j] = 1;//需要将开始点设置为已经走过了
                    point new_p(i,j,0);
                    v.push_back(new_p);
                }
            }
        }
        BFS(v);
        if(::min == 999999)
        {
            cout << -1 << endl;
        }
        else
        {
            cout << ::min << endl;
        }
    }
    return 0;
}