POJ

迷宫问题

定义一个二维数组： 

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

一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。

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)

//update：2019蓝桥杯原题变式

BFS经典题。需要在结构体中定义c记录当前下标，用f记录父节点下标。输出路径时由叶节点遍历到根节点，逆序输出。

#include<stdio.h>
#include<queue>
using namespace std;

int a[10][10],b[10][10],rx[30],ry[30];
int t[4][2]={{1,0},{0,1},{-1,0},{0,-1}};
struct Node{
    int x,y,s,f,c;
}node[30];
int main()
{
    int c,tx,ty,f,i,j;
    queue<Node> q;
    for(i=1;i<=5;i++){
        for(j=1;j<=5;j++){
            scanf("%d",&a[i][j]);
        }
    }
    node[1].x=1;
    node[1].y=1;
    node[1].s=0;
    node[1].f=1;
    node[1].c=1;
    b[1][1]=1;
    q.push(node[1]);
    c=1;f=0;
    while(q.size()){
        for(i=0;i<4;i++){
            c++;
            tx=q.front().x+t[i][0];
            ty=q.front().y+t[i][1];
            if(tx<1||ty<1||tx>5||ty>5) continue;
            if(a[tx][ty]==0&&b[tx][ty]==0){
                b[tx][ty]=1;
                node[c].x=tx;
                node[c].y=ty;
                node[c].s=q.front().s+1;
                node[c].f=q.front().c;
                node[c].c=c;
                q.push(node[c]);
            }
            if(tx==5&&ty==5){
                int cc=c;
                for(j=node[c].s+1;j>=1;j--){
                    rx[j]=tx-1;
                    ry[j]=ty-1;
                    cc=node[cc].f;
                    tx=node[cc].x;
                    ty=node[cc].y;
                }
                for(j=1;j<=node[c].s+1;j++){
                    printf("(%d, %d)
",rx[j],ry[j]);
                }
                f=1;
                break;
            }
        }
        if(f==1) break;
        q.pop();
    }
    return 0;
}