最少步数



3000 ms  |  内存限制： 65535



4


描述

这有一个迷宫，有0~8行和0~8列：

 1,1,1,1,1,1,1,1,1
 1,0,0,1,0,0,1,0,1
 1,0,0,1,1,0,0,0,1
 1,0,1,0,1,1,0,1,1
 1,0,0,0,0,1,0,0,1
 1,1,0,1,0,1,0,0,1
 1,1,0,1,0,1,0,0,1
 1,1,0,1,0,0,0,0,1
 1,1,1,1,1,1,1,1,1

0表示道路，1表示墙。

现在输入一个道路的坐标作为起点，再如输入一个道路的坐标作为终点，问最少走几步才能从起点到达终点？

（注：一步是指从一坐标点走到其上下左右相邻坐标点，如：从（3，1）到（4,1）。）




第一行输入一个整数n（0<n<=100），表示有n组测试数据;

随后n行,每行有四个整数a,b,c,d（0<=a,b,c,d<=8）分别表示起点的行、列，终点的行、列。

输出 输出最少走几步。 样例输入

2 3 1 5 7 3 1 6 7

样例输出

12 11


思路：BFS 

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
#define  M 9
int graph[M][M]=
{
    {1,1,1,1,1,1,1,1,1},
    {1,0,0,1,0,0,1,0,1},
    {1,0,0,1,1,0,0,0,1},
    {1,0,1,0,1,1,0,1,1},
    {1,0,0,0,0,1,0,0,1},
    {1,1,0,1,0,1,0,0,1},
    {1,1,0,1,0,1,0,0,1},
    {1,1,0,1,0,0,0,0,1},
    {1,1,1,1,1,1,1,1,1}
};
int dir[4][2]={{-1,0},{0,1},{1,0},{0,-1}};
struct point
{
    int x,y;
    int step;
    bool operator ==(const point &a)
    {
        return (x==a.x&&y==a.y);
    }
    bool ok()
    {
        return (x>=0&&x<9&&y>=0&&y<9);
    }
};
int BFS(point s,point e)
{
    if(s==e)return 0;
    point pre,now;
    int vis[M][M];
    memset(vis,0,sizeof(vis));
    queue<point> Q;
    s.step=0;
    Q.push(s);
    vis[s.x][s.y]=1;
    while(!Q.empty())
    {
        pre=Q.front();
        Q.pop();
        for(int i=0;i<4;i++)
        {
            now=pre;
            now.x+=dir[i][0];
            now.y+=dir[i][1];
            now.step+=1;
            if(now.ok()&&!vis[now.x][now.y]&&graph[now.x][now.y]==0)
            {
                if(now==e)
                    return now.step;
                Q.push(now);
                //标记该点已访问
                vis[now.x][now.y]=1;
            }
        }
    }
    return -1;//访问不到
}
int main()
{
    int n;
    scanf("%d",&n);
    point s,e;
    while(n--)
    {
        scanf("%d%d%d%d",&s.x,&s.y,&e.x,&e.y);
        int minstep=BFS(s,e);
        printf("%d\n",minstep);
    }
    return 0;
}