[已解决]迷宫问题

墨笠阳

调试时，有些数据运行结果是对的，但会报这个错误，有些数据运行结果有误，求大佬不吝指教

1. #define MAX_STACK_FindPath_SIZE 1275
   
2. #define MAX_ROW 50
   
3. #define MAX_COL 50
   
4. 
   
5. 
   
6. //位置
   
7. typedef struct  position {
   
8.         int x = 0;
   
9.         int y = 0;
   
10.         int pos = 1;//1，有障碍        0 无障碍        
    
11.         int step = 0;//1 已访问 0 未访问，-1 回退时再次访问
    
12. }position;
    
13. 
    
14. typedef struct {
    
15.         position* base;
    
16.         position* top;
    
17.         int stacksize;
    
18. }Stack;
    
19. 
    
20. //初始化
    
21. int InitStack_FindPath(Stack& S) {
    
22.         S.base = new position[MAX_STACK_FindPath_SIZE];
    
23.         if (!S.base)
    
24.                 return 0;
    
25.         else {
    
26.                 S.top = S.base;
    
27.                 S.stacksize = MAX_STACK_FindPath_SIZE;
    
28.                 return 1;
    
29.         }
    
30. }
    
31. 
    
32. int InitStack_maze(Stack& S) {
    
33.         int max = MAX_ROW * MAX_COL;
    
34.         S.base = new position[max];
    
35.         if (!S.base)
    
36.                 return 0;
    
37.         else {
    
38.                 S.top = S.base;
    
39.                 S.stacksize = max;
    
40.                 return 1;
    
41.         }
    
42. }
    
43. 
    
44. //入栈
    
45. int Push(Stack& S, position p) {
    
46.         if (S.top - S.base == S.stacksize)//栈满
    
47.                 return 0;
    
48.         else {               
    
49.                 *S.top = p;
    
50.                 S.top++;
    
51.                 return 1;
    
52.         }
    
53. }
    
54. 
    
55. //出栈
    
56. int Pop(Stack& S, position& p) {
    
57.         if (S.top == S.base)
    
58.                 return 0;
    
59.         else {
    
60.                
    
61.                 p = *(S.top - 1);
    
62. 
    
63.                 /*
    
64.                 p.x = (S.top - 1)->x;
    
65.                 p.y = (S.top - 1)->y;
    
66.                 p.pos = (S.top - 1)->pos;/**/
    
67.                 S.top--;
    
68.                 return 1;
    
69.         }
    
70. }
    
71. #include <iostream>
    
72. #include <malloc.h>
    
73. #include"struct.h"
    
74. using namespace std;
    
75. 
    
76. void Creat_maze(int row, int col, Stack& maze);
    
77. int FindPath(Stack& maze, Stack& pass, position* p,position start, position end, int row, int col);
    
78. int main() {
    
79.         position* p;//指向当前起点的指针
    
80.         Stack path;//通路
    
81.         Stack maze;//迷宫
    
82.         int m, n;//行、列
    
83.         
    
84.         //初始化指针p
    
85.         do {
    
86.                 p = new position;
    
87.         } while (!p);
    
88.         //初始化path栈、maze栈
    
89.         InitStack_FindPath(path);
    
90.         InitStack_maze(maze);
    
91. 
    
92.         cout << "迷宫规格m*n:\n" << "请输入m,n的值\n" << endl;
    
93.         cin >> m >> n;
    
94. 
    
95.         position start = { 0 ,0 ,0 };//入口
    
96.         position end = { m - 1 , n - 1, 0 };//出口
    
97. 
    
98.         cout << "\n1 表示不可通行，0 表示可通行\n" ;
    
99.         cout << "默认入口为第一个元素，出口为最后一个元素，" << "请输入迷宫元素\n" << endl;
    
100. 
     
101.         //构建迷宫m*n
     
102.         Creat_maze(m, n, maze);
     
103. 
     
104.         p = maze.base;
     
105.         Push(path, *p);
     
106. 
     
107.         if (FindPath(maze,path, p,start, end, m, n)) {
     
108.                 p = path.base;
     
109.                 cout << "通道为：" << endl;
     
110.                 while (p != path.top) {
     
111.                         cout << "\t(" << p->x << "," << p->y << ")" << endl;
     
112.                         p++;
     
113.                 }
     
114.                 delete p;
     
115.                 return 1;
     
116.         }
     
117.         else {
     
118.                 cout << "此迷宫无通路！" << endl;
     
119.                 delete p;
     
120.                 return 0;
     
121.         }
     
122. 
     
123. }
     
