Question

我正在使用Heap for A *算法的这种实现：

https://courses.cs.washington.edu/courses/cse373/11wi/homework/5/BinaryHeap.java

我略微修改了它，但只添加了contains方法并将remove重命名为poll，因为我之前使用的是PriorityQueue，但它没有用。

以下是我Comparable<Spot>接口的实现：

@Override
public int compareTo(Spot o) {
    Double.compare(getF(), o.getF());
}

getF()返回双倍...

然而，当我用所有getF()打印堆时，我看到了：

1. 176.0
2. 175.0
3. 180.0
4. 176.0
5. 223.0
6. 182.0
7. 146.0
8. 177.0
9. 87.0
10. 202.0
...

现在175错了，因为它低于176,87也是错误的......

PriorityQueue发生了同样的事情，我做错了什么？

修改这是我的A *实现：

public List<Spot> process(GameBodyObject me, Point target, ArrayList<GameBodyObject> others) throws Exception {

    if(grid == null) {
        throw new Exception("You have to initialize AStar first.");
    }

    grid.unsetObstacleForObject(me);

    Spot start = grid.getSpotAtPosition(me.getPosition().getX(), me.getPosition().getY());
    Spot end = grid.getSpotAtPosition(target.getX(), target.getY());

    end = grid.moveSpotSoThatItDoesntCollide(end, me.getRadius());

    Heap<Spot> openSet = new Heap<Spot>(grid.getMaxSize());
    List<Spot> closedSet = new ArrayList<>();
    List<Spot> path = new ArrayList<>();

    openSet.add(start);

    while(openSet.size() > 0) {

        /*int winner = 0;
        for(int i = 1; i < openSet.size(); i++) {
            if(openSet.get(i).getF() < openSet.get(winner).getF()) {
                winner = i;
            }
        }*/

        Spot current = openSet.poll(); //openSet.get(winner);

        int i = 1;
        for(Spot s : Arrays.asList(openSet.getArray())) {
            if(s != null) {
                System.out.println(i + ". " + s.getF());
                i++;
            }
        }

        if(current.equals(end)) {
            // We are done, reconstruct the path...
            Spot temp = current;
            path.add(temp);
            while(temp.getPrevious() != null) {
                path.add(temp.getPrevious());
                temp = temp.getPrevious();
            }

            grid.resetObstacles();
            return path;
        }

        closedSet.add(current);

        List<Spot> neighbors = current.getNeighbors();

        for(Spot neighbor : neighbors) {
            if(!closedSet.contains(neighbor) && !grid.isCollidingWithObstacle(neighbor, me.getRadius())) {
                double tempG = current.getG() + 1;
                if(openSet.contains(neighbor)) {
                    if(tempG < neighbor.getG()) {
                        neighbor.setG(tempG);
                    }
                } else {
                    neighbor.setG(tempG);
                    openSet.add(neighbor);
                }

                neighbor.setH(heuristic(neighbor, end));
                neighbor.setF(neighbor.getG() + neighbor.getH());
                neighbor.setPrevious(current);
            }
        }

    }

    grid.resetObstacles();
    return new ArrayList<>();
}

Answer 1

使用Java的PriorityQueue或类似的堆实现来实现Dijkstra或A *算法时的常见问题是缺少decreaseKey方法。 Dijkstra或A *有时需要更改插入堆中的元素的优先级。避免丢失此功能的唯一方法是删除元素（在Java的PriorityQueue实现中很慢），然后重新插入它。

但是有一个问题：当从PQ / Heap中删除对象时，它仍然必须包含“旧”优先级（getF()必须仍然返回你的情况下的旧值），否则可能找不到元素。如果元素已经包含新值，则PQ / Heap将在要删除的新位置中查找它，而不是在与旧值匹配的位置中查找。

因此，序列必须是：（1）从PQ中删除元素，（2）调整其权重/优先级，（3）将其重新插入PQ。

在您的代码中，您有以下部分：

            if(openSet.contains(neighbor)) {
                if(tempG < neighbor.getG()) {
                    neighbor.setG(tempG); // *1
                }
            } else {
                neighbor.setG(tempG);
                openSet.add(neighbor);
            }

            neighbor.setH(heuristic(neighbor, end));
            neighbor.setF(neighbor.getG() + neighbor.getH()); // *2
            neighbor.setPrevious(current);

如果您仔细查看，由于第neighbor行的更改，您可以在*2标记的行修改*1的权重。要解决此问题，您可以尝试以下方法：

            if(openSet.contains(neighbor)) {
                if(tempG < neighbor.getG()) {
                    openset.remove(neighbor); // *3
                    neighbor.setG(tempG);
                }
            } else {
                neighbor.setG(tempG);
                // openSet.add(neighbor); // *4
            }

            neighbor.setH(heuristic(neighbor, end));
            neighbor.setF(neighbor.getG() + neighbor.getH());
            openSet.add(neighbor); // *5
            neighbor.setPrevious(current);

如果元素已经存在（*3），则会从堆中移除该元素，并仅在正确计算权重（*4，*5）后插入该元素。

现在的问题：您的Heap实现不提供这样的remove(Object)方法。 Java的PriorityQueue does。因此，您必须更改为Java的PriorityQueue，或更改为提供remove(Object)方法的另一个Heap-Implementation。（或者甚至更好：decreaseKey方法，因此根本不必删除重新插入元素。

在许多Dijkstra / A * -Implementations中，我看到使用Java的PQ，这在第一次尝试时做错了，导致堆的顺序不正确。

tl; dr：请勿修改已插入PriorityQueue或堆中的元素的权重/优先级。

Java BinaryHeap无法处理A *（未排序）

1 个答案: