迷宫输出路径

定义一个二维数组：

int maze[5][5] = {
	0, 1, 0, 0, 0,
	0, 1, 0, 1, 0,
	0, 0, 0, 0, 0,
	0, 1, 1, 1, 0,
	0, 0, 0, 1, 0,
};

它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从起点到终点的最短路线。

Input

​ m和n，表示一个m*n 的二维数组，表示一个迷宫。sx,sy,p,q分别表示起点和终点的坐标数据保证有唯一解。

Output

​ 左上角到右下角的最短路径，格式如样例所示。

Sample Input

0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

Sample Output

(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)

#include <stdio.h>//广度搜索算法
int map[51][51],book[10][10];
int dx[]={0,1,0,-1};
int dy[]={1,0,-1,0};
struct que{
    int x;
    int y;
    int s;
    int f;
}arr[2501];
void print(int l)//递归逆序打印下标为l的点的坐标
{
    if(arr[l].f!=-1)
    {
        print(arr[l].f);//l的父亲节点的编号。
        printf("(%d, %d)\n",arr[l].x,arr[l].y);}
}
int main(void)
{
    int i,j,head,tail,k=0,sx,sy,p,q,m,n;
    scanf("%d%d%d%d%d%d",&m,&n,&sx,&sy,&p,&q);//起点，终点
    for(i=0;i<m;i++)
    {
        for(j=0;j<n;j++)
            scanf("%d",&map[i][j]);
    }
    printf("(%d, %d)\n",sx,sy);
    head = 1;
    tail = 1;
    arr[tail].x = 0;
    arr[tail].y = 0;
    arr[tail].s = 0;
    arr[tail].f = -1;//下标为tail的父亲节点的编号
    tail++;
    book[0][0] = 1;
    while(head<tail)
    {
        for(i=0;i<4;i++)
        {
            int nx = arr[head].x+dx[i];
            int ny = arr[head].y+dy[i];
            if(nx<0||nx>m-1||ny<0||ny>n-1)
                continue;
            if(book[nx][ny]==0&&map[nx][ny]==0)
            {
                book[nx][ny]=1;
                arr[tail].x = nx;
                arr[tail].y = ny;
                arr[tail].s = arr[head].s+1;
                arr[tail].f = head;
                tail++;
            }
            if(nx==p&&ny==q)
            {
                 k = 1;
                 print(head);
                 break;
            }
        }   if(k==1)
                break;
            head++;

    }
    printf("(%d, %d)\n",p,q);
    printf("共需 %d 步",arr[tail-1].s);
    return 0;
}