A-Star 搜索算法找不到有效路径

Question

我正在尝试在我的 3D 网格中实现用于寻路的 A* 算法。 我一直在关注一个教程，但我没有得到一个有效的路径。 我已经通过我的代码来找出发生了什么，但我不知道如何解决这个问题。 对于最基本的测试，我只使用 2-D 网格（它是 3-D，但只有一个 Z 选项，所以基本上是 2-D）。

这是它正在做的事情：

所以我们从 0,0（橙色）开始，想要达到 1,2（绿色）。 首先，它计算橙色正方形的两个选项，北和东，对于 F 值为 3 和 2.414，得到 2 和 1.414 的距离。 它移动到东广场 (0,1)。 伟大的。 但是现在它从 0,1 开始计算两个空方格，分别是 1,1 和 0,2，它们的 ag 值为 2，h 值（距离）为 1，使得它们的 F 值都为 3。

由于它们的 F 值为 3，并且我们已经有一个 F 值为 3 的选项（从起点开始为 1,0），这两个选项被忽略，即使它们显然是最佳选项。

然后它继续前进并切换到移动到 1,0，然后再次将 1,1 计算为 3，将 2,0 计算为 4.236。 1,1 的 f 值不大于我们当前的 f 值，所以它被忽略了，我们向上移动到 2,0。

2,0 只能向右移动。

2,1 只能向下移动，因为 2,2 是无效方格，但是移动到 1,1 的 f 值保存为 3，所以再次忽略它，让我们在 0,0 和 1,2 之间没有有效路径. 我错过了什么？

这是我的路径循环的片段。 这里有一堆自定义结构，我正在使用 Unreal Engine 中的 TMap 来存储我的关闭列表，但我认为这对这个问题并不重要。 这是关于这些结构的快速而肮脏的内容：

• PCell ：保存单元格坐标
• PPair ：将单元坐标保存为 PCell 和 F 值
• FVectorInt : 3-D integer 向量
• FPathCell ：保存父坐标，以及 f、g 和 h 值。
• cellDetails是 FPathCell 的FPathCell动态数组
• closedMap是一个 TMap，其中<key, value>为<IntVector, bool>

另外locationIsWalkable(FVectorInt, StepDirection)只是检查玩家是否可以从某个方向走到单元格的代码。 你可以忽略那部分。

    std::set<PPair> openList;
    PPair originPair = PPair();
    originPair.cell = PCell(i, j, k);
    originPair.f = 0.0;
    openList.insert(originPair);

    bool foundDestination = false;
    FPathCell destPair;
    FVectorInt destCell;

    while (!openList.empty() && !foundDestination)
    {
        iterations++;
        PPair p = *openList.begin();
        
        //Remove vertex
        openList.erase(openList.begin());

        //Add vertex to closed list
        i = p.cell.i;
        j = p.cell.j;
        k = p.cell.k;
        closedMap.Remove(FIntVector(i, j, k));
        closedMap.Add(FIntVector(i, j, k), true);

        double gNew, hNew, fNew;

        //Generate movement options
        //Option 1: NORTH (+X)
        //Process if valid movement
        if (locationIsWalkable(FVectorInt(i + 1, j, k), StepDirection::North))
        {
            FVectorInt check = FVectorInt(i + 1, j, k);

            //If this cell is the destination
            if (check == destination)
            {
                foundDestination = true;
                
                //Set the parent of the destination cell
                cellDetails[check.x][check.y][check.z].parent_i = i;
                cellDetails[check.x][check.y][check.z].parent_j = j;
                cellDetails[check.x][check.y][check.z].parent_k = k;
                destPair = cellDetails[check.x][check.y][check.z];
                destCell = check;
                break;
            }

            //Else if this cell is not in the closed list
            else if (!closedMap.FindRef(FIntVector(check.x, check.y, check.z)))
            {
                gNew = cellDetails[i][j][k].g + 1;
                hNew = calculateHValue(check, destination);
                fNew = gNew + hNew;

                if (cellDetails[check.x][check.y][check.z].f == FLT_MAX ||
                    cellDetails[check.x][check.y][check.z].f > fNew) {
                    
                    PPair cellPair = PPair();
                    cellPair.cell = PCell(check.x, check.y, check.z);
                    cellPair.f = fNew;
                    openList.insert(cellPair);

                    cellDetails[check.x][check.y][check.z].f = fNew;
                    cellDetails[check.x][check.y][check.z].g = gNew;
                    cellDetails[check.x][check.y][check.z].h = hNew;
                    cellDetails[check.x][check.y][check.z].parent_i = i;
                    cellDetails[check.x][check.y][check.z].parent_j = j;
                    cellDetails[check.x][check.y][check.z].parent_k = k;
                }
            }
        }

        //11 other movement options
    }

inline bool operator<(const PPair& lhs, const PPair& rhs)
{
    return lhs.f < rhs.f;
}

有 12 种运动选项（北、南、东、西、上+北、下+北等），但它们基本上都使用相同的代码，只是将check向量换成适当的运动。

这是我遵循的教程

Answer 1

由于它们的 F 值为 3，并且我们已经有一个 F 值为 3 的选项（从起点开始为 1,0），这两个选项被忽略，即使它们显然是最佳选项。

这一定是你的错。 这些选项不应被“忽略”，而应“延迟到它们成为次佳选项”。 它的完成方式是，在 A* 的每次迭代中，您都应该 select F 分数最低的开放单元格。

在您的示例中，一旦您展开0,1 （以获得0,2和1,1 ），您的开放集应如下所示：

(1,0):3   (1,1):3   (0,2):3

（也可以是这些的任何其他排列，因为它们具有相同的分数。）

现在想象它选择访问1,0 。 它将2,0添加到队列中，但1,1和0,2应该仍然存在：

(1,1):3   (0,2):3   (2,0):4.236

由于2,0比1,1或0,2具有更高的 F 分数，因此尚未选择它。 相反，您的算法将在此迭代中选择1,1或0,2 ，从而到达目的地1,2 。

至于您的代码，您正在为openList使用std::set ，这可以防止队列中有多个具有相同分数的实例。 您可以使用multiset或priority_queue来解决这个问题。 然而，A* 可以减少开放集中节点的权重，并且两种数据结构都不允许在亚线性时间内进行该操作。 通过多次插入同一个节点（每次它的分数降低），并在它关闭后忽略任何弹出，你仍然会得到一个正确的，虽然次优的算法。

正确的 A* 实现通常使用二项式或斐波那契堆。 不幸的是 C++ 没有它们。 您可以在 web 上找到实现这些的库。