宽度优先搜索(记录路径)

迷宫问题 + 记录路径 + 结构体数组(模拟队列,因为我用不好指针记录前驱节点)

从终点向始点宽搜(其实这一题是深搜,无所谓啦)。每拓展一层,这一层的节点各自保存它是由哪个节点拓展来的。

Description

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

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
/*------default---------*/
const int maxn = 1e1 + 7;
int pic[maxn][maxn];
int n = 5;
struct Node {
	int x, y, pre;
}q[maxn];
int dir[4][2] = { { 0, -1 },{ 0, 1 },{ -1, 0 },{ 1, 0 } };
void BFS() {
	int front = 0, rear = 1;
	q[front] = { n - 1, n - 1, -1 };
	while (front < rear) {
		if (q[front].x == 0 && q[front].y == 0) {
			while (q[front].pre != -1) {
				cout << "(" << q[front].x << ", " << q[front].y << ")" << endl;
				front = q[front].pre;
			}
			cout << "(" << n - 1 << ", " << n - 1 << ")" << endl;
			break;
		}
		for (int i = 0; i < 4; ++i) {
			int x = q[front].x + dir[i][0];
			int y = q[front].y + dir[i][1];
			if (0 <= x && x < n && 0 <= y && y < n && pic[x][y] == 0) {
				pic[x][y] = 1;
				q[rear++] = { x, y, front };
			}
		}
		front++;
	}
}
int main()
{
	for (int i = 0; i < n; ++i)
		for (int j = 0; j < n; ++j)
			cin >> pic[i][j];
	BFS();
	return 0;
}




你可能感兴趣的:(搜索)