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

御坂19090

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

#include <iostream>
#include <queue>
#include <string>
using namespace std;

struct Index
{
    int x, y;
};

struct Data
{
    char ch;
    Index In;
};

Data mg[40][60];
bool vestige[40][60];
Index dire[4] = { {1,0},{0,-1},{0,1},{-1,0} };
char sym[4] = { 'D','L','R','U' };

void sqfa(int x, int y)
{
    queue<Index> q;
    q.push({ 1,1 });
    vestige[1][1] = true;

    while (!q.empty())
    {
        Index node = q.front();
        for (int i = 0; i < 4; i++)
        {
            Index t = { node.x + dire[i].x, node.y + dire[i].y };
            if (mg[t.x][t.y].ch == '1' && !vestige[t.x][t.y])
            {
                mg[t.x][t.y].In = node;
                vestige[t.x][t.y] = true;
                q.push(t);
            }
        }
        q.pop();
    }
}

string GetPath(int x, int y)
{
    Index data{ x, y };
    string S;

    for (; data.x != 1 || data.y != 1; data = mg[data.x][data.y].In)
    {
        Index V = { data.x - mg[data.x][data.y].In.x, data.y - mg[data.x][data.y].In.y };

        for (int i = 0; i < 4; i++)
        {
            if (V.x == dire[i].x && V.y == dire[i].y)
            {
                S = sym[i] + S;
                break;
            }
        }
    }

    return S;
}


int main()
{
    // 请在此输入您的代码
    for (int i = 0; i < 30; i++)
        for (int j = 0; j < 50; j++)
        {
            cin >> mg[i + 1][j + 1].ch;
            mg[i + 1][j + 1].ch++;
        }

    sqfa(1, 1);

    cout << GetPath(30, 50);

    return 0;
}

然后这个是输入的参数

01010101001011001001010110010110100100001000101010
00001000100000101010010000100000001001100110100101
01111011010010001000001101001011100011000000010000
01000000001010100011010000101000001010101011001011
00011111000000101000010010100010100000101100000000
11001000110101000010101100011010011010101011110111
00011011010101001001001010000001000101001110000000
10100000101000100110101010111110011000010000111010
00111000001010100001100010000001000101001100001001
11000110100001110010001001010101010101010001101000
00010000100100000101001010101110100010101010000101
11100100101001001000010000010101010100100100010100
00000010000000101011001111010001100000101010100011
10101010011100001000011000010110011110110100001000
10101010100001101010100101000010100000111011101001
10000000101100010000101100101101001011100000000100
10101001000000010100100001000100000100011110101001
00101001010101101001010100011010101101110000110101
11001010000100001100000010100101000001000111000010
00001000110000110101101000000100101001001000011101
10100101000101000000001110110010110101101010100001
00101000010000110101010000100010001001000100010101
10100001000110010001000010101001010101011111010010
00000100101000000110010100101001000001000000000010
11010000001001110111001001000011101001011011101000
00000110100010001000100000001000011101000000110011
10101000101000100010001111100010101001010000001000
10000010100101001010110000000100101010001011101000
00111100001000010000000110111000000001000000001011
10000001100111010111010001000110111010101101111000

最佳答案

月排行榜 / 总排行榜

不二猫猫

2023-3-23 17:53:58

