BDFZOI 迷宫问题

Posted 2020-09-05 tat296847

难度：普及

题目类型：BFS

提交次数：2

涉及知识：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)

代码：

 1 #include<iostream>
 2 #include<queue>
 3 #include<cstring>
 4 #include<stack> 
 5 using namespace std;
 6 int maze[6][6];
 7 struct node{
 8     int x, y, step;
 9 };
10 queue<node>q;
11 bool visited[5][5];
12 int dirx[4] = {1, 0, -1, 0};
13 int diry[4] = {0, 1, 0, -1};
14 node way[6][6];
15 stack<node> w;
16 
17 int main(){
18     int i, j;
19     for(i = 1; i <= 5; i++)
20         for(j = 1; j <= 5; j++){
21             cin>>maze[i][j]; 
22             if(maze[i][j] == 0)
23                 maze[i][j] = 2;
24         }
25     node p;        
26     p.x = 1;
27     p.y = 1;
28     p.step = 0;
29     q.push(p);
30     visited[1][1] = true;
31     while(!q.empty()){
32         p = q.front();
33         q.pop();
34         if(p.x == 5&&p.y == 5){
35             while(1){
36                 w.push(p);
37                 if(p.x==1&&p.y==1)
38                     break;
39                     p = way[p.x][p.y];
40             }
41             while(!w.empty()){
42                 p = w.top();
43                 cout<<"("<<p.x-1<<", "<<p.y-1<<")"<<endl;
44                 w.pop();
45             }
46             return 0;
47         }
48         for(i = 0; i < 4; i++){
49             int nx = p.x+dirx[i];
50             int ny = p.y+diry[i];
51             if(!visited[nx][ny]&&maze[nx][ny]==2){
52                 node no;
53                 no.x = nx;
54                 no.y = ny;
55                 no.step = p.step+1;
56                 q.push(no);
57                 way[nx][ny] = p; //记录前驱结点 
58                 visited[nx][ny] = true;
59             }
60         }
61     }
62     return 0;
63 }

备注：

BFS没什么好说的。用way这个二维数组记录一下前驱结点，然后走到终点的时候回溯。有一个地方当时想了一下：way里一定记录的是最短路径上的前驱结点。因为每个结点只访问一次，最短路径上的一定是先访问到的。