ACM - 迷宫问题

迷宫问题

定义一个二维数组：
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)

BFS（广度优先搜索算法）：
广度优先搜索的优点是找出的第一条路径就是最短路径，常用来搜索最短路径。可以想象从入口处灌水，通过水的漫布进行层次式的搜索，一旦达到终点，停止搜索。可借助队列和树实现。

实现步骤：
（1）从入口元素开始，判断它上下左右的邻边元素是否满足条件，如果满足条件就入队列；
（2）取队首元素并出队列。寻找其相邻未被访问的元素，将其如队列并标记元素的前驱节点为队首元素。
（3）重复步骤（2），直到队列为空（没有找到可行路径）或者找到了终点。最后从终点开始，根据节点的前驱节点找出一条最短的可行路径。

代码：

#include<iostream>
#include<vector>
#include<queue>
#include<string>
using namespace std;

struct node {
	int x;
	int y;
	int pre;  // 前驱点：树结构实现
	int flag; // flag为0表示该点可以走
	node(int x_ = 0, int y_ = 0, int flag_ = 1, int pre_ = -1)
	{
		x = x_; y = y_; flag = flag_; pre = pre_;
	}
};

int f[4][2] = { -1, 0, 1, 0, 0, -1, 0, 1 };  // 定义四个方向
node maze[5][5];  // 迷宫
int head = 0;  // 用于创建树
queue<node> q;
vector<node> qs;

// 满足条件的新点加入队列
void work(const node &n)
{
	int nx, ny;
	for (int i = 0; i < 4; i++)
	{
		nx = n.x + f[i][0]; ny = n.y + f[i][1]; // 点向四个方向扩展
		if (nx < 0 || nx > 4 || ny < 0 || ny > 4) {
			continue;
		}
		node &e = maze[nx][ny];
		if (e.flag == 0) {
			e.flag = 1;
			e.pre = head;
			q.push(e);
		}
	}
}
void print_s(node a) //实现路径输出的函数（递归）
{
	if (a.pre == -1) {
		printf("(%d, %d)\n", a.x, a.y);
		return;
	}
	else {
		print_s(qs[a.pre]);
		printf("(%d, %d)\n", a.x, a.y);
	}
}
int main()
{
	int e;
	for (int i = 0; i <= 4; i++)
	{
		for (int j = 0; j <= 4; j++)
		{
			cin >> e;
			maze[i][j].x = i;
			maze[i][j].y = j;
			if (e == 0) maze[i][j].flag = 0;
			else maze[i][j].flag = 1;
		}
	}
	// BFS（广度优先搜索）: 使用队列
	maze[0][0].flag = 1;  // 第一个点特殊，flag初始为1
	q.push(maze[0][0]);
	node q_fro = q.front();
	while (q_fro.x != 4 || q_fro.y != 4) {
		q_fro = q.front();
		qs.push_back(q_fro);
		work(q_fro);
		head++;
		q.pop();
	}
	print_s(qs.back());
}