给定一个 n 行 m 列的地牢，其中 '.' 表示可以通行的位置，'X' 表示不可通行的障碍，牛牛从 (x0 , y0 ) 位置出发，遍历这个地牢，和一般的游戏所不同的是，他每一步只能按照一些指定的步长遍历地牢，要求每一步都不可以超过地牢的边界，也不能到达障碍上。地牢的出口可能在任意某个可以通行的位置上。牛牛想知道最坏情况下，他需要多少步才可以离开这个地牢。

网易的题目是真难理解啊

#include<iostream>
#include<vector>
#include<queue>
using namespace std;
/*
BFS:用队列实现，类似于迷宫
输入：地牢矩阵maze，可移动的方向矩阵dx,dy,起始点到每个点的最近步数矩阵dist,访问矩阵visited,起点x0,y0
步骤：从起点出发按照方向遍历满足条件的其他点，并将满足的点入队，相应的改变步数矩阵与访问矩阵，继续从队顶取点遍历...一直到队列为空
*/
void BFS(vector<vector<char> >& maze,vector<int>& dx,vector<int>& dy,
         vector<vector<int> >& dist,vector<vector<bool> >& visited,int x0,int y0,int n,int m)
{
    //用队列存储x,y坐标
    queue<int> xqueue;
    queue<int> yqueue;
    //1.起点入队
    xqueue.push(x0);
    yqueue.push(y0);
    //2.循环，取出队列元素。。。。
    int curDist=dist[x0][y0];
    while(!xqueue.empty()&&!yqueue.empty())
    {
        int x=xqueue.front();
        int y=yqueue.front();
        xqueue.pop();
        yqueue.pop();
        visited[x][y]=true;
        curDist=dist[x][y]+1;
        //根据dx,dy中方向判断是否能走
        for(int i=0;i<dx.size();i++)
        {
            int xnext=x+dx[i];
            int ynext=y+dy[i];
            //满足限制条件则入队，并且当前距离+1，访问标志置为true
            if(xnext>=0&&xnext<n&&ynext>=0
               &&ynext<m&&maze[xnext][ynext]=='.'
               &&visited[xnext][ynext]==false)
            {
                xqueue.push(xnext);
                yqueue.push(ynext);
                dist[xnext][ynext]=curDist;
                visited[xnext][ynext]=true;
            }
        }
        /*
        cout<<"---------dist矩阵-------------"<<endl;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                cout<<dist[i][j]<<"  ";
            }
            cout<<endl;
        }
        */
    }

}

int main()
{
    int n,m;
    while(cin>>n>>m)
    {
        //保存地牢字符
        vector<vector<char> > maze(n*m);
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                char ch;
                cin>>ch;
                maze[i].push_back(ch);
            }
        }

        /*
        cout<<"------maze矩阵------------"<<endl;
         for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                cout<<maze[i][j]<<" ";
            }
             cout<<endl;
        }
        */

        int x0,y0,k;
        cin>>x0>>y0>>k;
        //保存可选方向dx与dy
        vector<int> dx(k);
        vector<int> dy(k);

        for(int i=0;i<k;i++)
        {
            int dxi,dyi;
            cin>>dxi>>dyi;
            dx.push_back(dxi);
            dy.push_back(dyi);
        }

        /*
        cout<<"-------dx dy------------"<<endl;
        for(int i=0;i<k;i++)
        {
            cout<<dx[i]<<"  "<<dy[i]<<endl;
        }
        */

        //构造起点到每个坐标的最近距离矩阵和访问矩阵
        vector<vector<int> >dist(n,vector<int>(m,0));
        vector<vector<bool> >visited(n,vector<bool>(m,false));

        BFS(maze,dx,dy,dist,visited,x0,y0,n,m);

        int maxDist=0;
        bool notfind=false;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                /*
                遍历每个可通行的'.'点，若其中有点未到达，则最坏情况是此点为出口，且到达不了出口，输出-1；
                否则输出距离最大的点
                */
                if(maze[i][j]=='.'&&visited[i][j]==false)
                {
                    //notfind=true;
                    //break;
                    cout<<"-1"<<endl;
                    return 0;
                }
                if(maze[i][j]=='.'&&dist[i][j]>0&&maxDist<dist[i][j])
                {
                    maxDist=dist[i][j];
                }
            }
        }
        //if(notfind)
            //cout<<"-1"<<endl;
        //else
        cout<<maxDist<<endl;
        return 0;
    }
}