POJ3984 迷宫问题(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表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。
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)

2019年3月11日

又写了一遍

#include<bits/stdc++.h>
using namespace std;
typedef struct Node{
    int x,y;
}node;
int m,n,vis[110][110];
node pre[110][110];
int dx[4]={-1,0,1,0};
int dy[4]={0,1,0,-1};
int d[110][110];
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,};
void bfs(int sx,int sy){
    queue<node> que;
    while(!que.empty()){que.pop();}
    node q1,q2,q3;
    q1.x=sx;
    q1.y=sy;
    vis[sx][sy]=1;
    d[sx][sy]=0;
    que.push(q1);
    while(!que.empty()){
        q2=que.front();
        que.pop();
        for(int i=0;i<4;i++){
            int nx=q2.x+dx[i];
            int ny=q2.y+dy[i];
            if(nx>=0&&nx<5&&ny>=0&&ny<5&&maze[nx][ny]==0&&vis[nx][ny]==0){
                pre[nx][ny]=q2;
                q3.x=nx;
                q3.y=ny;
                vis[nx][ny]=1;
                d[nx][ny]=d[q2.x][q2.y]+1;
                que.push(q3);
            }
        }
    }

}
int main(){
    std::ios::sync_with_stdio(false);
    n=m=5;
    bfs(0,0);
    node t;
    node path[110*110];
    int pos=0;
    int ex=4,ey=4;
    t.x=0;t.y=0;
    while(1){
        node tmp=pre[ex][ey];
        path[pos++]=tmp;
        ex=tmp.x;
        ey=tmp.y;
        if(ex==0&&ey==0){
            path[pos]=t;
            break;
        }
    }
    for(int i=pos-1;i>=0;i--){
        cout<<path[i].x<<" "<<path[i].y<<endl;
    }

    for(int i=0;i<5;i++){
        for(int j=0;j<5;j++){
            cout<<d[i][j]<<" ";
        }
        cout<<endl;
    }
    cout<<d[4][4]<<endl;        //打印步数
    return 0;
}

今天又重新写了一遍这个bfs的模板题目。

#include<iostream>
#define maxn 1010
#define inf 0x3f3f3f
typedef long long ll;
using namespace std;
typedef struct Node{
    int xx, yy;
    int pre;    //保存前一个结点的序号
}node;
node que[maxn];
int mp[maxn][maxn];
int fro=0,rear=0;
int m,n;
int vis[maxn][maxn];
int dx[4]={1,0,-1,0},dy[4]={0,1,0,-1};
int sx,sy,ex,ey;

void bfs(){
    for(int i=0;i<maxn;i++)
        for(int j=0;j<maxn;j++) vis[i][j]=0;
    que[0].pre=-1;
    que[0].xx=sx;
    que[0].yy=sy;
    vis[sx][sy]=1;
    rear++;
    while(fro<rear){
        //if(b.xx==ex&&b.yy==ey) break;
        for(int i=0;i<4;i++){
            int nx=que[fro].xx+dx[i];
            int ny=que[fro].yy+dy[i];
            //不是墙壁，先前没有访问过，且该点有意义
            if(0<=nx&&nx<n&&0<=ny&&ny<m&&vis[nx][ny]==0&&mp[nx][ny]!=1){
                que[rear].pre=fro;
                que[rear].xx=nx;
                que[rear].yy=ny;
                rear++;
                vis[nx][ny]=1;
                if(nx==ex&&ny==ey) return ;
            }
        }
        fro++;
    }
 }

// void print(node qq){
//    if(qq.pre==-1){
//        cout<<"("<<qq.xx<<","<<qq.yy<<")"<<endl;
//    }
//    else{
//        print(que[qq.pre]);
//        cout<<"("<<qq.xx<<","<<qq.yy<<")"<<endl;
//    }
// }
void print(node qq){
    int a[maxn];
    int cur=0;
    while(qq.pre!=-1){
        a[cur++]=qq.pre;
        qq=que[qq.pre];
    }
    cur--;
    while(cur>=0){
        int t=a[cur];
        cout<<"("<<que[t].xx<<","<<que[t].yy<<")"<<endl;
        cur--;
    }
    cout<<"(4,4)"<<endl;
}

int main(){
    std::ios::sync_with_stdio(false);
    n=5;m=5;
    for(int i=0;i<n;i++){
        for(int j=0;j<m;j++){
            cin>>mp[i][j];
        }
    }
    sx=0,sy=0,ex=4,ey=4;
    bfs();
    print(que[rear-1]);
    return 0;
}

