简单迷宫问题的求解-BFS

描述
定义一个二维数组：
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表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

输入

        一个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
样例输出
        (0, 0)
        (1, 0)
        (2, 0)
        (2, 1)
        (2, 2)
        (2, 3)
        (2, 4)
        (3, 4)

        (4, 4)

#include <iostream>
#include <cstring>
#include <stdio.h>
using namespace std;

int arr[5][5];
int visited[5][5];
struct node{
    int X;
    int Y;
    int parent;
}que[25];
int dir[4][2]={{0,1},{1,0},{0,-1},{-1,0}};//四个方向
int head=0,tail=0;
void print(int h){
    if(que[h].parent>=0)
            print(que[h].parent);
    printf("(%d,%d)\n",que[h].X,que[h].Y);
}
void bfs(int x,int y){   //从(0,0)广度优先搜索
    if(x==0&&y==0){
        que[head].X=x;
        que[head].Y=y;
        que[head].parent=-1;
        visited[0][0]=1;
    }
    if(x==4&&y==4){
        print(head);
        return;
    }
    for(int t=0;t<4;t++){
        tail++;
        que[tail].X=que[head].X+dir[t][0];
        que[tail].Y=que[head].Y+dir[t][1];


        if(que[tail].X<0|| que[tail].X>4 || que[tail].Y<0||que[tail].Y>4||visited[que[tail].X ][que[tail].Y]||arr[que[tail].X][que[tail].Y]){
            tail--;
            continue;
        }
        que[tail].parent=head;
        visited[que[tail].X ][que[tail].Y]=1;
        if(que[tail].X==4&&que[tail].Y==4){
            print(tail);
            return;
        }
    }
    head++;
    if(head<=tail){
        bfs(que[head].X,que[head].Y);
        head++;
    }
}


int main()
{
    for(int i=0;i<5;i++)
        for(int j=0;j<5;j++)
            cin>>arr[i][j];
    memset(visited,0,sizeof(visited));
    bfs(0,0);
    return 0;
}