迷宫最小步数

|————————最少步数—————————|

时间限制：3000 ms | 内存限制：65535 KB
难度：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

第一种方法：深搜（DFS）

#include<iostream>
#include<cstdio>
using namespace std;
int str[9][9]={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 a[4]={1,0,-1,0};
int b[4]={0,-1,0,1};
int x1,x2,y1,y2,sum,minx;

void dfs(int x,int y)
{
    if(x==x2&&y==y2)
    {
        if(sum<minx)//到达终点后与之前进行的比较若步数小于之前则替换
            minx=sum;
        return ;
    }
    for(int i=0;i<4;i++)
    {
        if(str[x+a[i]][y+b[i]]==0)
        {
            str[x+a[i]][y+b[i]]=1;//到达一个地方之后进行标记；
            sum++;
            dfs(x+a[i],y+b[i]);
            str[x+a[i]][y+b[i]]=0;//回溯，取消标记；
            sum--;
        }
    }
}

int main()
{
    int n;
    scanf("%d",&n);
    while(n--)
    {
        scanf("%d %d  %d %d",&x1,&y1,&x2,&y2);///输入数据
        sum=0;
        minx=10000;///初始化变量；
        dfs(x1,y1);
        printf("%d\n",minx);
    }
    return 0;
}

第二种方法：广搜（BFS）

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;
int dx[4] = { -1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
int c, step, ex, ey;
int x, y;
int vis[9][9];
int map[9][9] = { 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};
struct node
{
    int x, y, step;
};
int bfs()
{
    node s, now, next;                      //s为第一个访问的节点
    s.x = x;
    s.y = y;
    s.step = 0;

    vis[x][y] = 1;                         //对访问过的点进行标记
    queue<node>qu;
    qu.push(s);                               //第一个点入队
    while(!qu.empty())
    {
        now = qu.front();               //把正在访问的点提出来
        qu.pop();     //提出来后进行出队操作，把他相邻符合条件的点全部入队
                                                 //找到终点
        if(now.x == ex && now.y == ey)
            return now.step;

        for(int i = 0; i < 4; i++)
        {
            next.x = now.x + dx[i];
            next.y = now.y + dy[i];
            next.step = now.step;
            if(map[next.x][next.y] == 0 && vis[next.x][next.y] == 0)
            {
                vis[next.x][next.y] = 1;
                next.step += 1;
                qu.push(next);
            }
        }
    }
}
int main()
{
    int t;
    scanf("%d", &t);
    while(t--)
    {
        memset(vis, 0, sizeof(vis));
        scanf("%d %d %d %d", &x, &y, &ex,&ey);
        printf("%d\n", bfs());
    }
    return 0;
}