迷宫求解

1. 递归回溯法思路：

　　从入口处发，顺着某一个方向向前探索，若能走通则继续向前走；否则沿原路回溯，换一个方向再继续探索，直到所有可能通路都探索为止，如果恰好某一步找到出口，程序则返回。

 1 #include <iostream>
 2 using namespace std;
 3 
 4 void print_maze(int maze[][10])
 5 {
 6     for (int i = 0; i < 10; i++)
 7     {
 8         for (int j = 0; j < 10; j++)
 9         {
10             if (maze[i][j] == 0)
11                 printf ("□");
12             else if (maze[i][j] == 2)
13                 printf ("★");
14             else
15                 printf ("■");
16             
17         }
18         printf("\n");
19     }
20 }
21 
22 bool FindPath(int maze[][10], int begx, int begy, int endx, int endy)
23 {
24     // 找到通道
25     if ( (begx == endx) && (begy == endy) )
26     {
27         maze[begx][begy] = 2;
28         
29         return true;
30     }
31     else
32     {
33         if (maze[begx][begy] == 0)        //当前路径可通
34         {
35             
36             maze[begx][begy] = 2;        //此路径可通, 留下足迹
37 
38             if ( FindPath (maze, begx+1, begy, endx, endy) ||    // 向南寻找路径
39                  FindPath (maze, begx-1, begy, endx, endy) ||    // 南路走不通，向北寻找路径
40                  FindPath (maze, begx, begy+1, endx, endy) ||    // 南路和北路走不通，向东寻找路径
41                  FindPath (maze, begx, begy-1, endx, endy) )    // 南北东都走不通，向西寻找路径
42             {
43                 return true;
44             }
45             else
46             {
47                 maze[begx][begy] = 0;    //此路不可通，退回原路
48                 return false;
49             }
50         }
51         else                            //当前路径不能通
52         {
53             return false;
54         }
55     }
56 }
57 
58 int main(void)
59 {　　
60     int maze[10][10] = {　　//地图，1表示城墙，0表示道路
61         1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
62         1, 0, 0, 1, 0, 0, 0, 1, 0, 1,
63         1, 1, 0, 1, 0, 0, 0, 1, 0, 1,
64         1, 0, 0, 0, 0, 1, 1, 0, 0, 1,
65         1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 
66         1, 0, 0, 0, 1, 0, 1, 0, 0, 1,
67         1, 0, 1, 0, 0, 0, 1, 0, 0, 1,
68         1, 1, 1, 1, 1, 1, 1, 1, 0, 1,
69         1, 1, 0, 0, 0, 0, 0, 0, 0, 1,
70         1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
71     };
72 
73     FindPath(maze, 1, 1, 8, 8);
74     print_maze(maze);
75 
76     return 0;
77 }

 2. 深度优先搜索法解题思路：

　　沿某一个方向一步探索，每走一步都在当前位置留下足迹、并将当前位置入栈。若是无路可走则将当前位置的上一个位置出栈作为下一次探索的当前位置。

 1 typedef struct {
 2     int x;
 3     int y;
 4 }point;
 5 
 6 point stack[100] = {0};        //迷宫存储路径
 7 int top = -1;                //栈顶
 8 
 9 bool DFS_FindPath(int maze[][10], point beg, point end)
10 {
11     bool is_bracktrack;            //是否需要回溯
12 
13     while (true)
14     {
15 
16         is_bracktrack = true;
17 
18         if ( beg.x == end.x && beg.y == end.y )
19         {stack[++top] = beg; return true;}
20         
21 
22         if ( maze[beg.x][beg.y] == 0 )            //当前位置可通，留下足迹并加入到栈
23             maze[beg.x][beg.y] = 2, stack[++top] = beg;
24 
25         if ( maze[beg.x][beg.y+1] == 0 )        //向东走
26         {
27             maze[beg.x][++beg.y] = 2;
28             stack[++top].x = beg.x;
29             stack[top].y = beg.y;
30             is_bracktrack = false;
31         }
32         else if ( maze[beg.x+1][beg.y] == 0 )    //向南走
33         {
34             maze[++beg.x][beg.y] = 2;
35             stack[++top].x = beg.x;
36             stack[top].y = beg.y;
37             is_bracktrack = false;
38         }
39         else if ( maze[beg.x][beg.y-1] == 0 )    //向西走
40         {
41             maze[beg.x][--beg.y] = 2;
42             stack[++top].x = beg.x;
43             stack[top].y = beg.y;
44             is_bracktrack = false;
45         }
46         else if ( maze[beg.x-1][beg.y] == 0 )    //向北走
47         {
48             maze[--beg.x][beg.y] = 2;
49             stack[++top].x = beg.x;
50             stack[top].y = beg.y;
51             is_bracktrack = false;
52         }
53         else    //无路可走，回溯
54         {
55             if (top < 0)
56                 return false;
57             beg = stack[--top];
58         }
59         
60     }
61 
62     return false;
63 }
64 
65 
66 
67 int main(void)
68 {
69     int maze[10][10] = {
70         1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
71         1, 0, 0, 1, 0, 0, 0, 1, 0, 1,
72         1, 1, 0, 1, 0, 0, 0, 1, 0, 1,
73         1, 0, 0, 0, 1, 1, 0, 0, 0, 1,
74         1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 
75         1, 0, 1, 0, 1, 0, 1, 0, 0, 1,
76         1, 0, 0, 0, 1, 0, 1, 0, 0, 1,
77         1, 1, 1, 1, 1, 1, 1, 1, 0, 1,
78         1, 1, 0, 0, 0, 0, 0, 0, 0, 1,
79         1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
80     };
81 
82     point beg;
83     point end;
84 
85     beg.x = 1;
86     beg.y = 1;
87     end.x = 8;
88     end.y = 8;
89     cout << DFS_FindPath(maze, beg, end) << endl;;
90 
91 
92 
93     print_maze(maze);
94 
95 
96     return 0;
97 }

 

转载于:https://www.cnblogs.com/Jer-/archive/2013/04/29/3050511.html