Trung tâm cá nhân
sách gpt4 ai đã đi

java - 构建 A* 算法的问题

In lại 作者：塔克拉玛干 更新时间：2023-11-03 06:18:40 hai mươi bốn 4
mua khóa gpt4 Nike

我正在尝试构建一个实现 A* 的应用程序，但我在处理逻辑时遇到了问题。这里的方法接受 4 个整数(startX/Y，goalX/Y)，然后使用 A* 算法，它将构建一个 ArrayList 并返回它，因此 main 方法可以迭代并显示 A* 构建的路径。但是我得到的是一条跳跃的路径，最终会建立一条通往目标节点的非常粗的路径。谁能指出我的错误在哪里。

注意:open和closed是优先级队列和Tile实现类比.

public ArrayList findPath(int sX, int sY, int gX, int gY)
{
    ArrayList path = new ArrayList();

    open.offer(gameMap[sX][sY]);
    Tile currentNode = gameMap[sX][sY];
    Tile goalNode = gameMap[gX][gY];

    int cX;
    int cY;

    while(open.size() > 0){
        currentNode = open.poll();
        closed.offer(currentNode);
        path.add(currentNode);

        cX = currentNode.getX();
        cY = currentNode.getY();

        if(currentNode == goalNode){
            phá vỡ;
        }
        if((cX > 0 && cX < gameMap.length - 1) && (cY > 0 && cY < gameMap.length -1)){
            for(int i = -1; i < 2; i++){
                for(int j = 1; j > -2; j--){
                    if(i == 0 && j == 0){}
                    else{

                        if((gameMap[cX + i][cX + j].type != 1) && !closed.contains(gameMap[cX + i][cX + j])){

                            if(!open.contains(gameMap[cX + i][cX + j])){
                                open.offer(gameMap[cX + i][cX + j]);
                                gameMap[cX + i][cX + j].parent = currentNode;

                            }
                        }
                    }

                }

            }

        }

    }

    // while(currentNode != gameMap[sX][sY]){
    // path.push(currentNode);
    // currentNode = currentNode.parent;
    // }

    return path;
}

nhập mô tả hình ảnh ở đây

1 Câu trả lời

首先，我认为您的closed 集不需要是优先队列。它只是一组已查看的节点。

您似乎错过了 A* 工作原理的核心部分，这就是为什么我认为此路径查找器不适合您的原因。

主要思想如下:

有一个启发式函数，可以猜测目的地有多远。理想情况下，该函数将可接受，这意味着它永远不会高估距离。

对于瓷砖网格，这可以使用曼哈顿距离(x 差值 + y 差值)来完成，因为这是最小距离，所以它始终是可接受的。

每当您从开放列表中取出一个图 block 并将其添加到封闭集中时，您需要更新相邻图 block 距离的已知值(保持最低已知值)。由于您拥有要放入封闭集中的图 block 的已知值，因此只需将所有邻居的已知值加 1。

通过更新这些值，打开列表可能会改变顺序(这就是为什么优先队列在这里是一个不错的选择)。启发值可能会保持不变，但已知值会变得更加精细。

到达目的地后，您将拥有一组距离已知的封闭节点。然后，您从目的地回溯，查看也在封闭集中的每个邻居，并选择已知距离最小的邻居。

就如何实现这一点而言，您可能需要考虑将您的 Tile 类包装在另一个名为 SearchTile 或类似的类中。它可能看起来像这样:

//You may not want to use public variables, depending on your needs
public class SearchTile implements Comparable {
    public final Tile tile;
    //These need to be updated
    public int knownDistance = 0;
    public int heuristicDistance = 0;

    public SearchTile(final Tile tile) {
        this.tile = tile;
    }

    @Ghi đè
    public int compareTo(final SearchTile other) {
        if (knownDistance + heuristicDistance > other.knownDistance + other.heuristicDistance) {
            return 1;
        } else if (knownDistance + heuristicDistance < other.knownDistance + other.heuristicDistance) {
            return -1;
        } khác {
            trả về 0;
        }
    } 
}

A* 的妙处在于，在理想情况下，它应该直接到达目的地。在有墙的情况下，它会进行最佳猜测，只要启发式是可接受的，它就会提出最佳解决方案。

关于java - 构建 A* 算法的问题，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/37005153/

hai mươi bốn 4 0
Bài viết được đề xuất: Thuật toán - được sử dụng để đếm số lần các cặp
Bài viết được đề xuất: c++ - 使用结构/遗传算法
Bài viết được đề xuất: 更改枚举算法以首先显示更大的范围
Bài viết được đề xuất: r - 如何将概率插入矩阵？
塔克拉玛干
Hồ sơ cá nhân

Tôi là một lập trình viên xuất sắc, rất giỏi!

Nhận phiếu giảm giá Didi Taxi miễn phí
Mã giảm giá Didi Taxi
Các bài viết nóng hổi trên toàn bộ trang web
Giấy chứng nhận ICP Bắc Kinh số 000000
Hợp tác quảng cáo: 1813099741@qq.com 6ren.com