def dijkstra(G, start, end=None):
D = {} # dictionary of final distances
P = {} # dictionary of predecessors
Q = priority_dict() # est.dist. of non-final vert.
# initialize Q and P
for vertex in G:
Q[vertex] = float("inf")
P[vertex] = None
Q[start] = 0
for v in Q: # iterate and pop the smallest item in Q
D[v] = Q[v]
if v == end: break # we have reached the end
for w in G[v]: # for all of v's adjacent vertices
vwLength = D[v] + G[v][w]
if w not in Q or vwLength < Q[w]:
Q[w] = vwLength
P[w] = v
return D, P
def dijkstra(G, start, end=None):
D = {} # dictionary of final distances
P = {} # dictionary of predecessors
Q = priority_dict() # est.dist. of non-final vert.
# initialize Q and P
for vertex in G:
Q[vertex] = float("inf")
P[vertex] = None
Q[start] = 0
for v in Q: # iterate and pop the smallest item in Q
D[v] = Q[v]
if v == end: break # we have reached the end
for w in G[v]: # for all of v's adjacent vertices
vwLength = D[v] + G[v][w]
if (w not in D) and (w not in Q or vwLength < Q[w]):
Q[w] = vwLength
P[w] = v
return D, P
def dijkstra(G, start, end=None):
"""Find shortest paths from the start vertex to all
vertices nearer than or equal to the end.
The input graph G is assumed to have the following
representation: A vertex can be any object that can
be used as an index into a dictionary. G is a
dictionary, indexed by vertices. For any vertex v,
G[v] is itself a dictionary, indexed by the neighbors
of v. For any edge v->w, G[v][w] is the length of
the edge. This is related to the representation in
<http://www.python.org/doc/essays/graphs.html>
where Guido van Rossum suggests representing graphs
as dictionaries mapping vertices to lists of neighbors,
however dictionaries of edges have many advantages
over lists: they can store extra information (here,
the lengths), they support fast existence tests,
and they allow easy modification of the graph by edge
insertion and removal. Such modifications are not
needed here but are important in other graph algorithms.
Since dictionaries obey iterator protocol, a graph
represented as described here could be handed without
modification to an algorithm using Guido's representation.
Of course, G and G[v] need not be Python dict objects;
they can be any other object that obeys dict protocol,
for instance a wrapper in which vertices are URLs
and a call to G[v] loads the web page and finds its links.
The output is a pair (D,P) where D[v] is the distance
from start to v and P[v] is the predecessor of v along
the shortest path from s to v.
Dijkstra's algorithm is only guaranteed to work correctly
when all edge lengths are positive. This code does not
verify this property for all edges (only the edges seen
before the end vertex is reached), but will correctly
compute shortest paths even for some graphs with negative
edges, and will raise an exception if it discovers that
a negative edge has caused it to make a mistake.
Input: G - the input graph in the adjacency list representation via a dictionary
start - the starting vertex
end - the ending vertex. It is not necessary to provide this argument, in that case dijkstra's will find the distance
from 'start' to every other vertex, but that may take a long time, so it is recommended to provide the last argument"""
D = {} # dictionary of final distances
P = {} # dictionary of predecessors
Q = priority_dict() # est.dist. of non-final vert.
# initialize Q and P
for vertex in G:
Q[vertex] = float("inf")
P[vertex] = None
Q[start] = 0
for v in Q: # iterate and pop the smallest item in Q
D[v] = Q[v]
if v == end: break # we have reached the end
for w in G[v]: # for all of v's adjacent vertices
vwLength = D[v] + G[v][w]
if w not in Q or vwLength < Q[w]:
Q[w] = vwLength
P[w] = v
return D, P
def dijkstra(G, start, end=None):
"""Find shortest paths from the start vertex to all
vertices nearer than or equal to the end.
The input graph G is assumed to have the following
representation: A vertex can be any object that can
be used as an index into a dictionary. G is a
dictionary, indexed by vertices. For any vertex v,
G[v] is itself a dictionary, indexed by the neighbors
of v. For any edge v->w, G[v][w] is the length of
the edge. This is related to the representation in
<http://www.python.org/doc/essays/graphs.html>
where Guido van Rossum suggests representing graphs
as dictionaries mapping vertices to lists of neighbors,
however dictionaries of edges have many advantages
over lists: they can store extra information (here,
the lengths), they support fast existence tests,
and they allow easy modification of the graph by edge
insertion and removal. Such modifications are not
needed here but are important in other graph algorithms.
Since dictionaries obey iterator protocol, a graph
represented as described here could be handed without
modification to an algorithm using Guido's representation.
Of course, G and G[v] need not be Python dict objects;
they can be any other object that obeys dict protocol,
for instance a wrapper in which vertices are URLs
and a call to G[v] loads the web page and finds its links.
The output is a pair (D,P) where D[v] is the distance
from start to v and P[v] is the predecessor of v along
the shortest path from s to v.
Dijkstra's algorithm is only guaranteed to work correctly
when all edge lengths are positive. This code does not
verify this property for all edges (only the edges seen
before the end vertex is reached), but will correctly
compute shortest paths even for some graphs with negative
edges, and will raise an exception if it discovers that
a negative edge has caused it to make a mistake.
Input: G - the input graph in the adjacency list representation via a dictionary
start - the starting vertex
end - the ending vertex. It is not necessary to provide this argument, in that case dijkstra's will find the distance
from 'start' to every other vertex, but that may take a long time, so it is recommended to provide the last argument"""
D = {} # dictionary of final distances
P = {} # dictionary of predecessors
Q = priority_dict() # est.dist. of non-final vert.
# initialize Q and P
for vertex in G:
Q[vertex] = float("inf")
P[vertex] = None
Q[start] = 0
for v in Q: # iterate and pop the smallest item in Q
D[v] = Q[v]
if v == end: break # we have reached the end
for w in G[v]: # for all of v's adjacent vertices
vwLength = D[v] + G[v][w]
if w not in Q or vwLength < Q[w]:
Q[w] = vwLength
P[w] = v
return D, P
