Warum funktioniert der Dijkstra-Algorithmus funktioniert?

Können Sie denken Djikstra ' s Algorithmus als Wasser-Füllung-Algorithmus (d.h. eine schrumpelige Breite-zuerst-Suche). Auf jeder Stufe, das Ziel ist, decken mehr des gesamten Graphen mit der niedrigsten cost-Pfad möglich. Angenommen, Sie haben Eckpunkte am Rand der Bereich, den Sie gefüllt haben, und Sie der Liste in Bezug auf die Entfernung:

v0 <= v1 <= v2 <= v3 ...

Könnte es möglicherweise ein billiger Weg, um zu vertex v1? Wenn ja, den Pfad muss gehen durch v0, da keine ungetestete vertex könnte näher sein. So untersuchen Sie vertex v0 um zu sehen, wo Sie bekommen können, überprüfung, ob jeder Pfad durch v0 ist billiger (auf jeden anderen Eckpunkt, einen Schritt Weg).

Wenn Sie ziehen Weg, das problem auf diese Weise sind Sie garantiert, dass Ihre Entfernungen sind alle minima, weil Sie immer genau prüfen, dass die vertex, die dazu führen könnten, einen kürzesten Pfad. Entweder finden Sie, dass der kürzeste Weg, oder du schließt Sie aus, und verschieben Sie auf den nächsten Scheitelpunkt. So sind Sie garantiert täglich ein vertex pro Schritt.

Sind und Sie zu stoppen, ohne dabei mehr Arbeit, als Sie brauchen, weil Sie stoppen, wenn Sie Ihre Ziel-vertex nimmt die "ich bin der kleinste" v0 slot.

Schauen wir uns kurz ein Beispiel. Nehmen wir an, wir versuchen, aus 1 zu 12 durch die Multiplikation, und die Kosten zwischen den Knoten ist die Zahl, die Sie haben, zu vermehren. (Wir beschränken die Eckpunkte zu den zahlen von 1 zu 12.)

Beginnen wir mit 1, und wir können zu jedem anderen Knoten durch Multiplikation mit diesem Wert. Also Knoten 2 gekostet hat 2, 3 gekostet hat 3, ... 12 gekostet hat 12 wenn Sie gehen in einem Schritt.

Nun, einen Weg durch 2 könnte (ohne wissen über die Struktur) man 12 schnellsten, wenn es ein freier link von 2 zu 12. Gibt es nicht, aber wenn es war, es würde am schnellsten. So überprüfen wir 2. Und wir finden, dass wir bekommen können, um 4 für Kosten 2 zu 6 für 3, und so weiter. Wir haben also eine Tabelle der Kosten in etwa so:

3  4  5  6  7  8  9 10 11 12 //Vertex
3  4  5  5  7  6  9  7 11  8 //Best cost to get there so far.

Okay, nun, vielleicht bekommen wir 12 aus 3 kostenlos! Besser überprüfen. Und wir finden, dass 3*2==6 so die Kosten zu 6 ist, die Kosten zu 3 plus 2 und zu 9 ist plus 3, und 12 ist plus 4.

4  5  6  7  8  9 10 11 12
4  5  5  7  6  6  7 11  7

Fair genug. Jetzt testen wir 4, und wir sehen, dass wir bekommen können, um 8 für eine zusätzliche 2 und zu 12 für eine zusätzliche 3. Wieder, die Kosten zu bekommen, um 12 ist damit nicht mehr als 4+3 = 7:

5  6  7  8  9 10 11 12
5  5  7  6  8  7 11  7

Nun versuchen wir 5 und 6--keine Verbesserungen so weit. Dies lässt uns mit

7  8  9 10 11 12
7  6  8  7 11  7

Nun, zum ersten mal, sehen wir, dass die Kosten, um zu 8 ist weniger als die Kosten, um zu 7, so hatten wir besser kontrollieren, dass es nicht eine Kostenlose Möglichkeit, um zu 12 aus 8. Gibt es nicht--es gibt keinen Weg, um es überhaupt mit ganzen zahlen--so werfen wir es Weg.

7  9 10 11 12
7  8  7 11  7

