迷宫问题

题目描述

小明置身于一个迷宫，请你帮小明找出从起点到终点的最短路程。
小明只能向上下左右四个方向移动。

输入

输入包含多组测试数据。输入的第一行是一个整数T，表示有T组测试数据。
每组输入的第一行是两个整数N和M（1<=N,M<=100）。
接下来N行，每行输入M个字符，每个字符表示迷宫中的一个小方格。
字符的含义如下：
‘S’：起点
‘E’：终点
‘-’：空地，可以通过
‘#’：障碍，无法通过
输入数据保证有且仅有一个起点和终点。

输出

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

样例输入

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

样例输出

9

#define Question5
#ifdef Question5

#define UnDebug

#ifdef Debug
#include <ctime>
#endif

#include <iostream>
#include <cstring>
#include <queue>
#include <cstdio>

using namespace std;

typedef pair<int, int> P;
const int Max = 100;
const int INF = -1;
char Map[Max + 10][Max + 10];
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int diction[Max + 10][Max + 10];
int sx, sy, ex, ey;

void InputMap(int N, int M);
void OutputMap(int N, int M);
void BFS(int N, int M);

int main()
{
#ifdef Debug
    freopen("in.txt", "r", stdin);
    clock_t start, finish;
    double totaltime;
    start = clock();
#endif

    int T, N, M;
    cin >> T;
    while (T--)
    {
        cin >> N >> M;
        InputMap(N, M);
        BFS(N, M);
        cout << diction[ey][ex] << endl;
    }

#ifdef Debug
    finish = clock();
    totaltime = (double)(finish - start) / CLOCKS_PER_SEC;
    cout << "Times : " << totaltime * 1000 << "ms" << endl;
    system("pause");
#endif
    return 0;
}

void InputMap(int N, int M)
{
    bool sok = 1, eok = 1;
    for (int i = 0; i < N; i++)
    {
        cin >> Map[i];
        for (int j = 0; j < M; j++)
        {
            if (sok && Map[i][j] == 'S')
            {
                sx = j;
                sy = i;
                sok = 0;
            }
            if (eok && Map[i][j] == 'E')
            {
                ex = j;
                ey = i;
                eok = 0;
            }
        }
    }
}
void OutputMap(int N, int M)
{
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < M; j++)
        {
            cout << Map[i][j] << " ";
        }
        cout << endl;
    }
}

void BFS(int N, int M)
{
    queue<P> que;
    memset(diction, INF, sizeof(diction));
    que.push(P(sy, sx));
    diction[sy][sx] = 0;

    while (!que.empty())
    {
        P curPoint = que.front();
        que.pop();
        for (int i = 0; i < 4; i++)
        {
            int newx = curPoint.second + dx[i];
            int newy = curPoint.first + dy[i];

            if (newy >= 0 && newy < N &&
                newx >= 0 && newx < M &&
                Map[newy][newx] != '#' &&
                diction[newy][newx] == INF)
            {
                que.push(P(newy, newx));
                diction[newy][newx] = diction[curPoint.first][curPoint.second] + 1;
                if (newx == ex && newy == ey)
                    return;
            }
        }
    }
}

#endif