124. void Creat_maze(int row, int col, Stack& maze) {
     
125.         int i, j;
     
126.         position p;
     
127. 
     
128.         for (i = 0; i < row; i++) {
     
129.                
     
130.                 p.x = i;
     
131.                 for (j = 0; j < col; j++) {
     
132.                         p.y = j;
     
133.                         cin >> p.pos;
     
134.                         Push(maze, p);                        
     
135.                 }               
     
136.         }
     
137.         
     
138. }
     
139. 
     
140. /*
     
141. * 通道函数：
     
142. *        从起点出发，将起点入栈，标记其为已访问，然后依次对当前位置上，左，下，右进行深度遍历,
     
143. *        .1.若 p 所指的 position 的 上（左下右）可通，即 pos=0,且未被访问，即pos=0,则入栈pass
     
144. *   p.step=1 ,将新位置设为新起点，继续遍历,直到无前路
     
145. *
     
146. *        此过程中，如果访问到end，return 1,否则继续访问，直到遍历完成，return 0
     
147. */
     
148. int FindPath(Stack& maze, Stack& path, position* per, position start ,position end, int row, int col) {
     
149.         
     
150.         while (per!=&end) {//per未指向end
     
151.                 //向上
     
152.                 {
     
153.                         per = per - col;
     
154.                         if (!per && per->pos == 0 && per->step == 0) {//!per未越上边界,per->pos==0无障碍，per->step == 0未访问
     
155.                                                         //per->pos = 1;
     
156.                         //if (  per->pos == 0 && per->step == 0) {
     
157.                                 per->step = 1;
     
158.                                 Push(path, *per);
     
159.                                                 //FindPath(maze, path, per, start,end, row, col);
     
160.                                 if (FindPath(maze, path, per, start, end, row, col)) {
     
161.                                         return 1;
     
162.                                 }
     
163.                                 else {
     
164.                                         return 0;
     
165.                                 }
     
166.                         }
     
167.                         else
     
168.                                 per = per + col;
     
169.                 }
     
170.                 //向左
     
171.                 {
     
172.                         position p=*per;
     
173.                         per = per - 1;
     
174.                         if (!per&&p.x==per->x && per->pos == 0 && per->step == 0) {
     
175.                                 
     
176.                                 per->step = 1;
     
177.                                 Push(path, *per);
     
178.                                 
     
179.                                 if (FindPath(maze, path, per, start, end, row, col)) {
     
180.                                         return 1;
     
181.                                 }
     
182.                                 else {
     
183.                                         return 0;
     
184.                                 }
     
185.                         }
     
186.                         else
     
187.                                 per = per + 1;
     
188.                 }
     
189.                 //向下
     
190.                 {
     
191.                         per = per + col;
     
192.                         if (!(per->x==0&&per->y==0&&per->pos==1) && per->pos == 0 && per->step == 0) {
     
193.                                 per->step = 1;
     
194.                                 Push(path, *per);                                
     
195.                                 if (FindPath(maze, path, per, start, end, row, col)) {
     
196.                                         return 1;
     
197.                                 }
     
198.                                 else {
     
199.                                         return 0;
     
200.                                 }
     
201.                         }
     
202.                         else
     
203.                                 per = per - col;
     
204.                 }
     
205.                 //右
     
206.                 {
     
207.                         position p=*per;
     
208.                         per = per + 1;
     
209.                         if (!(per->x == 0 && per->y == 0 && per->pos == 1)&&p.x==per->x && per->pos == 0 && per->step == 0) {
     
210.                                 //p.x==per->x未到右界,per->pos==0无障碍且未访问
     
211.                                 per->step = 1;
     
212.                                 Push(path, *per);                        
     
213.                                 if (FindPath(maze, path, per, start, end, row, col)) {
     
214.                                         return 1;
     
215.                                 }
     
216.                                 else {
     
217.                                         return 0;
     
218.                                 }
     
219.                         }
     
220.                         else
     
221.                                 per = per - 1;
     
222.                 }
     
223.                 // 1,per==end,结束，有通路，，return 1
     
224.                 // 2,per!=end,回退：pop(FindPath,tem),(maze.base + (tem.x * row + tem.y))->step = -1
     
225.                 //退一格看一眼 上左下右
     
226.                 //FindPath(maze, FindPath, per, end, row, col);
     
227.                 // 直到per==end,有通路，结束
     
228.                 // 或者back==start，无通路，结束
     
229.                 {
     
230.                         if (per->x == end.x && per->y == end.y) {                                
     
231.                                 return 1;                                
     
232.                         }
     
233.                         else {
     
234.                                 position tem;
     
235.                                 Pop(path, tem);
     
236.                                 //cout << (path.top - 1)->x<< (path.top - 1)->y<<"\t";//输出回退后新栈顶元素，测试Pop(),经检验POp()无误
     
237.                                 if (tem.x == start.x && tem.y == start.y && tem.pos == 0) {
     
238.                                         return 0;
     
239.                                 }                                
     
240.                                 else {                                                                        
     
241.                                         per->x = (path.top - 1)->x;
     
242.                                         per->y = (path.top - 1)->y;
     
243.                                         per->pos = (path.top - 1)->pos;
     
244.                                         per->step = (path.top - 1)->step;
     
245.                                         per = maze.base + (per->x) * col + (per->y);                        
     
246.                                         if (FindPath(maze, path, per, start, end, row, col)) {
     
247.                                                 return 1;
     
248.                                         }
     
249.                                         else {
     
250.                                                 return 0;
     
251.                                         }
     
252.                                 }
     
253.                         }
     
254.                         
     
255.                 }
     
256. 
     
257.         }
     
258. 
     
259.         //per 指向了终点
     
260.         return 1;
     
261. 
     
262. }
     

