广度优先搜索 《挑战程序设计竞赛》——迷宫的最短路径

问题：给定一个大小为N×M的迷宫。迷宫由通道和墙壁组成，每一步可以向邻接的上下左右四格的通道移动。请求出从起点到终点所需的最小步数。请注意，本题假定从起点一定可以移动到终点。

限制条件：N, M ≦100

示例输入：

10 10
#S######.# 
......#..#
.#.##.##.#
.#........
##.##.####
....#....#
.#######.#
....#.....
.####.###.
....#...G#

示例输出：

22

注意pair的使用和定义，注意4个方向向量的处理，注意标记的处理 
BFS(宽度优先搜索)按照距开始状态由近及远的顺序进行搜索，因此可以很容易地用来求最短路径、 
最少操作之类的答案 

pair的类型：  
pair 是 一种模版类型。每个pair 可以存储两个值。这两种值无限制。也可以将自己写的struct的对象放进去。。  
[cpp] view plain copy
pair<string,int> p;  
pair<int ,int > p;  
pair<double,int> p;  

都可以。。。  

<span style="font-family: Arial, Helvetica, sans-serif;">应用：如果一个函数有两个返回值 的话，如果是相同类型，就可以用数组返回，如果是不同类型，就可以自己写个struct ，但为了方便就可以使用 c++  自带的pair ，返回一个pair,其中带有两个值。除了返回值的应用，在一个对象有多个属性的时候 ，一般自己写一个struct ，如果就是两个属性的话，就可以用pair 进行操作。。。</span>  
[cpp] view plain copy
应用pair 可以省的自己写一个struct 。。。如果有三个属性的话，其实也是可以用的pair 的 ，极端的写法 pair <int ,pair<int ,int > >  
写法极端。（后边的两个 > > 要有空格，否则就会是 >>  位移运算符）  
makr_pair：  
pair<int ,int >p (5,6);  
pair<int ,int > p1= make_pair(5,6);  
pair<string,double> p2 ("aa",5.0);  
pair <string ,double> p3 = make_pair("aa",5.0);  
有这两种写法来生成一个pair。  
  
 如何取得pair的值呢。。  
 每个pair 都有两个属性值  first  和second  
 cout<<p1.first<<p1.second;  
 注意是属性值而不是方法。  
  
template <class T1, class T2> struct pair  
{  
  typedef T1 first_type;  
  typedef T2 second_type;  
  
  T1 first;  
  T2 second;  
  pair() : first(T1()), second(T2()) {}  
  pair(const T1& x, const T2& y) : first(x), second(y) {}  
  template <class U, class V>  
    pair (const pair<U,V> &p) : first(p.first), second(p.second) { }  
}  
由于pair类型的使用比较繁琐，因为如果要定义多个形同的pair类型的时候，可以时候typedef简化声明：  
typedef pair<string, string> author;  
author pro("May", "Lily");  

author joye("James", "Joyce"

这个关于pair状态的解释是从一个博主那copy过来的，写的挺详细的，这道题，主要是对队列掌握的不熟练，其他的都没什么问题了，金典例题，值得一做！

//pair的类型：
//pair 是 一种模版类型。每个pair 可以存储两个值。这两种值无限制。
//也可以将自己写的struct的对象放进去。。
#include<cstdio>
#include<queue>
#include<iostream>
using namespace std;
const int INF=100000000;
typedef pair<int ,int> P;
char maze[10000][10000];//迷宫的字符串数组
int n,m;
int sx,sy;//起点坐标
int gx,gy;//终点坐标
int d[10000][10000];//各个位置的最短距离的数组
int dx[4]={1,0,-1,0},dy[4]={0,1,0,-1};//四个方向的移动向量
int bfs()
{
    queue<P> que;
    que.push(P(sx,sy));
    d[sx][sy]=0;
    while(que.size())//直到队列的长度为0
    {
        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];
            int 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()
{
    cin>>n>>m;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            cin>>maze[i][j];
            d[i][j]=INF;//把所有位置都初始化为INF
            if(maze[i][j]=='S')
            {
                sx=i;
                sy=j;
            }
            if(maze[i][j]=='G')
            {
                gx=i;
                gy=j;
            }
        }
    }
    int res=bfs();
    printf("%d\n",res);
    return 0;
}