迷宫问题（116）

最新推荐文章于 2021-04-12 16:55:31 发布

stack-0

最新推荐文章于 2021-04-12 16:55:31 发布

阅读量260

点赞数

分类专栏： c语言项目

本文链接：https://blog.csdn.net/qq_33033983/article/details/52927353

版权

c语言项目专栏收录该内容

65 篇文章 1 订阅

订阅专栏

本文介绍了一种基于广度优先搜索的迷宫寻路算法，并通过C语言实现了该算法。利用队列来保存待探索的迷宫位置，通过遍历八个方向来寻找可能的路径。当找到终点时，通过回溯记录的前驱节点来确定从起点到终点的最短路径。

摘要由CSDN通过智能技术生成

源代码：

#include <stdio.h>
#include <stdlib.h>

int maze[6+2][8+2] = {
	{1,1,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,0,1,1,1,1},
	{1,1,0,1,0,1,0,1,0,1},
	{1,0,1,0,0,1,1,1,1,1},
	{1,0,1,1,1,0,0,1,1,1},
	{1,1,0,0,1,1,0,0,0,1},
	{1,0,1,1,0,0,1,1,0,1},
	{1,1,1,1,1,1,1,1,1,1}
};

typedef struct {
	int i,j;			//方块的位置
	int pre;        	//记录前一步的位置 
} Mark;

typedef struct {
	Mark maze[60];        
	int rear, front;			//队尾，队首指针 
} Queue;			//定义一个顺序队列 

int path (int xb, int yb, int xe, int ye) {
	Queue a;
	int find = 0;
	int i,j,k;
	
	a.front = a.rear = -1;			//初始化队列
	a.rear++;			//入队
	a.maze[a.rear].i = xb;
	a.maze[a.rear].j = yb;
	a.maze[a.rear].pre = -1;
	maze[xb][yb] = -1;			//避免重复搜索
	 
	while (a.front!=a.rear && !find) {
		a.front++;
		i = a.maze[a.front].i;
		j = a.maze[a.front].j;			//出队
		if (i==xe && j==ye) {
			find = 1;
			print(a,a.front);
			return 1;
		}
		
		for (k=0; k<8; k++) {
			switch (k) {
				case 0:
					i = a.maze[a.front].i - 1;
					j = a.maze[a.front].j;
					break;
				case 1:
					i = a.maze[a.front].i - 1;
					j = a.maze[a.front].j + 1;
					break;
				case 2:
					i = a.maze[a.front].i;
					j = a.maze[a.front].j + 1;
					break;
				case 3:
					i = a.maze[a.front].i + 1;
					j = a.maze[a.front].j + 1;
					break;
				case 4:
					i = a.maze[a.front].i + 1;
					j = a.maze[a.front].j;
					break;
				case 5:
					i = a.maze[a.front].i + 1;
					j = a.maze[a.front].j - 1;
					break;
				case 6:
					i = a.maze[a.front].i;
					j = a.maze[a.front].j - 1;
					break;
				case 7:
					i = a.maze[a.front].i - 1;
					j = a.maze[a.front].j - 1;
					break;
			}
			if (maze[i][j]==0) {
				a.rear++;			//将相邻的方块入队 
				a.maze[a.rear].i = i;
				a.maze[a.rear].j = j;
				a.maze[a.rear].pre = a.front;
				maze[i][j] = -1;
			}
		} 
		
	}
	return 0; 
}  

void print (Queue a, int front) {
	int j,k;
	k = front;
	while (k != 0) {			//倒序找最短路径 
		j = k;
		k = a.maze[k].pre;
		a.maze[j].pre = -1;
	}
	
	k = 0;
	while (k<=front) {
		if (a.maze[k].pre == -1) {
		    printf("(%d,%d) ", a.maze[k].i, a.maze[k].j);
		}
		k++;
	}
	return ;
}

int main() {
	path(1, 1, 6, 8);
	return 0;
}

运行结果：