Scribd
Upload
83 views23 pages

Floyd

Uploaded by

Muhammad Arsalan
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
83 views23 pages

Floyd

Uploaded by

Muhammad Arsalan
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 23

Floyds Algorithm

All pairs shortest path

Floyds 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
Floyds Algorithm 2

The weight matrix and the graph


1

1 2 3 4 5

1 0 9 3

2 1 0

3 3 0 2

4 1 2 4 0

5 5 3 0

3
5 v5

v1
1

9 2

v2
3

v4

2
4

v3

Floyds 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.

Floyds 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) ?

Floyds 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

Vi

Vj
Shortest Path using intermediate vertices { V1, . . . Vk -1 }
Floyds 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

Vi

Vj
Shortest Path using intermediate vertices { V1, . . . Vk -1 }
Floyds 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

Floyds 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 ]

Floyds Algorithm 9

Example
W=
1 4 2 2 -3 P= 5 3 1 2 3

D0 =

1 2 3

1 0 2

2 4 0 -3

3 5

1 0 0 0

2 0 0 0

3 0 0 0

Floyds Algorithm 10

1
4

5
2 -3

D0 =
3

1 2 3

1 0 2

2 4 0 -3

3 5

1 1= D 2

1 0 2

2 4 0 -3
2 0

3 5 7 0
3 0

k=1 Vertex 1 can be intermediate node

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

1 0

P=

2 3

0 0

0 0

1 0

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

Floyds Algorithm 11

1
4

5
2 -3

D1 = 1
3 2 3

1 0 2

2 4 0 -3

3 5 7 0

1 2= D 2

1 0 2 -1
1 0

2 4 0 -3
2 0

3 5 7 0
3 0

k=2 Vertices 1, 2 can be intermediate

D2[1,3] = min( D1[1,3], D1[1,2]+D1[2,3] ) = min (5, 4+7) =5

P=

2 3

0 2

0 0

1 0

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

Floyds Algorithm 12

1
4

D2 = 1 1 0 3 2 2 2 -3 3 -1
5

2 4 0 -3

3 5 7 0

D3 =

1 2

1 0 2 -1
1 0

2 2 0 -3
2 3

3 5 7 0
3 0

k=3 Vertices 1, 2, 3 can be intermediate

D3[1,2] = min(D2[1,2], D2[1,3]+D2[3,2] ) = min (4, 5+(-3)) =2

P=

2 3

0 2

0 0

1 0

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

Floyds 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.
Floyds 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

Floyds 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?

Floyds 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]
Floyds 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 ]

Floyds 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;

Floyds Algorithm 19

Printing intermediate nodes on shortest path from q to r


path(index q, r) if (P[ q, r ]!=0) path(q, P[q, r]) println( v+ P[q, r]) path(P[q, r], r) return; //no intermediate nodes else return

1 P= 2 3

1 0 0 2

2 3 0 0

3 0 1 0

5 2 -3

Before calling path check D[q, r] < , and 4 print node q, after the call to path print node r 2

Floyds Algorithm 20

Example

Floyds Algorithm 21

The final distance matrix and P

The values in parenthesis are the non zero P values.


Floyds Algorithm 22

The call tree for Path(1, 4)


Path(1, 4)

Path(1, 6) P(1, 6)=0

Print v6 Path(6, 3)

Path(6, 4)

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

Print Path(3, 4) v3 P(3, 4)=0

You might also like