复制代码

最佳答案

月排行榜 / 总排行榜

isdkz

2023-7-2 16:46:06

你的代码中的问题可能是来自于内存溢出、堆栈溢出、数组越界等问题，但是不幸的是，根据你的问题描述，很难确定确切的错误来源。这里有一些我觉得可能存在问题的地方：

1. 边界检查问题：你在处理“向上”、“向左”、“向下”、“向右”方向的时候，并没有进行充分的边界检查。比如在“向上”操作中，你是通过减去一个“列”数量的值来向上移动的，但是并没有判断当前位置是否在第一行，可能会导致越界访问。同理，“向左”、“向右”也存在同样的问题。

2. 内存管理问题：在main()函数中，你使用了 new 创建了一个 position 对象的指针，但是在函数结束的时候并没有释放它。并且在 FindPath() 函数的递归调用中也没有释放这个指针。这可能会导致内存泄漏。

3. 空指针访问：在 FindPath() 函数中， while(per!=&end) 的判断可能会出现问题。因为 per 可能不会指向 end ，这可能会造成无限循环。同时，如果 per 成为了空指针，程序可能会崩溃。

我建议你按照以下步骤进行调试：

1. 确保没有越界访问：对于每一次访问数组或者指针操作，都要确保没有越过其边界。

2. 检查内存管理：确保为每一个使用 new 分配的内存都有一个相应的 delete 来释放它。

3. 检查指针的有效性：在使用指针之前，确保它们已经被正确初始化并且没有被意外修改。

希望这些建议能对你有所帮助。如果还有其他的错误或者更详细的错误信息，欢迎继续提问。

跳转到最佳答案楼层

isdkz