```c++
#include <iostream>
#include <queue>
#include <string>
using namespace std;

// 二维坐标结构体
struct Index
{
    int x, y;
};

// 迷宫中每个位置的数据结构体
struct Data
{
    char ch;    // 储存当前位置的字符（0 或 1）
    Index In;   // 储存当前位置的前驱（用于求解最短路径）
};

Data mg[40][60];        // 迷宫矩阵
bool visited[40][60];   // 标记某个位置是否已经被访问过
Index dire[4] = { {1,0},{0,-1},{0,1},{-1,0} };    // 方向数组，用于 BFS 遍历迷宫
char sym[4] = { 'D','L','R','U' };                // 路径方向符号，用于记录最短路径

// 广度优先搜索函数，用于遍历迷宫并记录每个位置的前驱
void bfs(int x, int y)
{
    queue<Index> q;
    q.push({ 1,1 });         // 先将起点放入队列中
    visited[1][1] = true;    // 标记起点已经被访问过

    while (!q.empty())
    {
        // 取出队首元素
        Index node = q.front();
        for (int i = 0; i < 4; i++)     // 遍历当前位置的四个方向
        {
            Index t = { node.x + dire[i].x, node.y + dire[i].y };    // 计算下一个位置的坐标
            if (mg[t.x][t.y].ch == '1' && !visited[t.x][t.y])        // 如果下一个位置可行且未访问过
            {
                mg[t.x][t.y].In = node;     // 更新下一个位置的前驱为当前位置
                visited[t.x][t.y] = true;   // 标记下一个位置已经被访问过
                q.push(t);                  // 将下一个位置加入队列中
            }
        }
        q.pop();    // 将当前位置出队
    }
}

// 求解最短路径函数，根据迷宫中每个位置的前驱反向遍历得到最短路径
string getPath(int x, int y)
{
    Index data{ x, y };
    string S;

    for (; data.x != 1 || data.y != 1; data = mg[data.x][data.y].In)
    {
        // 利用前驱计算当前位置相对于前驱的偏移量，从而确定当前位置的方向
        Index V = { data.x - mg[data.x][data.y].In.x, data.y - mg[data.x][data.y].In.y };

        // 查找当前位置与前驱的偏移量在方向数组中的下标，记录对应的方向符号
        for (int i = 0; i < 4; i++)
        {
            if (V.x == dire[i].x && V.y == dire[i].y)
            {
                S = sym[i] + S;     // 将方向符号加入路径字符串中
                break;
            }
        }
    }

    return S;
}

int main()
{
    // 请在此输入您的代码
    for (int i = 1; i <= 30; i++)
        for (int j = 1; j <= 50; j++)
        {
            cin >> mg[i][j].ch;                 // 读入迷宫矩阵
            visited[i][j] = false;             // 初始化每个位置的访问状态为未访问
        }

    bfs(1, 1);     // 遍历迷宫并记录每个位置的前驱

    cout << getPath(30, 50);    // 求解最短路径

    return 0;
}
```

错处在于：

- 在输入迷宫矩

跳转到最佳答案楼层

不二猫猫

```c++
#include <iostream>
#include <queue>
#include <string>
using namespace std;

// 二维坐标结构体
struct Index
{
    int x, y;
};

// 迷宫中每个位置的数据结构体
struct Data
{
    char ch;    // 储存当前位置的字符（0 或 1）
    Index In;   // 储存当前位置的前驱（用于求解最短路径）
};

Data mg[40][60];        // 迷宫矩阵
bool visited[40][60];   // 标记某个位置是否已经被访问过
Index dire[4] = { {1,0},{0,-1},{0,1},{-1,0} };    // 方向数组，用于 BFS 遍历迷宫
char sym[4] = { 'D','L','R','U' };                // 路径方向符号，用于记录最短路径

// 广度优先搜索函数，用于遍历迷宫并记录每个位置的前驱
void bfs(int x, int y)
{
    queue<Index> q;
    q.push({ 1,1 });         // 先将起点放入队列中
    visited[1][1] = true;    // 标记起点已经被访问过

    while (!q.empty())
    {
        // 取出队首元素
        Index node = q.front();
        for (int i = 0; i < 4; i++)     // 遍历当前位置的四个方向
        {
            Index t = { node.x + dire[i].x, node.y + dire[i].y };    // 计算下一个位置的坐标
            if (mg[t.x][t.y].ch == '1' && !visited[t.x][t.y])        // 如果下一个位置可行且未访问过
            {
                mg[t.x][t.y].In = node;     // 更新下一个位置的前驱为当前位置
                visited[t.x][t.y] = true;   // 标记下一个位置已经被访问过
                q.push(t);                  // 将下一个位置加入队列中
            }
        }
        q.pop();    // 将当前位置出队
    }
}

// 求解最短路径函数，根据迷宫中每个位置的前驱反向遍历得到最短路径
string getPath(int x, int y)
{
    Index data{ x, y };
    string S;

    for (; data.x != 1 || data.y != 1; data = mg[data.x][data.y].In)
    {
        // 利用前驱计算当前位置相对于前驱的偏移量，从而确定当前位置的方向
        Index V = { data.x - mg[data.x][data.y].In.x, data.y - mg[data.x][data.y].In.y };

        // 查找当前位置与前驱的偏移量在方向数组中的下标，记录对应的方向符号
        for (int i = 0; i < 4; i++)
        {
            if (V.x == dire[i].x && V.y == dire[i].y)
            {
                S = sym[i] + S;     // 将方向符号加入路径字符串中
                break;
            }
        }
    }

    return S;
}

int main()
{
    // 请在此输入您的代码
    for (int i = 1; i <= 30; i++)
        for (int j = 1; j <= 50; j++)
        {
            cin >> mg[i][j].ch;                 // 读入迷宫矩阵
            visited[i][j] = false;             // 初始化每个位置的访问状态为未访问
        }

    bfs(1, 1);     // 遍历迷宫并记录每个位置的前驱

    cout << getPath(30, 50);    // 求解最短路径

    return 0;
}
```

错处在于：

- 在输入迷宫矩

小甲鱼的二师兄

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

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

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

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

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

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