Scribd
Upload
131 views15 pages

The Floyd-Warshall Algorithm: Andreas Klappenecker

The Floyd-Warshall algorithm finds the shortest paths between all pairs of vertices in a graph. It uses dynamic programming to compute the shortest path distances between all pairs iteratively. In each iteration k, it considers all paths that use vertices 1 through k as intermediate vertices. The algorithm runs in O(n3) time and O(n2) space for a graph with n vertices. It improves upon Dijkstra's and Bellman-Ford algorithms by solving the all-pairs shortest path problem more efficiently for graphs with negative edge weights.

Uploaded by

Shivam Pandey
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
Download as ppt, pdf, or txt
131 views15 pages

The Floyd-Warshall Algorithm: Andreas Klappenecker

The Floyd-Warshall algorithm finds the shortest paths between all pairs of vertices in a graph. It uses dynamic programming to compute the shortest path distances between all pairs iteratively. In each iteration k, it considers all paths that use vertices 1 through k as intermediate vertices. The algorithm runs in O(n3) time and O(n2) space for a graph with n vertices. It improves upon Dijkstra's and Bellman-Ford algorithms by solving the all-pairs shortest path problem more efficiently for graphs with negative edge weights.

Uploaded by

Shivam Pandey
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
Download as ppt, pdf, or txt
Download as ppt, pdf, or txt
You are on page 1/ 15

The Floyd-Warshall Algorithm

Andreas Klappenecker

All-Pairs Shortest Path Problem


Suppose we are given a directed graph
G=(V,E) and a weight function w: E->R.
We assume that G does not contain cycles
of weight 0 or less.
The All-Pairs Shortest Path Problem asks
to find the length of the shortest path
between any pair of vertices in G.
2

Quick Solutions
If the weight function is nonnegative for
all edges, then we can use Dijkstras single
source shortest path algorithm for all
vertices to solve the problem.
This yields an O(n3) algorithm on graphs
with n vertices (on dense graphs and with
a simple implementation).
3

Quick Solution
For arbitrary weight functions, we can
use the Bellman-Ford algorithm applied to
all vertices. This yields an O(n4) algorithm
for graphs with n vertices.

Floyd-Warshall
We will now investigate a dynamic
programming solution that solved the
problem in O(n3) time for a graph with n
vertices.
This algorithm is known as the FloydWarshall algorithm, but it was apparently
described earlier by Roy.
5

Representation of the Input


We assume that the input is represented by a
weight matrix W= (wij)i,j in E that is defined by
wij= 0
wij= w(i,j)
wij=

if i=j
if ij and (i,j) in E
if ij and (i,j) not in E

Format of the Output


If the graph has n vertices, we return a
distance matrix (dij), where dij the length
of the path from i to j.

Intermediate Vertices
Without loss of generality, we will assume that
V={1,2,,n}, i.e., that the vertices of the graph are
numbered from 1 to n.
Given a path p=(v1, v2,, vm) in the graph, we will
call the vertices vk with index k in {2,,m-1} the
intermediate vertices of p.

Key Definition
The key to the Floyd-Warshall algorithm
is the following definition:
Let dij(k) denote the length of the
shortest path from i to j such that all
intermediate vertices are contained in
the set {1,,k}.
9

Remark 1
A shortest path does not contain any
vertex twice, as this would imply that the
path contains a cycle. By assumption,
cycles in the graph have a positive weight,
so removing the cycle would result in a
shorter path, which is impossible.

10

Remark 2
Consider a shortest path p from i to j such
that the intermediate vertices are from the
set {1,,k}.
If the vertex k is not an intermediate
vertex on p, then dij(k) = dij(k-1)
If the vertex k is an intermediate vertex on
p, then dij(k) = dik(k-1) + dkj(k-1)
Interestingly, in either case, the subpaths contain merely
nodes from {1,,k-1}.
11

Remark 2
Therefore, we can conclude that
dij(k) = min{dij(k-1) , dik(k-1) + dkj(k-1)}

12

Recursive Formulation
If we do not use intermediate nodes, i.e.,
when k=0, then
dij(0) = wij
If k>0, then
dij(k) = min{dij(k-1) , dik(k-1) + dkj(k-1)}

13

The Floyd-Warshall Algorithm


Floyd-Warshall(W)
n = # of rows of W;
D(0) = W;
for k = 1 to n do
for i = 1 to n do
for j = 1 to n do
dij(k) = min{dij(k-1) , dik(k-1) + dkj(k-1)};
od;
od;
od;
return D(n);

14

Time and Space Requirements


The running time is obviously O(n3).
However, in this version, the space
requirements are high. One can reduce
the space from O(n3) to O(n2) by using
a single array d.

15

You might also like