Und nun sehen wir, dass 12 ist so Billig wie alle Pfad Links, also die Kosten für das erreichen 12 muss 7. Hätten wir immer den überblick über die günstigsten Pfad so weit (nur Austausch der Pfad, wenn es strikt besser), würden wir feststellen, dass 3*4 ist die erste billigste Weg, um Treffer 12.

Der Grund, warum Dijsktra-Algorithmus funktioniert, wie es tut, ist in Teil, weil es nutzt die Tatsache, dass der kürzeste Pfad zwischen Knoten u und w enthält Punkt v auch enthält der kürzeste Pfad von u zu v und von v zu w. Wenn gab es etwas kürzer, zwischen u-v, dann wäre es nicht der kürzeste Weg.

Wirklich zu verstehen, warum Dijkstra ' s Algorithmus funktioniert, schauen Sie in die Grundlagen der dynamische Programmierung, klingt hart aber es ist wirklich ziemlich einfach, die Prinzipien zu verstehen.

Prüft es, den Pfad mit dem geringsten Gewicht zuerst, da diese am wahrscheinlichsten ist (ohne zusätzliche Informationen) zu reduzieren, die Anzahl der Pfade überprüft. Zum Beispiel:

a->b->c Kosten 20 
a->b->d Kosten 10 
a->b->d->e Kosten 12 

Wenn Ziel ist es, von a bis e, brauchen wir nicht einmal die Kosten prüfen von:

a->b->c->e 

Weil wir wissen, dass es mindestens 20, so wissen wir, es ist nicht optimal, weil es bereits einen anderen Weg mit einem Kostenaufwand von 12. Maximieren Sie den Effekt, indem Sie die überprüfung der niedrigste GEWICHTE erste. Dies ist ähnlich (gleich?) wie minimax arbeitet in Schach und andere Spiele zur Verringerung der branching-Faktor des Spiels Baum.

Für verstehen das grundlegende Konzept dieses Algorithmus, schrieb ich diesen code für Sie. Es ist eine Erklärung, wie es funktioniert.

graph = {}

graph["start"] = {}
graph["start"]["a"] = 6
graph["start"]["b"] = 2
graph["a"] = {}
graph["a"]["finish"] = 1
graph["b"] = {}
graph["b"]["a"] = 3
graph["b"]["finish"] = 5
graph["finish"] = {}

infinity = float("inf")
costs = {}
costs["a"] = 6
costs["b"] = 2
costs["finish"] = infinity
print "The weight of each node is: ", costs

parents = {}
parents["a"] = "start"
parents["b"] = "start"
parents["finish"] = None

processed = []

def find_lowest_cost_node(costs):
    lowest_cost = float("inf")
    lowest_cost_node = None
    for node in costs:
        cost = costs[node]
        if cost < lowest_cost and node not in processed:
            lowest_cost = cost
            lowest_cost_node = node
    return lowest_cost_node

node = find_lowest_cost_node(costs)
print "Start: the lowest cost node is", node, "with weight",\
    graph["start"]["{}".format(node)]

while node is not None:
    cost = costs[node]
    print "Continue execution ..."
    print "The weight of node {} is".format(node), cost
    neighbors = graph[node]
    if neighbors != {}:
        print "The node {} has neighbors:".format(node), neighbors
    else:
        print "It is finish, we have the answer: {}".format(cost)
    for neighbor in neighbors.keys():
        new_cost = cost + neighbors[neighbor]
        if costs[neighbor] > new_cost:
            costs[neighbor] = new_cost
            parents[neighbor] = node
    processed.append(node)
    print "This nodes we researched:", processed
    node = find_lowest_cost_node(costs)
    if node is not None:
        print "Look at the neighbor:", node

# to draw graph
import networkx
G = networkx.Graph()
G.add_nodes_from(graph)
G.add_edge("start", "a", weight=6)
G.add_edge("b", "a", weight=3)
G.add_edge("start", "b", weight=2)
G.add_edge("a", "finish", weight=1)
G.add_edge("b", "finish", weight=5)

import matplotlib.pyplot as plt
networkx.draw(G, with_labels=True)
plt.show()