你的代码中的问题可能是来自于内存溢出、堆栈溢出、数组越界等问题，但是不幸的是，根据你的问题描述，很难确定确切的错误来源。这里有一些我觉得可能存在问题的地方：

1. 边界检查问题：你在处理“向上”、“向左”、“向下”、“向右”方向的时候，并没有进行充分的边界检查。比如在“向上”操作中，你是通过减去一个“列”数量的值来向上移动的，但是并没有判断当前位置是否在第一行，可能会导致越界访问。同理，“向左”、“向右”也存在同样的问题。

2. 内存管理问题：在main()函数中，你使用了 new 创建了一个 position 对象的指针，但是在函数结束的时候并没有释放它。并且在 FindPath() 函数的递归调用中也没有释放这个指针。这可能会导致内存泄漏。

3. 空指针访问：在 FindPath() 函数中， while(per!=&end) 的判断可能会出现问题。因为 per 可能不会指向 end ，这可能会造成无限循环。同时，如果 per 成为了空指针，程序可能会崩溃。

我建议你按照以下步骤进行调试：

1. 确保没有越界访问：对于每一次访问数组或者指针操作，都要确保没有越过其边界。

2. 检查内存管理：确保为每一个使用 new 分配的内存都有一个相应的 delete 来释放它。

3. 检查指针的有效性：在使用指针之前，确保它们已经被正确初始化并且没有被意外修改。

希望这些建议能对你有所帮助。如果还有其他的错误或者更详细的错误信息，欢迎继续提问。

sfqxx

isdkz 发表于 2023-7-2 16:46
你的代码中的问题可能是来自于内存溢出、堆栈溢出、数组越界等问题，但是不幸的是，根据你的问题描述，很难 ...

我的 gpt 显示消息太长了

isdkz

sfqxx 发表于 2023-7-2 16:46
我的 gpt 显示消息太长了

现在官方的gpt应该加强了，之前也不行

sfqxx

isdkz 发表于 2023-7-2 16:48
现在官方的gpt应该加强了，之前也不行

我听说翻 墙次数多了会触犯法律规定

isdkz

sfqxx 发表于 2023-7-2 18:03
我听说翻 墙次数多了会触犯法律规定

sfqxx

isdkz 发表于 2023-7-2 18:23

真的，所以我不敢

陶远航

根据您提供的代码，很可能出现“Debug Assertion Failed”的原因是访问了无效的内存地址。这可能是由于在使用Pop函数时，出栈时访问了已被删除的指针的错误。

在FindPath函数的回退部分，您使用了Pop函数将栈顶元素弹出，并将其赋值给per指针。但是，在此之后，您又尝试通过per->x和per->y访问已经出栈的位置。这可能导致访问无效的内存。

要解决这个问题，您可以在执行Pop函数之前将栈顶元素保存到临时变量中，然后使用临时变量进行相关操作。

下面是对FindPath函数回退部分的修改：

1. {
   
2.     if (per->x == end.x && per->y == end.y) {
   
3.         return 1;
   
4.     }
   
5.     else {
   
6.         position tem;
   
7.         Pop(path, tem);
   
8.         if (tem.x == start.x && tem.y == start.y && tem.pos == 0) {
   
9.             return 0;
   
10.         }
    
11.         else {
    
12.             per = path.top - 1;  // 使用栈顶元素进行回退
    
13.             per = maze.base + (per->x) * col + (per->y);
    
14.             if (FindPath(maze, path, per, start, end, row, col)) {
    
15.                 return 1;
    
16.             }
    
17.             else {
    
18.                 return 0;
    
19.             }
    
20.         }
    
21.     }
    
22. }

复制代码

通过上述修改，应该可以避免访问无效的内存地址，并解决“Debug Assertion Failed”的问题。

歌者文明清理员

sfqxx 发表于 2023-7-2 18:30
真的，所以我不敢

www.github.com/dddddgz/cn-internet-bad

###为了不使论坛被墙掉发在github###

编程追风梦

