Floyd’s Algorithm

All pairs shortest path

Floyd’s Algorithm 1
 All pairs shortest path

• The problem: find the shortest path between every

pair of vertices of a graph

• The graph: may contain negative edges but no

negative cycles

• A representation: a weight matrix where

W(i,j)=0 if i=j.
W(i,j)=∞ if there is no edge between i and j.
W(i,j)=“weight of edge”
• Note: we have shown principle of optimality
applies to shortest path problems

Floyd’s Algorithm 2
The weight matrix and the graph
1
3 v1 v2
9
5
1 2 3
v5
3 2
v4 v3
4

Floyd’s Algorithm 3
 The subproblems

• How can we define the shortest distance di,j in terms

of “smaller” problems?

• One way is to restrict the paths to only include

vertices from a restricted subset.

• Initially, the subset is empty.

• Then, it is incrementally increased until it includes

all the vertices.

Floyd’s Algorithm 4
 The subproblems
• Let D(k)[i,j]=weight of a shortest path from vi to vj
using only vertices from {v1,v2,…,vk} as
intermediate vertices in the path

– D(0)=W
– D(n)=D which is the goal matrix

• How do we compute D(k) from D(k-1) ?

Floyd’s Algorithm 5
 The Recursive Definition:
Case 1: A shortest path from vi to vj restricted to using
only vertices from {v1,v2,…,vk} as intermediate vertices
does not use vk. Then D(k)[i,j]= D(k-1)[i,j].

Case 2: A shortest path from vi to vj restricted to using

only vertices from {v1,v2,…,vk} as intermediate vertices
does use vk. Then D(k)[i,j]= D(k-1)[i,k]+ D(k-1)[k,j].
Shortest path using intermediate vertices
{V1, . . . Vk } V k

Vj
Vi

Shortest Path using intermediate vertices { V1, . . . Vk -1 }

Floyd’s Algorithm 6
 The recursive definition
• Since
D(k)[i,j]= D(k-1)[i,j] or
D(k)[i,j]= D(k-1)[i,k]+ D(k-1)[k,j].
We conclude:
D(k)[i,j]= min{ D(k-1)[i,j], D(k-1)[i,k]+ D(k-1)[k,j] }.

Shortest path using intermediate vertices

{V1, . . . Vk } V k

Vj
Vi

Shortest Path using intermediate vertices { V1, . . . Vk -1 }

Floyd’s Algorithm 7
 The pointer array P
• Used to enable finding a shortest path
• Initially the array contains 0

• Each time that a shorter path from i to j is found

the k that provided the minimum is saved
(highest index node on the path from i to j)

• To print the intermediate nodes on the shortest

path a recursive procedure that print the shortest
paths from i and k, and from k to j can be used

Floyd’s Algorithm 8
 Floyd's Algorithm Using n+1 D matrices

Floyd//Computes shortest distance between all pairs of

//nodes, and saves P to enable finding shortest paths
1. D0 ← W // initialize D array to W [ ]
2. P ← 0 // initialize P array to [0]
3. for k ← 1 to n
4. do for i ← 1 to n
5. do for j ← 1 to n
6. if (Dk-1[ i, j ] > Dk-1 [ i, k ] + Dk-1 [ k, j ] )
7. then Dk[ i, j ] ← Dk-1 [ i, k ] + Dk-1 [ k, j ]
8. P[ i, j ] ← k;
9. else Dk[ i, j ] ← Dk-1 [ i, j ]

Floyd’s Algorithm 9
 Example
1 2 3
0
1 0 4 5
W=D =
5 2 2 0 ∞
1
3 ∞ -3 0
4 2 3
1 2 3
-3 1 0 0 0
2
P= 2 0 0 0
3 0 0 0

Floyd’s Algorithm 10
 1 5 0
1 2 3
D =1
0 4 5 k=1
4 2 3 Vertex 1 can be
2 2 0 ∞
2
-3 intermediate
3 ∞ -3 0
node
1 2 3
1 0 4 5 D1[2,3] = min( D0[2,3], D0[2,1]+D0[1,3] )
1
D = = min (∝, 7)
2 2 0 7
=7
3 ∞ -3 0

1 2 3 D1[3,2] = min( D0[3,2], D0[3,1]+D0[1,2] )

1 0 0 0 = min (-3,∝)
P= 2 0 0 1 = -3

3 0 0 0

Floyd’s Algorithm 11
 1 2 3
1 5 D1 = 1 0 4 5 k=2
4 2 3 2 2 0 7 Vertices 1, 2
2
-3 3 ∞ -3 0 can be
1 2 3
intermediate
1 0 4 5 D2[1,3] = min( D1[1,3], D1[1,2]+D1[2,3] )
2
D = = min (5, 4+7)
2 2 0 7
=5
3 -1 -3 0

