[已解决]疑惑。为什么函数里面代码不执行

御坂19090

为什么GetPath这个函数一进去就跳过？不进循环。想不通

1. #include <iostream>
   
2. #include <queue>
   
3. #include <string>
   
4. using namespace std;
   
5. 
   
6. struct Index
   
7. {
   
8.     int x, y;
   
9. };
   
10. 
    
11. struct Data
    
12. {
    
13.     char ch;
    
14.     Index In;
    
15. };
    
16. 
    
17. Data mg[40][60];
    
18. bool vestige[40][60];
    
19. Index dire[4] = { {1,0},{0,-1},{0,1},{-1,0} };
    
20. char sym[4] = { 'D','L','R','U' };
    
21. 
    
22. void sqfa(int x, int y)
    
23. {
    
24.     queue<Index> q;
    
25.     q.push({ 1,1 });
    
26.     vestige[1][1] = true;
    
27. 
    
28.     while (!q.empty())
    
29.     {
    
30.         Index node = q.front();
    
31.         for (int i = 0; i < 4; i++)
    
32.         {
    
33.             Index t = { node.x + dire[i].x, node.y + dire[i].y };
    
34.             if (mg[t.x][t.y].ch == '1' && !vestige[t.x][t.y])
    
35.             {
    
36.                 mg[t.x][t.y].In = node;
    
37.                 vestige[t.x][t.y] = true;
    
38.                 q.push(t);
    
39.             }
    
40.         }
    
41.         q.pop();
    
42.     }
    
43. }
    
44. 
    
45. string GetPath(int x, int y)
    
46. {
    
47.     Index data{ x, y };
    
48.     string S;
    
49. 
    
50.     for (; data.x != 1 || data.y != 1; data = mg[data.x][data.y].In)
    
51.     {
    
52.         Index V = { data.x - mg[data.x][data.y].In.x, data.y - mg[data.x][data.y].In.y };
    
53. 
    
54.         for (int i = 0; i < 4; i++)
    
55.         {
    
56.             if (V.x == dire[i].x && V.y == dire[i].y)
    
57.             {
    
58.                 S = sym[i] + S;
    
59.                 break;
    
60.             }
    
61.         }
    
62.     }
    
63. 
    
64.     return S;
    
65. }
    
66. 
    
67. 
    
68. int main()
    
69. {
    
70.     // 请在此输入您的代码
    
71.     for (int i = 0; i < 30; i++)
    
72.         for (int j = 0; j < 50; j++)
    
73.         {
    
74.             cin >> mg[i + 1][j + 1].ch;
    
75.             mg[i + 1][j + 1].ch++;
    
76.         }
    
77. 
    
78.     sqfa(1, 1);
    
79. 
    
80.     cout << GetPath(30, 50);
    
81. 
    
82.     return 0;
    
83. }

复制代码

然后这个是输入的参数

1. 01010101001011001001010110010110100100001000101010
   
2. 00001000100000101010010000100000001001100110100101
   
3. 01111011010010001000001101001011100011000000010000
   
4. 01000000001010100011010000101000001010101011001011
   
5. 00011111000000101000010010100010100000101100000000
   
6. 11001000110101000010101100011010011010101011110111
   
7. 00011011010101001001001010000001000101001110000000
   
8. 10100000101000100110101010111110011000010000111010
   
9. 00111000001010100001100010000001000101001100001001
   
10. 11000110100001110010001001010101010101010001101000
    
11. 00010000100100000101001010101110100010101010000101
    
12. 11100100101001001000010000010101010100100100010100
    
13. 00000010000000101011001111010001100000101010100011
    
14. 10101010011100001000011000010110011110110100001000
    
15. 10101010100001101010100101000010100000111011101001
    
16. 10000000101100010000101100101101001011100000000100
    
17. 10101001000000010100100001000100000100011110101001
    
18. 00101001010101101001010100011010101101110000110101
    
19. 11001010000100001100000010100101000001000111000010
    
20. 00001000110000110101101000000100101001001000011101
    
21. 10100101000101000000001110110010110101101010100001
    
22. 00101000010000110101010000100010001001000100010101
    
23. 10100001000110010001000010101001010101011111010010
    
24. 00000100101000000110010100101001000001000000000010
    
25. 11010000001001110111001001000011101001011011101000
    
26. 00000110100010001000100000001000011101000000110011
    
27. 10101000101000100010001111100010101001010000001000
    
28. 10000010100101001010110000000100101010001011101000
    
29. 00111100001000010000000110111000000001000000001011
    