根据提供的代码，我注意到您在 `FindPath` 函数中存在一个问题。在递归调用 `FindPath` 时，您在参数列表中将 `per` 传递给了 `end`，导致了不正确的递归调用。这会导致结果出错或产生异常。

下面是相关代码片段，我已经标出了问题所在：

1. //错误的递归调用
   
2. if (FindPath(maze, path, per, end, row, col)) {
   
3.     return 1;
   
4. }
   
5. else {
   
6.     return 0;
   
7. }
   

复制代码

为了修复这个问题，您应该将 `end` 替换为 `start`，如下所示：

1. if (FindPath(maze, path, per, start, end, row, col)) {
   
2.     return 1;
   
3. }
   
4. else {
   
5.     return 0;
   
6. }
   

复制代码

此外，还有几个注意事项：

1. 在 `Creat_maze` 函数中，您可以将 `Push(maze, p);` 放在内循环之外，以避免重复入栈。

2. 在 `FindPath` 函数中，`per = per + col;` 和 `per = per - col;` 这两行代码的位置需要调整，以确保在计算新位置之前将 `per` 恢复到原始位置。

请注意这些修正，并再次运行您的代码进行测试。

如果回答对你有帮助，给个最佳答案吧，求求了

墨笠阳

isdkz 发表于 2023-7-2 16:46
你的代码中的问题可能是来自于内存溢出、堆栈溢出、数组越界等问题，但是不幸的是，根据你的问题描述，很难 ...

谢谢您的回复，经过调试，我发现
1.初始化栈时，确实成功开辟了数组空间，可是指向栈内元素的指针 p 和 per，在 p = maze.base 之后，也为空，导致运行时 per 始终不向上和向左遍历
2.发生数组越界时，向上越界多为设定的position类型元素的默认值，向左越界时多为随机数值，如x= 40000        y= 0    pos= 153        step= -33686019，不知道为什么
3.内存管理问题：原先我使用new 开辟了一个position类型大小的空间，并将其首地址赋给了p,经过您的提醒，我检查了全文，补全了delete，可是仍然报了“Debug Assertion Failed”的错误，后来误打误撞把
p = new position;
        while (!p) {
                delete p;
                p = new position;
                //最终这个p将在程序结束时delete
        }
及对应的delete删除，未报该错误了，却不知道是为什么
4.在 FindPath()函数中， while(per!=&end)的判断确实可能出现问题了，因为&end未声明是maze栈出口的地址，只是存放了出口的 x ， y ,pos 等信息，现已将 end 和 start 改成指针类型，并使其分别指向 maze 栈的出口和入口
以上是我的新困惑，请不吝赐教
以下为修改后的代码

1. #include<malloc.h>
   
2. #define MAX_STACK_FindPath_SIZE 1275
   
3. #define MAX_ROW 50
   
4. #define MAX_COL 50
   
5. 
   
6. 
   
7. //位置
   
8. typedef struct  position {
   
9.     int x = 0;
   
10.     int y = 0;
    
11.     int pos = 1;//1，有障碍        0 无障碍        
    
12.     int step = 0;//1 已访问 0 未访问，-1 回退时再次访问
    
13. }position;
    
14. 
    
15. typedef struct {
    
16.     position* base;
    
17.     position* top;
    
18.     int stacksize;
    
19. }Stack;
    
20. 
    
21. //初始化
    
22. int InitStack_FindPath(Stack& S) {
    
23.     S.base = new position[MAX_STACK_FindPath_SIZE];
    
24.     if (!S.base)
    
25.         return 0;
    
26.     else {
    
27.         S.top = S.base;
    
28.         S.stacksize = MAX_STACK_FindPath_SIZE;
    
29.         return 1;
    
30.     }
    
31. }
    
32. 
    
33. int InitStack_maze(Stack& S) {
    
34.     int max = MAX_ROW * MAX_COL;
    
35.     S.base = new position[max];
    
36.     if (!S.base)
    
37.         return 0;
    
38.     else {
    
39.         S.top = S.base;
    
40.         S.stacksize = max;
    
41.         return 1;
    
42.     }
    
43. }
    
