Question

我正在javascript中实现A-Star算法。它有效，但是在两个非常接近的点之间创建一条路径需要很长的时间：（1,1）到（6,6）需要几秒钟。我想知道我在算法中犯了哪些错误以及如何解决这些错误。

我的代码：

Node.prototype.genNeighbours = function() {
    var right = new Node(this.x + 1, this.y);
    var left = new Node(this.x - 1, this.y);
    var top = new Node(this.x, this.y + 1);
    var bottom = new Node(this.x, this.y - 1);
    this.neighbours = [right, left, top, bottom];
}

AStar.prototype.getSmallestNode = function(openarr) {
    var comp = 0;
    for(var i = 0; i < openarr.length; i++) {
        if(openarr[i].f < openarr[comp].f) comp = i
    }
    return comp;
}

AStar.prototype.calculateRoute = function(start, dest, arr){
var open = new Array();
var closed = new Array();

start.g = 0;
start.h = this.manhattanDistance(start.x, dest.x, start.y, dest.y);
start.f = start.h;
start.genNeighbours();
open.push(start);
while(open.length > 0) {
    var currentNode = null;
    this.getSmallestNode(open);
    currentNode = open[0];
    if(this.equals(currentNode,dest)) return currentNode;
    currentNode.genNeighbours();
    var iOfCurr = open.indexOf(currentNode);
    open.splice(iOfCurr, 1);
    closed.push(currentNode);
    for(var i = 0; i < currentNode.neighbours.length; i++) {
        var neighbour = currentNode.neighbours[i];
        if(neighbour == null) continue;
        var newG = currentNode.g + 1;
        if(newG < neighbour.g) {
            var iOfNeigh = open.indexOf(neighbour);
            var iiOfNeigh = closed.indexOf(neighbour);
            open.splice(iOfNeigh, 1);
            closed.splice(iiOfNeigh,1);
        }
        if(open.indexOf(neighbour) == -1 && closed.indexOf(neighbour) == -1) {
            neighbour.g = newG;
            neighbour.h = this.manhattanDistance(neighbour.x, dest.x, neighbour.y, dest.y);
            neighbour.f = neighbour.g + neighbour.h;
            neighbour.parent = currentNode;
            open.push(neighbour);
        }
    }

}
}

编辑：我现在已经解决了这个问题。这是因为我只是在调用：open.sort（）;它没有按照他们的＆＃39; f＆＃39;排序节点。值。我写了一个自定义函数，现在算法运行得很快。

Answer 1

我发现了一些错误：

您的open节点集没有任何结构，因此检索具有最小距离的节点很容易。通常的选择是使用优先级队列，但以排序顺序（而不是open.push(neighbour)）插入新节点应该足够（首先）。
在您的getSmallestNode函数中，您可以在索引1
您正在呼叫getSmallestNode()，但根本没有使用其结果。你每次只接受currentNode = open[0];（然后甚至搜索它的位置来拼接它！它是0！）。对于队列，它只是currentNode = open.shift()。

然而，最重要的事情（可能出错最多）是你的getNeighbors()功能。它每次调用时都会创建全新的节点对象 - 之前闻所未闻，并且不了解您的算法（或其closed集）。它们可能与其他节点位于网格中的相同位置，但它们是不同的对象（通过引用进行比较，而不是通过相似性进行比较）。这意味着indexOf将永远不会在closed数组中找到这些新邻居，并且它们将被反复处理（以及结束）。我不会尝试计算这种实现的复杂性，但我猜它甚至比指数更糟。

通常，A *算法在现有图形上执行。 OOP - getNeighbors - 函数将返回对现有节点对象的引用，而不是创建具有相同坐标的新对象。如果您需要动态生成图形，那么您需要一个查找结构（二维数组？）来存储和检索已经生成的节点。

A-Star算法：执行缓慢

1 个答案: