迷宫最短路径（宽度搜索妙解）

/*
问题描述：
迷宫的最短路径
给定N*M的迷宫，找到从起点S到终点G的最短路径长度。（默认一定可以到达终点）

输入：
10 10
#S######.#
......#..#
.#.##.##.#
.#........
##.##.####
....#....#
.#######.#
....#.....
.####.###.
....#...G#
输出：
22
*/
#include<iostream>
#include<queue>
#define MAX 101
using namespace std;

const int INF = 100000000;//一般放大2~4倍不会溢出为标准设无穷大值

//使用pair表示状态,用typedef会更方便
typedef pair<int, int> P;

char maze[MAX][MAX];
int N, M;
int sx, sy;//起点坐标
int gx, gy;//终点坐标

int d[MAX][MAX];//到各个位置的最短距离的数组

int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};//4个方向移动的向量

//求从(sx, sy)到(gx, gy)的最短距离，如果无法到达，则是INF
int bfs()
{
    queue<P> que;

    for(int i = 0; i < N; i++)for(int j = 0; j < M; j++) d[i][j] = INF;

    que.push(P(sx, sy));
    d[sx][sy] = 0;

    while(que.size())
    {
        P p = que.front(); que.pop();

        if(p.first == gx && p.second == gy) break;

        for(int i = 0; i < 4; i++)
        {
            int nx = p.first + dx[i], ny = p.second + dy[i];

            if(0 <= nx && nx < N && 0 <= ny && ny < M && maze[nx][ny] != '#' && d[nx][ny] == INF)
            {
                que.push(P(nx, ny));
                d[nx][ny] = d[p.first][p.second] + 1;
            }
        }
    }
    return d[gx][gy];
}

int main()
{
    int ans;

    cin>>N>>M;
    for(int i = 0; i < N; i++) for(int j = 0; j < M; j++) 
    {
        cin>>maze[i][j];
        if(maze[i][j] == 'S') {sx = i; sy = j;}
        if(maze[i][j] == 'G') {gx = i; gy = j;}
    }

    ans = bfs();

    cout<<ans<<endl;

    system("pause");
    return 0;
}
/*
宽度优先搜索总结：
宽度优先按照距离开始状态由近到远的顺序进行搜索，因此可以很容易的用来求最短路径、最少操作之类的问题。
深度优先（隐式）使用栈，而宽度优先使用队列。
*/