用BFS解决迷宫问题

在一个n*n的矩阵里走，从原点（0,0）开始走到终点（n-1,n-1），只能上下左右4个方向走，只能在给定的矩阵里走，求最短步数。n*n是01矩阵，0代表该格子没有障碍，为1表示有障碍物。

int mazeArr[maxn][maxn]; //表示的是01矩阵

int stepArr[4][2] = {{-1,0},{1,0},{0,-1},{0,1}}; //表示上下左右4个方向

int visit[maxn][maxn]; //表示该点是否被访问过，防止回溯，回溯很耗时。

解题思路：

BFS找出来的是最短路径，如果用DFS，那么寻找出来的不是最短路径。

我们先对原点的上下左右进行访问，如果上下左右的点非障碍物，并且还没访问过，那么就将这些点入队列，并设置为已经访问，然后再依次把这些点出队列，并且重复之前的步骤对这些点的进行上下左右访问。。。。如果最后访问到终点（n-1，n-1），则结束

代码如下：

#include<iostream>
using namespace std;

//定义迷宫的行列
#define ROW_COL  4   

//定义一个结构体，表示经过的点路径
struct Node
{
	int x;
	int y;
	int step;
};

//赋值
Node fuzhi(int x,int y,int step)
{
	Node p;
	p.x=x;
	p.y=y;
	p.step=step;
	return p;
}

//实现一个循环队列
//=====================================
#define QueueSize 30
typedef struct
{
	Node Seq[QueueSize];
	int front;
	int rear;
	int count;
}RQueue;

RQueue Q;

void Initiate_Queue(RQueue *Q)
{
	Q->front=0;
	Q->rear=0;
	Q->count=0;
}

void AppendQueue(RQueue *Q,Node data)
{
	if(Q->count>=QueueSize)
	{
		cout<<"overflow"<<endl;
		return ;
	}
	Q->Seq[Q->rear]=data;
	Q->rear=(Q->rear+1)%QueueSize;
	Q->count++;
}

int QueueNotEmpty(RQueue *Q)
{
	if(Q->count!=0)
		return 1;
	else
		return 0;
}

Node DeleteQueue(RQueue *Q)
{
	if(Q->count<=0)
	{
		cout<<"empty"<<endl;
		exit(0);
	}
	Node d;
	d=Q->Seq[Q->front];
	Q->front=(Q->front+1)%QueueSize;
	Q->count--;
	return  d;
}

//=======================

//迷宫图的矩阵
int mazeArr[4][4]=
{
	{0,0,1,1},
	{0,1,1,0},
	{0,0,1,0},
	{0,1,0,0}
};

int visit[ROW_COL][ROW_COL];

//表示上下左右
int stepArr[4][2]={{-1,0},{1,0},{0,-1},{0,1}};

//对其进行BFS，找出的路径为最短路径，注意二位数组的形参是int (*mazeArr)[4]
int BFS(int (*mazeArr)[4],Node node,int n)
{
	for(int i=0;i<ROW_COL;i++)
		for(int j=0;j<ROW_COL;j++)
			visit[i][j]=0;
	Node N;
	Initiate_Queue(&Q);
	AppendQueue(&Q,node);
	while(QueueNotEmpty(&Q))
	{
		N=DeleteQueue(&Q);
		if(N.x==n-1 &&N.y==n-1)
		{
			return N.step;
		}
		visit[N.x][N.y]=1;
		//对该点的上下左右进行遍历，如果符合条件，就入队列
		for(int i=0;i<4;i++)
		{
			int x=N.x+stepArr[i][0];
			int y=N.y+stepArr[i][1];
			if(x>=0 &&y>=0&&x<n&&y<n&&!visit[x][y]&& mazeArr[x][y]==0)
			{
				visit[x][y]=1;
				N=fuzhi(x,y,N.step+1);
				AppendQueue(&Q,N);
			}
		}
	}
	return -1;
}

void main()
{
	Node node;
	node=fuzhi(0,0,0);
	cout<<BFS(mazeArr,node,ROW_COL);
	getchar();
}