1 2 3
1 0 0 0 D2[3,1] = min( D1[3,1], D1[3,2]+D1[2,1] )
P= 2 0 0 1 = min (∝, -3+2)
= -1
3 2 0 0

Floyd’s Algorithm 12
 D2 = 1
1 5 2 3
1 0 4 5 k=3
4 2 3
2 2 0 7 Vertices 1, 2, 3
-3
2 3 -1 -3 0 can be
1 2 3
intermediate
1
3
0 2 5 D3[1,2] = min(D2[1,2], D2[1,3]+D2[3,2] )
D =
2 2 0 7 = min (4, 5+(-3))
3 -1 -3 0 =2

1 2 3
D3[2,1] = min(D2[2,1], D2[2,3]+D2[3,1] )
1 0 3 0
= min (2, 7+ (-1))
P= 2 0 0 1 =2
3 2 0 0

Floyd’s Algorithm 13
 Floyd's Algorithm: Using 2 D matrices

Floyd
1. D ← W // initialize D array to W [ ]
2. P ← 0 // initialize P array to [0]
3. for k ← 1 to n
// Computing D’ from D
4. do for i ← 1 to n
5. do for j ← 1 to n
6. if (D[ i, j ] > D[ i, k ] + D[ k, j ] )
7. then D’[ i, j ] ← D[ i, k ] + D[ k, j ]
8. P[ i, j ] ← k;
9. else D’[ i, j ] ← D[ i, j ]
10. Move D’ to D.

Floyd’s Algorithm 14
 Can we use only one D matrix?

• D[i,j] depends only on elements in the kth column

and row of the distance matrix.
• We will show that the kth row and the kth column
of the distance matrix are unchanged when Dk is
computed
• This means D can be calculated in-place

Floyd’s Algorithm 15
 The main diagonal values

• Before we show that kth row and column of D

remain unchanged we show that the main diagonal
remains 0

• D(k)[ j,j ] = min{ D(k-1)[ j,j ] , D(k-1)[ j,k ] + D(k-1)[ k,j ] }

= min{ 0, D(k-1)[ j,k ] + D(k-1)[ k,j ] }
=0
• Based on which assumption?

Floyd’s Algorithm 16
 The kth column

• kth column of Dk is equal to the kth column of Dk-1

• Intuitively true - a path from i to k will not become

shorter by adding k to the allowed subset of
intermediate vertices

• For all i, D(k)[i,k] =

= min{ D(k-1)[i,k], D(k-1)[i,k]+ D(k-1)[k,k] }
= min { D(k-1)[i,k], D(k-1)[i,k]+0 }
= D(k-1)[i,k]

Floyd’s Algorithm 17
 The kth row

• kth row of Dk is equal to the kth row of Dk-1

For all j, D(k)[k,j] =

= min{ D(k-1)[k,j], D(k-1)[k,k]+ D(k-1)[k,j] }
= min{ D(k-1)[ k,j ], 0+D(k-1)[k,j ] }
= D(k-1)[ k,j ]

Floyd’s Algorithm 18
 Floyd's Algorithm using a single D
Floyd
1. D ← W // initialize D array to W [ ]
2. P ← 0 // initialize P array to [0]
3. for k ← 1 to n
4. do for i ← 1 to n
5. do for j ← 1 to n
6. if (D[ i, j ] > D[ i, k ] + D[ k, j ] )
7. then D[ i, j ] ← D[ i, k ] + D[ k, j ]
8. P[ i, j ] ← k;

Floyd’s Algorithm 19
Printing intermediate nodes on shortest path
from q to r
path(index q, r)
1 2 3
if (P[ q, r ]!=0)
path(q, P[q, r]) 1 0 3 0
println( “v”+ P[q, r]) P= 2 0 0 1
path(P[q, r], r)
3 2 0 0
return;
//no intermediate nodes
else return
1 5
Before calling path check D[q, r] < ∞, and
print node q, after the call to 4 2 3
path print node r -3
2

Floyd’s Algorithm 20
Example

Floyd’s Algorithm 21
 The final distance matrix and P

The values in parenthesis are the non zero P values.

Floyd’s Algorithm 22
 The call tree for Path(1, 4)
Path(1, 4)

Path(1, 6) Path(6, 4)
Print
P(1, 6)=0 v6

Path(6, 3) Print Path(3, 4)

v3
P(6, 3)=0 P(3, 4)=0
The intermediate nodes on the shortest path from 1 to 4 are v6, v3.
The shortest path is v1, v6, v3, v4.
Floyd’s Algorithm 23