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
1 2 3 4 5 v1 v2
3
1 0 1  1 5 9
5 1 3
2 9 0 3 2  2
v5
3   0 4  3 2
v4 v3
4   2 0 3 4
5 3    0

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 } Vk

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 } Vk

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
1 0 4 5
W=D =
0
2 2 0 
1 5
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 1 2 3
D =1
0
0 4 5 k=1
4 2 3 Vertex 1 can
2 2 0 
2 -3

be 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] )
D =
1
= 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
intermediate
1 2 3
1 0 4 5 D2[1,3] = min( D1[1,3], D1[1,2]+D1[2,3] )
D =
2
= 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)
3 2 0 0 = -1

Floyd’s Algorithm 12
 1 5 D2 = 1 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
intermediate
1 2 3
1 0 2 5 D3[1,2] = min(D2[1,2], D2[1,3]+D2[3,2] )
D = 3
2 2 0 7 = min (4, 5+(-3))
3 -1 -3 0 =2

1 2 3
1 0 3 0 D3[2,1] = min(D2[2,1], D2[2,3]+D2[3,1] )
= 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)
if (P[ q, r ]0)
1 2 3
path(q, P[q, r]) 1 0 3 0
println( “v”+ P[q, r]) 0 0 1
path(P[q, r], r)
P= 2
return; 3 2 0 0
//no intermediate nodes
else return
1 5
Before calling path check D[q, r] < , and print
node q, after the call to 3
4 2
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