题意分析：

这是我做的第一道BFS题目，也是刚刚了解什么是BFS。
以下是一些小收获：
a.BFS层次遍历的实现依赖于队列。正是借助队列实现了层次搜索。
下面先给出BFS的核心代码：
b.通过方向数组，实现坐标的移动。
c.输出时，递归逆向输出结果。

先给出BFS实现的核心代码：

bool BFS(Node& Vs ,Node& Vd){
	queue<Node > Q;
	Node Vn,Vw;
	int i;

	//用于标记颜色当visit[i][j]==true时，说明节点访问过
	bool visit[maxn][maxn];
	
	//四个方向
	int dir[][2]={
		{0,1},{1,0},
		{0,-1},{-1,0}
	};

	//初始状态被放入队列Q
	Q.push(Vs);
	visit[Vs.x][Vs.y]=true//结点已经访问过

		while(!Q.empty()){ //队列不空，继续搜索
		//取出队列的头Vn
			Vn=Q.front;
			Q.pop();
		
			for(i=0;i<4;i++){
				Vw=Node(Vn.x+dir[i][0]+Vn.y+dir[i][1]);  //计算相邻结点
				
				if(Vw==Vd){  //找到结点了
					//记录路径，这里没给解法
					return true;
				}
				if(isValid(Vw) && !visit[Vw.x][Vw.y]){
					//Vw是一个合法的结点，并且没有访问过
					Q.push(Vw); //加入队列Q
					Visit[Vw.x][[Vw.y]=true; //设置结点颜色
				}
			}
		}
		return false;
}

回到这道题目上来：
摘自：
http://blog.csdn.net/huanghanqian/article/details/51506732

思路：
思迷宫是一个5 × 5的二维数组，搜索起来不会很复杂，也不会超时。从左上角（0, 0）位置开始，上下左右进行搜索，可以定义一个方向数组，代表上下左右四个方向，使用方向数组，可以使一个点上下左右移动。对于数组中的每个元素用结构体来存储，**除了有x,y成员外，还要定义pre成员，用来表示从左上角到右下角的最短路径中每个元素的前一个元素的下标，即保存路径，方便后面的输出。**通过广度搜索借助队列进行操作，当中要注意
1.搜索的元素是否在迷宫内；
2.是否可行（其中1是墙壁不能走，0可以走）。我们可以把已走过的路标记为1，这样能保证路径最短（因为广度优先搜索，只会离初始点的步数一步步增多。如果之后发现遇到了已走过的点，那肯定是从之前已走过的点那边走最短，而不是从之后发现的点走最短啊），直到搜索到右下角（4, 4），问题就解决了。输出路径即可。

下面是实现代码：

#include<iostream>
#include<cstring>
#include<queue>
#define maxn 110
using namespace std;
struct node{
	int x,y;
	int pre; //保存前面一个结点 
}que[maxn];

int map[maxn][maxn];
int front=0,rear=0;
int vis[maxn][maxn];	//保存是否访问过 
int dir[4][2]={-1,0,1,0,0,1,0,-1};

void init(){
	for(int i=0;i<5;i++)
		for(int j=0;j<5;j++)
			cin>>map[i][j];
	for(int i=0;i<maxn;i++){
		for(int j=0;j<maxn;j++){
			vis[i][j]=0;
		}
	}
}
void print(node n){
	if(n.pre==-1)
		cout<<"("<<n.x<<","<<n.y<<")"<<endl;
	else{
		print(que[n.pre]);
		cout<<"("<<n.x<<","<<n.y<<")"<<endl;
	}
}

void bfs(int x1,int y1,int x2,int y2){
	que[0].pre=-1,que[0].x=x1,que[0].y=y1;
	vis[x1][x2]=1;
	rear++;
	while(front<rear){	//如果队列不为空 
		for(int i=0;i<4;i++){
			int dx=que[front].x+dir[i][0];
			int dy=que[front].y+dir[i][1];
			if(dx<0||dx>=5||dy<0||dy>=5||vis[dx][dy]==1||map[dx][dy]==1) continue;
			//入队
			que[rear].pre=front;
			que[rear].x=dx;
			que[rear].y=dy;
			rear++;
			vis[dx][dy]=1;
			if(dx==x2&&dy==y2) return ;
		}
		front++;	//出队 
	}
	
	
}

int main(){
	init();
	bfs(0,0,4,4);
	print(que[rear-1]);
	return 0;
}