30. 10000001100111010111010001000110111010101101111000
    

复制代码

最佳答案

月排行榜 / 总排行榜

不二猫猫

2023-3-23 17:53:58

1. 
   
2. 
   
3. ```c++
   
4. #include <iostream>
   
5. #include <queue>
   
6. #include <string>
   
7. using namespace std;
   
8. 
   
9. // 二维坐标结构体
   
10. struct Index
    
11. {
    
12.     int x, y;
    
13. };
    
14. 
    
15. // 迷宫中每个位置的数据结构体
    
16. struct Data
    
17. {
    
18.     char ch;    // 储存当前位置的字符（0 或 1）
    
19.     Index In;   // 储存当前位置的前驱（用于求解最短路径）
    
20. };
    
21. 
    
22. Data mg[40][60];        // 迷宫矩阵
    
23. bool visited[40][60];   // 标记某个位置是否已经被访问过
    
24. Index dire[4] = { {1,0},{0,-1},{0,1},{-1,0} };    // 方向数组，用于 BFS 遍历迷宫
    
25. char sym[4] = { 'D','L','R','U' };                // 路径方向符号，用于记录最短路径
    
26. 
    
27. // 广度优先搜索函数，用于遍历迷宫并记录每个位置的前驱
    
28. void bfs(int x, int y)
    
29. {
    
30.     queue<Index> q;
    
31.     q.push({ 1,1 });         // 先将起点放入队列中
    
32.     visited[1][1] = true;    // 标记起点已经被访问过
    
33. 
    
34.     while (!q.empty())
    
35.     {
    
36.         // 取出队首元素
    
37.         Index node = q.front();
    
38.         for (int i = 0; i < 4; i++)     // 遍历当前位置的四个方向
    
39.         {
    
40.             Index t = { node.x + dire[i].x, node.y + dire[i].y };    // 计算下一个位置的坐标
    
41.             if (mg[t.x][t.y].ch == '1' && !visited[t.x][t.y])        // 如果下一个位置可行且未访问过
    
42.             {
    
43.                 mg[t.x][t.y].In = node;     // 更新下一个位置的前驱为当前位置
    
44.                 visited[t.x][t.y] = true;   // 标记下一个位置已经被访问过
    
45.                 q.push(t);                  // 将下一个位置加入队列中
    
46.             }
    
47.         }
    
48.         q.pop();    // 将当前位置出队
    
49.     }
    
50. }
    
51. 
    
52. // 求解最短路径函数，根据迷宫中每个位置的前驱反向遍历得到最短路径
    
53. string getPath(int x, int y)
    
54. {
    
55.     Index data{ x, y };
    
56.     string S;
    
57. 
    
58.     for (; data.x != 1 || data.y != 1; data = mg[data.x][data.y].In)
    
59.     {
    
60.         // 利用前驱计算当前位置相对于前驱的偏移量，从而确定当前位置的方向
    
61.         Index V = { data.x - mg[data.x][data.y].In.x, data.y - mg[data.x][data.y].In.y };
    
62. 
    
63.         // 查找当前位置与前驱的偏移量在方向数组中的下标，记录对应的方向符号
    
64.         for (int i = 0; i < 4; i++)
    
65.         {
    
66.             if (V.x == dire[i].x && V.y == dire[i].y)
    
67.             {
    
68.                 S = sym[i] + S;     // 将方向符号加入路径字符串中
    
69.                 break;
    
70.             }
    
71.         }
    
72.     }
    
73. 
    
74.     return S;
    
75. }
    
76. 
    
77. int main()
    
78. {
    
79.     // 请在此输入您的代码
    
80.     for (int i = 1; i <= 30; i++)
    
81.         for (int j = 1; j <= 50; j++)
    
82.         {
    
83.             cin >> mg[i][j].ch;                 // 读入迷宫矩阵
    
84.             visited[i][j] = false;             // 初始化每个位置的访问状态为未访问
    
85.         }
    
86. 
    
87.     bfs(1, 1);     // 遍历迷宫并记录每个位置的前驱
    
88. 
    
89.     cout << getPath(30, 50);    // 求解最短路径
    
90. 
    
91.     return 0;
    
92. }
    
93. ```
    
94. 
    
95. 错处在于：
    
96. 
    
97. - 在输入迷宫矩

复制代码

跳转到最佳答案楼层

不二猫猫

1. 
   
2. 
   
