迷宫问题（广度优先搜索BFS)

给定一个迷宫，入口为左上角，出口为右下角，问是否有路径从入口到出口，若有则输出一条这样的路径。注意移动可以从上、下、左、右、上左、上右、下左、下右八个方向进行。迷宫输入0表示可走，输入1表示墙。易得可以用1将迷宫围起来避免边界问题。

本题采用BFS算法给出解。注意，利用BFS算法给出的路径必然是一条最短路径。

[cpp]  view plain copy

1. /* 
2. 迷宫问题（八方向） 
3. input: 
4. 1 
5. 6 8 
6. 0 1 1 1 0 1 1 1 
7. 1 0 1 0 1 0 1 0 
8. 0 1 0 0 1 1 1 1 
9. 0 1 1 1 0 0 1 1 
10. 1 0 0 1 1 0 0 0 
11. 0 1 1 0 0 1 1 0 
12. output: 
13. YES 
14. (1,1) (2,2) (3,3) (3,4) (4,5) (4,6) (5,7) (6,8) 
15. */  
16. #include<iostream>  
17. #include<queue>  
18. #include<stack>  
19. using namespace std;  
20. struct point{  
21.     //横坐标纵坐标  
22.     int x;  
23.     int y;  
24. };  
25. int **Maze;     //初始化迷宫  
26. point **Pre;    //保存任意点在路径中的前一步  
27. point move[8]={{-1,-1},{-1,0},{-1,1},{0,-1},{0,1},{1,-1},{1,0},{1,1}};      //移动方向，横竖斜都可以，八个方向  
28. void Create(int row,int column){  
29.     //创建迷宫，注意到用0表示可走，1表示墙，将整个输入的迷宫再用墙围着，处理的时候就不用特别注意边界问题  
30.     int i,j;  
31.     for(i=0; i<row+2; i++)  
32.         Maze[i][0] = Maze[i][column+1] = 1;  
33.     for(j=0; j<column+2; j++)  
34.         Maze[0][j] = Maze[row+1][j] = 1;  
35.     for(i=1; i<=row; i++){  
36.         for(j=1; j<=column; j++){  
37.             cin>>Maze[i][j];  
38.         }  
39.     }  
40. }  
41. bool MazePath(int row,int column,int x,int y){  
42.     //判断是否有路径从入口到出口，保存该路径（队列）  
43.     if(x == row && y == column)return true;  
44.     queue<point> q;     //用于广度优先搜索  
45.     point now;          //当前位置  
46.     now.x = x;  
47.     now.y = y;  
48.     q.push(now);  
49.     Maze[now.x][now.y] = -1;  
50.     while(!q.empty()){  
51.         now = q.front();  
52.         q.pop();  
53.         for(int i=0; i<8; i++){  
54.             if(now.x + move[i].x == row && now.y + move[i].y == column){  
55.                 Maze[now.x + move[i].x][now.y + move[i].y] = -1;  
56.                 Pre[row][column] = now;  
57.                 return true;  
58.             }  
59.             if(Maze[now.x + move[i].x][now.y + move[i].y] == 0){  
60.                 point temp;     //下个位置  
61.                 temp.x = now.x + move[i].x;  
62.                 temp.y = now.y + move[i].y;  
63.                 q.push(temp);  
64.                 Maze[temp.x][temp.y] = -1;  
65.                 Pre[temp.x][temp.y] = now;  
66.   
67.             }  
68.         }  
69.     }  
70.     return false;  
71. }  
72. void PrintPath(int row,int column){  
73.     //输出最短路径  
74.     point temp;         //保存位置  
75.     stack<point> s;     //保存路径序列  
76.     temp.x = row;  
77.     temp.y = column;  
78.     while(temp.x != 1 || temp.y != 1){  
79.         s.push(temp);  
80.         temp = Pre[temp.x][temp.y];  
81.     }  
82.     cout<<"(1,1)";  
83.     while(!s.empty()){  
84.         temp = s.top();  
85.         cout<<' '<<'('<<temp.x<<','<<temp.y<<')';  
86.         s.pop();  
87.     }  
88.     cout<<endl;  
89. }  
90. int main(){  
91.     int t;          //用例数量  
92.     int row;        //迷宫行数  
93.     int column;     //迷宫列数  
94.     cin>>t;  
95.     while(t--){  
96.         cin>>row>>column;  
97.         Maze = new int*[row + 2];  
98.         Pre = new point*[row + 2];  
99.         for(int i=0; i<row+2; i++){  
100.             Maze[i] = new int[column + 2];  
101.             Pre[i] = new point[column + 2];  
102.         }  
103.         Create(row,column);  
104.         if(MazePath(row,column,1,1)){  
105.             cout<<"YES"<<endl;  
106.             PrintPath(row,column);  
107.         }  
108.         else cout<<"NO"<<endl;  
109.     }  
110.     return 0;  
111. }