44. 
    
45. //入栈
    
46. int Push(Stack& S, position p) {
    
47.     if (S.top - S.base == S.stacksize)//栈满
    
48.         return 0;
    
49.     else {
    
50.         *S.top = p;
    
51.         S.top++;
    
52.         return 1;
    
53.     }
    
54. }
    
55. 
    
56. //出栈
    
57. int Pop(Stack& S, position& p) {
    
58.     if (S.top == S.base)
    
59.         return 0;
    
60.     else {
    
61.         p = *(S.top - 1);
    
62.         S.top--;
    
63.         return 1;
    
64.     }
    
65. }
    
66. #include<iostream>
    
67. #include"struct.h"
    
68. using namespace std;
    
69. 
    
70. void Creat_maze(Stack& maze, int row,int col);
    
71. int FindPath(Stack& maze, Stack& path, position* p, position* start,position* end,int row,int col);
    
72. int main() {
    
73.         Stack maze;
    
74.         Stack path;
    
75.         position* p;
    
76.         position* start, * end;
    
77.         int row, col;
    
78.         InitStack_FindPath(path);
    
79.         InitStack_maze(maze);
    
80.         cout << "请输入行数：" ;
    
81.         cin >> row;
    
82.         cout << "\n请输入列数：";
    
83.         cin >> col;
    
84.         cout << endl;
    
85.         Creat_maze(maze,row,col);
    
86.         start = maze.base;
    
87.         end = maze.top - 1;
    
88.         p = maze.base;
    
89. 
    
90.         if (p) {
    
91.                 cout << "NULL";
    
92.                 cout << "\tx= " << p->x << "\ty= " << p->y << "\tpos= " << p->pos << "\tstep= " << p->step << endl;
    
93.         }
    
94. 
    
95.         p->step = 1;
    
96.         if (FindPath(maze, path, p, start,end,row, col)) {
    
97.                 p = path.base;
    
98.                 while (p!=path.top) {                       
    
99.                         cout << "(" << p->x << "," << p->y << ")" << endl;
    
100.                         p++;
     
101.                 }
     
102.                 return 1;
     
103.         }
     
104.         else {
     
105.                 cout << "此迷宫无通路！" << endl;               
     
106.                 return 0;
     
107.         }
     
108. }
     
109. void Creat_maze(Stack& maze, int row, int col) {
     
110.         int i, j;
     
111.         position p;
     
112.         for (i = 0; i < row; i++) {
     
113.                 p.x = i;
     
114.                 for (j = 0; j < col; j++) {
     
115.                         p.y = j;
     
116.                         cin >> p.pos;
     
117.                         Push(maze, p);
     
118.                 }
     
119.         }
     
120. }
     
121. int FindPath(Stack& maze, Stack& path, position* p,  position* start, position* end, int row, int col) {
     
122.         position* per;
     
123.          {
     
124.                 //向上
     
125.                 {
     
126.                         per = p - col;
     
127.                         //验证per是否空
     
128.                         /**
     
129.                         if (per) {
     
130.                                 cout << "NULL";
     
131.                                 cout << "\tx= " << per->x << "\ty= " << per->y << "\tpos= " << per->pos << "\tstep= " << per->step<<endl;
     
132.                         }/**/
     
133.                         /**
     
134.                         if (p) {
     
135.                                 cout << "NULL";
     
136.                                 cout << "\tx= " << per->x << "\ty= " << per->y << "\tpos= " << per->pos << "\tstep= " << per->step << endl;
     
137.                         }/**/
     
138.                         if (!per && per->pos == 0 && per->step == 0) {
     
139.                                 //!per 未越上边界
     
140.                                 //per->pos == 0 无障碍
     
141.                                 //per->step == 0 未被访问
     
142.                                 Push(path, *per);
     
143.                                 per->step = 1;
     
144.                                 if (FindPath(maze, path, per, start, end, row, col)) {
     
145.                                         return 1;
     
146.                                 }
     
147.                                 else {
     
148.                                         return 0;
     
149.                                 }
     
150.                         }
     
151.                 }
     
152.                 //向左
     
153.                 {
     
154.                         per = p - 1;
     
155.                         /*
     
156.                         if (per) {
     
157.                                 cout << "NULL";
     
158.                                 cout << "\tx= " << per->x << "\ty= " << per->y << "\tpos= " << per->pos << "\tstep= " << per->step << endl;
     
159.                         }/**/
     
160.                         if (!per && p->x == per->x && per->pos == 0 && per->step == 0) {
     
161.                                 //!per && p->x == per->x 未越界
     
162.                                 Push(path, *per);
     
163.                                 per->step = 1;
     
164.                                 if (FindPath(maze, path, per, start, end, row, col)) {
     
165.                                         return 1;
     
166.                                 }
     
167.                                 else {
     
168.                                         return 0;
     
169.                                 }
     
170.                         }
     
171.                        
     
172.                 }
     
173.                 //向下
     
174.                 {
     
175.                         per = p + col;
     
176.                         if (!(per->x == 0 && per->y == 0 && per->pos == 1) && per->pos == 0 && per->step == 0) {
     
177.                                 //per->x == 0 && per->y == 0 && per->pos == 1 是position类型元素的默认值，表示maze栈外元素
     
178.                                 Push(path, *per);
     
179.                                 per->step = 1;
     
180.                                 if (FindPath(maze, path, per, start, end, row, col)) {
     
181.                                         return 1;
     
182.                                 }
     
183.                                 else {
     
184.                                         return 0;
     
185.                                 }
     
186.                         }
     
187.                 }
     
188.                 //向右
     
189.                 {
     
190.                         per = p + 1;
     
191.                         if (p->x == per->x && !(per->x == 0 && per->y == 0 && per->pos == 1) && per->pos == 0 && per->step == 0) {
     
192.                                 Push(path, *per);
     
193.                                 per->step = 1;
     
194.                                 if (FindPath(maze, path, per, start, end, row, col)) {
     
195.                                         return 1;
     
196.                                 }
     
197.                                 else {
     
198.                                         return 0;
     
199.                                 }
     
200.                         }
     
201.                 }
     
202. 
     
203.                 //判断，是出口
     
204.                 if (p == end) {
     
205.                         return 1;
     
206.                 }
     
207.                 //不是出口，回退，
     
208.                         //判断，新起点是入口，return 0，F
     
209.                         // 0 0 0
     
210.                         // 0 1 0
     
211.                         // 1 1 0
     
212.                         //否，遍历,F
     
213.                 //判断，回退后path栈空，return 0
     
214.                 //path栈未空，以栈顶元素为新起点再遍历
     
215.                 else {
     
216.                         position tem;
     
217.                         Pop(path, tem);
     
218.                         //per = (maze.base + (tem.x * row + tem.y));
     
219.                         //per = (maze.base + (path.top - 1)->x * col + (path.top - 1)->y);
     
220.                         /**if (per == start) {
     
221.                                 delete per;
     
222.                                 return 0;
     
223.                         }
     
224.                         else {
     
225.                                 if (FindPath(maze, path, per, start, end, row, col)) {
     
226.                                         delete per;
     
227.                                         return 1;
     
228.                                 }
     
229.                                 else {
     
230.                                         delete per;
     
231.                                         return 0;
     
232.                                 }
     
233.                         }/**/
     
234.                         if (path.base == path.top) {
     
235.                                 return 0;
     
236.                         }
     
237.                         else {
     
238.                                 per = (maze.base + (path.top - 1)->x * col + (path.top - 1)->y);
     
239.                                 if (FindPath(maze, path, per, start, end, row, col)) {
     
240.                                         return 1;
     
241.                                 }
     
242.                                 else {
     
243.                                         return 0;
     
244.                                 }
     
245.                         }
     
246.                                
     
247.                 }
     
248.          }
     
249. }
     
250. 
     

复制代码