3. ```c++
   
4. #include <iostream>
   
5. #include <queue>
   
6. #include <string>
   
7. using namespace std;
   
8. 
   
9. // 二维坐标结构体
   
10. struct Index
    
11. {
    
12.     int x, y;
    
13. };
    
14. 
    
15. // 迷宫中每个位置的数据结构体
    
16. struct Data
    
17. {
    
18.     char ch;    // 储存当前位置的字符（0 或 1）
    
19.     Index In;   // 储存当前位置的前驱（用于求解最短路径）
    
20. };
    
21. 
    
22. Data mg[40][60];        // 迷宫矩阵
    
23. bool visited[40][60];   // 标记某个位置是否已经被访问过
    
24. Index dire[4] = { {1,0},{0,-1},{0,1},{-1,0} };    // 方向数组，用于 BFS 遍历迷宫
    
25. char sym[4] = { 'D','L','R','U' };                // 路径方向符号，用于记录最短路径
    
26. 
    
27. // 广度优先搜索函数，用于遍历迷宫并记录每个位置的前驱
    
28. void bfs(int x, int y)
    
29. {
    
30.     queue<Index> q;
    
31.     q.push({ 1,1 });         // 先将起点放入队列中
    
32.     visited[1][1] = true;    // 标记起点已经被访问过
    
33. 
    
34.     while (!q.empty())
    
35.     {
    
36.         // 取出队首元素
    
37.         Index node = q.front();
    
38.         for (int i = 0; i < 4; i++)     // 遍历当前位置的四个方向
    
39.         {
    
40.             Index t = { node.x + dire[i].x, node.y + dire[i].y };    // 计算下一个位置的坐标
    
41.             if (mg[t.x][t.y].ch == '1' && !visited[t.x][t.y])        // 如果下一个位置可行且未访问过
    
42.             {
    
43.                 mg[t.x][t.y].In = node;     // 更新下一个位置的前驱为当前位置
    
44.                 visited[t.x][t.y] = true;   // 标记下一个位置已经被访问过
    
45.                 q.push(t);                  // 将下一个位置加入队列中
    
46.             }
    
47.         }
    
48.         q.pop();    // 将当前位置出队
    
49.     }
    
50. }
    
51. 
    
52. // 求解最短路径函数，根据迷宫中每个位置的前驱反向遍历得到最短路径
    
53. string getPath(int x, int y)
    
54. {
    
55.     Index data{ x, y };
    
56.     string S;
    
57. 
    
58.     for (; data.x != 1 || data.y != 1; data = mg[data.x][data.y].In)
    
59.     {
    
60.         // 利用前驱计算当前位置相对于前驱的偏移量，从而确定当前位置的方向
    
61.         Index V = { data.x - mg[data.x][data.y].In.x, data.y - mg[data.x][data.y].In.y };
    
62. 
    
63.         // 查找当前位置与前驱的偏移量在方向数组中的下标，记录对应的方向符号
    
64.         for (int i = 0; i < 4; i++)
    
65.         {
    
66.             if (V.x == dire[i].x && V.y == dire[i].y)
    
67.             {
    
68.                 S = sym[i] + S;     // 将方向符号加入路径字符串中
    
69.                 break;
    
70.             }
    
71.         }
    
72.     }
    
73. 
    
74.     return S;
    
75. }
    
76. 
    
77. int main()
    
78. {
    
79.     // 请在此输入您的代码
    
80.     for (int i = 1; i <= 30; i++)
    
81.         for (int j = 1; j <= 50; j++)
    
82.         {
    
83.             cin >> mg[i][j].ch;                 // 读入迷宫矩阵
    
84.             visited[i][j] = false;             // 初始化每个位置的访问状态为未访问
    
85.         }
    
86. 
    
87.     bfs(1, 1);     // 遍历迷宫并记录每个位置的前驱
    
88. 
    
89.     cout << getPath(30, 50);    // 求解最短路径
    
90. 
    
91.     return 0;
    
92. }
    
93. ```
    
94. 
    
95. 错处在于：
    
96. 
    
97. - 在输入迷宫矩

复制代码

小甲鱼的二师兄

根据代码，函数GetPath的输入参数为目标点的横纵坐标，即x和y。

在主函数中，目标点的横纵坐标分别为30和50。

然而，在初始化地图mg时，只输入了1到30行和1到50列的内容，并对每个字符加了1。

因此，地图实际上是空的，所有格子的值都为0，而不是输入的字符加1。

这就导致在获取路径时，程序无法进入while循环，因为起点和终点都没有被找到，mg数组始终没有被更新。

解决方法是修改初始化地图的代码，使其正确读取输入的字符并存储在mg数组中即可。