openjudge.迷宫问题（bfs&&记录路径）（C语言）

openjudge.迷宫问题（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)

题解：就是简单的迷宫问题，题目要求求最短路径，直接就是简单的bfs就能解决，没什么新的花样特别之处，写这篇博客，只要是想写第一个有关记录路径的博客。
记录路径思路：方法就是：记录当前节点的父节点，按照这个思路每一个路径上的节点都能找到自己的上一个节点，所以只要从终点开始回溯就能输出完整的路径。
上代码：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct node
{
	int x, y;
	int pre;
}strnode;
int ans;
strnode que[200];
int d[4][2] = { {-1,0},{0,-1},{1,0},{0,1} };
int map[5][5];
int vis[5][5];
void bfs()
{
	memset(vis, 0, sizeof(vis));
	int head = 0, tail = 0, i = 0;
	que[tail].x = 0;
	que[tail].y = 0;
	que[tail++].pre = -1;
	vis[0][0] = 1;
	while (head < tail)
	{
		strnode temp = que[head++];
		if (temp.x == 4 && temp.y == 4)
		{
			ans = head - 1;
			return;
		}
		for (i = 0; i < 4; i++)
		{
			int dx = temp.x + d[i][0];
			int dy = temp.y + d[i][1];
			if (!vis[dx][dy] && !map[dx][dy]&&dx>=0&&dy>=0&&dx<5&&dy<5)
			{
				que[tail].x = dx;
				que[tail].y = dy;
				que[tail++].pre = head - 1;
				vis[dx][dy] = 1;
			}
		}
	}
}
void print(int ans)
{
	if (que[ans].pre != -1)
	{
		print(que[ans].pre);
	}
	printf("(%d, %d)\n", que[ans].x, que[ans].y);
	return;
}
int main()
{
	int i = 0, k, j = 0;
	for (i = 0; i <5; i++)
	{
		for (j = 0; j < 5; j++) {
			scanf("%d", &map[i][j]);
		}
	}
	bfs();
	print(ans);
	return 0;
}

就是两个函数：

bfs函数：普通的bfs，没什么特别之处，不多说；

回溯输出函数：注意回溯和输出的两个语句的顺序就没什么问题

总结：主要是要想到用父节点来记录路径