动态最短路径

Question

您的朋友正计划前往加拿大北部深处的一个小镇探险 下一个寒假。他们研究了所有的旅行选择，并制定了一个有针对性的 图，其节点表示中间目的地，边表示之间的重载 他们。 在此过程中，他们还了解到极端天气会导致这部分地区出现道路。 世界在冬天变得相当缓慢，并可能导致大量旅行延误。他们已经 找到了一个出色的旅游网站，可以准确预测他们能够以多快的速度旅行 沿着道路行驶；但是，旅行的速度取决于一年中的时间。更多的 准确地说，该网站回答以下形式的查询：给定一条边 e = (u, v) 连接两个站点 u 和 v，并给定从位置 u 开始的建议开始时间 t， 网站将返回一个值 fe(t)，即到达 v 的预计时间。网站保证 1 fe(t) > t 对于每个边 e 和每个时间 t（你不能在时间上倒退），并且 fe(t) 是 t 的单调递增函数（也就是说，你不会因为开始而更早到达 之后）。除此之外，函数fe 可以是任意的。例如，在那些 旅行时间不随季节变化，我们将有 fe(t) = t + e, wheree 是 从边缘开始到结束所需的时间 e. 您的朋友想通过网站确定最快的旅行方式 从起点到预期目的地的有向图。 （你应该假设 它们从时间 0 开始，并且网站所做的所有预测都是完全正确的 正确。）给出一个多项式时间算法来执行此操作，我们将单个查询处理为 网站（基于特定的边 e 和时间 t）作为单个计算步骤。

    def updatepath(node):
        randomvalue = random.randint(0,3)
        print(node,"to other node:",randomvalue)
        for i in range(0,n):
            distance[node][i] = distance[node][i] + randomvalue

    def minDistance(dist,flag_array,n):
        min_value = math.inf
        for i in range(0,n):
            if dist[i] < min_value and flag_array[i] == False:
                min_value = dist[i]
                min_index = i
        return min_index

    def shortest_path(graph, src,n):
        dist = [math.inf] * n
        flag_array = [False] * n
        dist[src] = 0

        for cout in range(n):
            #find the node index that have min cost
            u = minDistance(dist,flag_array,n)
            flag_array[u] = True
            updatepath(u)
            for i in range(n):
                if graph[u][i] > 0 and flag_array[i]==False and dist[i] > dist[u] + graph[u][i]:
                    dist[i] = dist[u] + graph[u][i]
                    path[i] = u
        return dist

我应用了 Dijkstra 算法，但它不正确？我将在我的算法中进行哪些更改以使其用于动态变化的边缘。

Answer 1

嗯，关键是函数是单调递增的。有一种算法可以利用此属性，称为 A*。

累计成本：您的教授希望您使用两个距离，其中一个是累计成本（这很简单，就是将之前的成本加到移动到下一个节点所需的成本/时间上）。 p>

启发式成本：这是一些预测成本。

Disjkstra 方法不起作用，因为您使用的是启发式成本/预测和累积成本。

单调递增意味着h(A) 。它只是说如果你从节点A移动到节点 B 则成本不应小于前一个节点（在本例中为 A），这是 启发式 + 累积的。 如果此属性成立，则第一个路径 A* 选择始终是通往目标的道路，它永远不需要回溯。

注意：这个算法的威力完全取决于你如何预测价值。

如果您低估了将通过累积值进行校正的值，但如果您高估了该值，它将选择错误的路径。

算法：

Create  a Min Priority queue.
insert initial city in q.

while(!pq.isEmpty() && !Goalfound) Node min = pq.delMin() //this should return you a cities to which your distance(heuristic+accumulated is minial). put all succesors of min in pq // all cities which you can reach, you can better make a list of visited cities s that queue will be efficient by not placing same element twice. Keep doing this and at the end you will either reach goal or your queue will be empty

额外

这里我使用 A* 实现了一个 8-puzzle-solve，它可以让您了解成本是如何定义的以及它是如何工作的。

`

private void solve(MinPQ<Node> pq, HashSet<Node> closedList) {
        while(!(pq.min().getBoad().isGoal(pq.min().getBoad()))){
            Node e = pq.delMin();
            closedList.add(e);
            for(Board boards: e.getBoad().neighbors()){
                Node nextNode = new Node(boards,e,e.getMoves()+1);
                if(!equalToPreviousNode(nextNode,e.getPreviousNode()))
                      pq.insert(nextNode);
               }
            }
        Node collection = pq.delMin();
            while(!(collection.getPreviousNode() == null)){
                this.getB().add(collection.getBoad());
                collection =collection.getPreviousNode();
        }
            this.getB().add(collection.getBoad());
            System.out.println(pq.size());
    }

full 代码的链接在这里。