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
2
3
4
5
6
7
8
9

};

它表示一个迷宫，其中的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)

Source

原题链接

简单思路

dfs思路：

普通的搜索。（很水）

bfs思路：

将每个能走得边存入队列，如果当前点在右下角break。

存路径思路：

一个node类型的二维数组，每个点记录，他从那来。
最后用递归输出路径。

void print(node tmp) {
	if (tmp.x == 0 && tmp.y == 0) {
		cout << "(0, 0)" << endl;
		return ;
	}
	print(path[tmp.x][tmp.y]);
	cout << "(" << tmp.x << ", " << tmp.y << ")" << endl;
}
1
2
3
4
5
6
7
8

最后附上完整代码

#include 
#include 

using namespace std;

struct node {
	int x, y;
};
int a[10][10], vis[11][11];
node path[110][110];
int dir[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};

void print(node tmp) {
	if (tmp.x == 0 && tmp.y == 0) {
		cout << "(0, 0)" << endl;
		return ;
	}
	print(path[tmp.x][tmp.y]);
	cout << "(" << tmp.x << ", " << tmp.y << ")" << endl;
}

int main() {
	for (int i = 0; i < 5; i++) {
		for (int j = 0; j < 5; j++) {
			cin >> a[i][j];
		}
	}
	queue <node> q;
	node ttt;
	ttt.x = 0, ttt.y = 0;
	q.push(ttt);
	vis[0][0] = 1;
	while (!q.empty()) {
		node now = q.front();
		q.pop();
		if (now.x == 4 && now.y == 4) break;
		for (int i = 0; i < 4; i++) {
			node nod;
			nod.x = now.x + dir[i][0];
			nod.y = now.y + dir[i][1];
			if (nod.x >= 0 && nod.x < 5 && nod.y >= 0 && nod.y < 5 && vis[nod.x][nod.y] == 0 && a[nod.x][nod.y] == 0) {
				vis[nod.x][nod.y] = 1;
				q.push(nod);
				path[nod.x][nod.y] = now;
			}
		}
	}
	node t;
	t.x = 4, t.y = 4;
	print(t);
	return 0;
	//完成
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53