Johnson's algorithm - Revision history

172.68.10.246: fixed time of Dijkstra with Fibonacci heap

2017-07-03T05:41:52Z

fixed time of Dijkstra with Fibonacci heap

172.68.10.246: fixed time of Dijkstra with Fibonacci heap

2017-07-03T05:38:41Z

fixed time of Dijkstra with Fibonacci heap

Brian at 07:07, 26 May 2011

2011-05-26T07:07:03Z

Brian at 07:04, 26 May 2011

2011-05-26T07:04:50Z

Brian: /* Reweighting by vertex */

2011-04-24T02:34:55Z

‎Reweighting by vertex

Brian: Created page with "'''Johnson's algorithm''' is a technique for finding all-pairs shortest paths in a graph in which some edge weights may be negative (but there are no cycles of negative weigh..."

2011-03-04T20:28:36Z

Created page with "'''Johnson's algorithm''' is a technique for finding all-pairs shortest paths in a graph in which some edge weights may be negative (but there are no cycles of negative weigh..."

New page

'''Johnson's algorithm''' is a technique for finding [[all-pairs shortest paths]] in a graph in which some edge weights may be negative (but there are no cycles of negative weight). It works by executing the [[Bellman–Ford algorithm]] once, using the data obtained to "reweight" the graph, eliminating negative weights, and then running [[Dijkstra's algorithm]] <math>V</math> times. Accordingly, its runtime is <math>O(VE+V(E+V)\log V)</math>. Because of this, it is faster to use the [[Floyd–Warshall]] algorithm when the graph is dense, but Johnson's algorithm is faster when the graph is sparse.

==Reweighting by vertex==
We want to change the weights of edges in the graph so that we can eliminate negative-weight edges, but we have to do so in such a way that the shortest paths do not change at all, otherwise the algorithm will simply not work. We shall do this by reweighting the graph in such a way that, given two vertices <math>s</math> and <math>t</math>, the weight of a path ''after'' the reweighting is always equal to the weight of the path ''before'' the reweighting, plus some constant that depends only on <math>s</math> and <math>t</math> but not the path.

A straightforward way of doing this is ''reweighting by vertex''. We shall initially assign each ''vertex'' <math>v\in V</math> a ''height'' <math>h(v)</math>. After we have done this, we will change the weight of any edge <math>(u,v)\in E</math> from <math>w(u,v)</math> to <math>w(u,v)+h(v)-h(u)</math>. (Intuitively, think of height literally, ''i.e.'', as an altitude, so that whenever we walk along an edge from <math>u</math> to <math>v</math>, if <math>v</math> is higher, it becomes "harder", ''i.e.'', like a higher distance, and if it is lower, it is like a lower distance.)

What happens to a path from <math>s</math> to <math>t</math>? Suppose the path is given by <math>s = v_0, v_1, v_2, ..., v_n = t</math>. Then the original weight of this path is <math>w(v_0,v_1) + w(v_1+v_2) + ... + w(v_{n-1},v_n)</math>. After reweighting, the weight of this path becomes :<math>\begin{array}{ll}
& w(v_0,v_1) + h(v_1)-h(v_0) + w(v_1,v_2) + h(v_2) - h(v_1) + ... + w(v_{n-1},v_n) + h(v_n) - h(v_{n-1}) \\
=& w(v_0,v_1) + w(v_1,v_2) + ... + w(v_{n-1},v_n) + (h(v_1)-h(v_0)) + (h(v_2)-h(v_1) + ... + (h(v_n)-h(v_{n-1}) \\
=& w(v_0,v_1) + w(v_1,v_2) + ... + w(v_{n-1},v_n) + h(v_n) - h(v_0) \\
=& w(v_0,v_1) + w(v_1,v_2) + ... + w(v_{n-1},v_n) + h(t) - h(s)
\end{array}</math>

So ''every'' path from <math>s</math> to <math>t</math> has a new weight equal to its original weight plus the difference in heights between the source and destination, which means a shortest path before the reweighting is still a shortest path after the reweighting, as promised. (With a bit of imagination, this still makes sense intuitively. Imagine the initially flat terrain is subject to geological activity that causes it to become uneven. If the source and the destination are still at the same height, for example, it doesn't matter what happened to the heights ''along'' the shortest path --- the amount of uphill has to equal the amount of downhill, crudely speaking, since you end up at the same height at the end. It's just not immediately obvious because even though uphill is harder for us, downhill is not really easier.)

==Eliminating negative-weight edges==
First, notice that reweighting by vertex cannot eliminate negative-weight cycles. This is because a cycle's weight will not change under reweighting, as a cycle can be considered a path from a vertex to itself (no height difference). However, it is always possible to make all edges non-negative provided that there are no negative-weight cycles.

To do so, we shall make use of the following Lemma:

''Lemma'': Given three nodes <math>s, u, v \in V</math>, where a path exists from <math>s</math> to <math>u</math> and <math>v</math> and an edge exists from <math>u</math> to <math>v</math>, the weight <math>w(u,v)</math> is at least <math>d(s,v) - d(s,u)</math>. (Here, <math>d</math> represents the distance function.)

''Proof'': If <math>w(u,v) < d(s,v) - d(s,u)</math>, then <math>d(s,u) + w(u,v) < d(s,v)</math>. But this means we can take the shortest path from <math>s</math> to <math>u</math> and append the edge <math>(u,v)</math> to obtain a path from <math>s</math> to <math>v</math> with weight less than <math>d(s,v)</math>, a contradiction. (This is equivalent to saying that relaxation is still possible.) <math>_{\blacksquare}</math>

Now what happens if we fix a source <math>s</math> and set the height of each vertex <math>v \in V</math> to <math>-d(s,v)</math>? Then, the new weight of each edge <math>(u,v) \in E</math> becomes <math>w(u,v) + h(v) - h(u) = w(u,v) - d(s,v) + d(s,u) \geq 0</math> by the Lemma. So we have successfully eliminated all negative weights. All we have to do is find the single-source shortest paths first, which is done using the Bellman–Ford algorithm.

Because the graph may not be connected, it may not be possible to fix a single source <math>s \in V</math> that allows all weights to be calculated at once. To circumvent this problem and allow just one invocation of Bellman–Ford to succeed, we first introduce an extra vertex into the graph, connecting it via edges of weight 0 to all other vertices. (But this vertex must be removed before we proceed to the next step.)

==Home stretch==
Having reweighted the graph appropriately, we can now run Dijkstra's algorithm once using each vertex as a source.

==References==
* Cormen, Thomas H.; Leiserson, Charles E.; Rivest, Ronald L.; Stein, Clifford (2001), ''Introduction to Algorithms'', MIT Press and McGraw-Hill, ISBN 978-0-262-03293-3 . Section 25.3, "Johnson's algorithm for sparse graphs", pp. 636–640.

[[Category:Algorithms]]
[[Category:Graph theory]]

← Older revision		Revision as of 05:41, 3 July 2017
Line 1:		Line 1:
−	'''Johnson's algorithm''' is a technique for finding [[all-pairs shortest paths]] in a graph in which some edge weights may be negative (but there are no cycles of negative weight). It works by executing the [[Bellman–Ford algorithm]] once, using the data obtained to "reweight" the graph, eliminating negative weights, and then running [[Dijkstra's algorithm]] <math>V</math> times. Accordingly, its runtime is <math>O(VE+V(E+V)\log V) = O(V(E+V)\log V)</math> using a [[binary heap]], or <math>O(V(E + V\log V))</math> using a [[Fibonacci heap]]. Because of this, it is faster to use the [[Floyd–Warshall]] algorithm when the graph is dense, but Johnson's algorithm is faster when the graph is sparse.	+	'''Johnson's algorithm''' is a technique for finding [[all-pairs shortest paths]] in a graph in which some edge weights may be negative (but there are no cycles of negative weight). It works by executing the [[Bellman–Ford algorithm]] once, using the data obtained to "reweight" the graph, eliminating negative weights, and then running [[Dijkstra's algorithm]] <math>V</math> times. Accordingly, its runtime is <math>O(VE+V(E+V)\log V) = O(V(E+V)\log V)</math> using a [[binary heap]], or <math>O(V(E + \log V))</math> using a [[Fibonacci heap]]. Because of this, it is faster to use the [[Floyd–Warshall]] algorithm when the graph is dense, but Johnson's algorithm is faster when the graph is sparse.

	==Reweighting by vertex==		==Reweighting by vertex==

← Older revision		Revision as of 05:38, 3 July 2017
Line 1:		Line 1:
−	'''Johnson's algorithm''' is a technique for finding [[all-pairs shortest paths]] in a graph in which some edge weights may be negative (but there are no cycles of negative weight). It works by executing the [[Bellman–Ford algorithm]] once, using the data obtained to "reweight" the graph, eliminating negative weights, and then running [[Dijkstra's algorithm]] <math>V</math> times. Accordingly, its runtime is <math>O(VE+V(E+V)\log V) = O(V(E+V)\log V)</math> using a [[binary heap]], or <math>O(V(E + \log V))</math> using a [[Fibonacci heap]]. Because of this, it is faster to use the [[Floyd–Warshall]] algorithm when the graph is dense, but Johnson's algorithm is faster when the graph is sparse.	+	'''Johnson's algorithm''' is a technique for finding [[all-pairs shortest paths]] in a graph in which some edge weights may be negative (but there are no cycles of negative weight). It works by executing the [[Bellman–Ford algorithm]] once, using the data obtained to "reweight" the graph, eliminating negative weights, and then running [[Dijkstra's algorithm]] <math>V</math> times. Accordingly, its runtime is <math>O(VE+V(E+V)\log V) = O(V(E+V)\log V)</math> using a [[binary heap]], or <math>O(V(E + V\log V))</math> using a [[Fibonacci heap]]. Because of this, it is faster to use the [[Floyd–Warshall]] algorithm when the graph is dense, but Johnson's algorithm is faster when the graph is sparse.

	==Reweighting by vertex==		==Reweighting by vertex==

← Older revision		Revision as of 07:07, 26 May 2011
Line 1:		Line 1:
−	'''Johnson's algorithm''' is a technique for finding [[all-pairs shortest paths]] in a graph in which some edge weights may be negative (but there are no cycles of negative weight). It works by executing the [[Bellman–Ford algorithm]] once, using the data obtained to "reweight" the graph, eliminating negative weights, and then running [[Dijkstra's algorithm]] <math>V</math> times. Accordingly, its runtime is <math>O(VE+V(E+V)\log V)</math> using a [[binary heap]], or <math>O(V(E + \log V))</math> using a [[Fibonacci heap]]. Because of this, it is faster to use the [[Floyd–Warshall]] algorithm when the graph is dense, but Johnson's algorithm is faster when the graph is sparse.	+	'''Johnson's algorithm''' is a technique for finding [[all-pairs shortest paths]] in a graph in which some edge weights may be negative (but there are no cycles of negative weight). It works by executing the [[Bellman–Ford algorithm]] once, using the data obtained to "reweight" the graph, eliminating negative weights, and then running [[Dijkstra's algorithm]] <math>V</math> times. Accordingly, its runtime is <math>O(VE+V(E+V)\log V) = O(V(E+V)\log V)</math> using a [[binary heap]], or <math>O(V(E + \log V))</math> using a [[Fibonacci heap]]. Because of this, it is faster to use the [[Floyd–Warshall]] algorithm when the graph is dense, but Johnson's algorithm is faster when the graph is sparse.

	==Reweighting by vertex==		==Reweighting by vertex==

← Older revision		Revision as of 07:04, 26 May 2011
Line 1:		Line 1:
−	'''Johnson's algorithm''' is a technique for finding [[all-pairs shortest paths]] in a graph in which some edge weights may be negative (but there are no cycles of negative weight). It works by executing the [[Bellman–Ford algorithm]] once, using the data obtained to "reweight" the graph, eliminating negative weights, and then running [[Dijkstra's algorithm]] <math>V</math> times. Accordingly, its runtime is <math>O(VE+V(E+V)\log V)</math>. Because of this, it is faster to use the [[Floyd–Warshall]] algorithm when the graph is dense, but Johnson's algorithm is faster when the graph is sparse.	+	'''Johnson's algorithm''' is a technique for finding [[all-pairs shortest paths]] in a graph in which some edge weights may be negative (but there are no cycles of negative weight). It works by executing the [[Bellman–Ford algorithm]] once, using the data obtained to "reweight" the graph, eliminating negative weights, and then running [[Dijkstra's algorithm]] <math>V</math> times. Accordingly, its runtime is <math>O(VE+V(E+V)\log V)</math> using a [[binary heap]], or <math>O(V(E + \log V))</math> using a [[Fibonacci heap]]. Because of this, it is faster to use the [[Floyd–Warshall]] algorithm when the graph is dense, but Johnson's algorithm is faster when the graph is sparse.

	==Reweighting by vertex==		==Reweighting by vertex==

@@ Line 8: / Line 8: @@
 What happens to a path from <math>s</math> to <math>t</math>? Suppose the path is given by <math>s = v_0, v_1, v_2, ..., v_n = t</math>. Then the original weight of this path is <math>w(v_0,v_1) + w(v_1+v_2) + ... + w(v_{n-1},v_n)</math>. After reweighting, the weight of this path becomes :<math>\begin{array}{ll}
 & w(v_0,v_1) + h(v_1)-h(v_0) + w(v_1,v_2) + h(v_2) - h(v_1) + ... + w(v_{n-1},v_n) + h(v_n) - h(v_{n-1}) \\
-=& w(v_0,v_1) + w(v_1,v_2) + ... + w(v_{n-1},v_n) + (h(v_1)-h(v_0)) + (h(v_2)-h(v_1) + ... + (h(v_n)-h(v_{n-1}) \\
+=& w(v_0,v_1) + w(v_1,v_2) + ... + w(v_{n-1},v_n) + (h(v_1)-h(v_0)) + (h(v_2)-h(v_1)) + ... + (h(v_n)-h(v_{n-1})) \\
 =& w(v_0,v_1) + w(v_1,v_2) + ... + w(v_{n-1},v_n) + h(v_n) - h(v_0) \\
 =& w(v_0,v_1) + w(v_1,v_2) + ... + w(v_{n-1},v_n) + h(t) - h(s)