Download presentation

Presentation is loading. Please wait.

Published byGarrett Myatt Modified over 2 years ago

2
§3 Shortest Path Algorithms Given a digraph G = ( V, E ), and a cost function c( e ) for e E( G ). The length of a path P from source to destination is (also called weighted path length). 1. Single-Source Shortest-Path Problem Given as input a weighted graph, G = ( V, E ), and a distinguished vertex, s, find the shortest weighted path from s to every other vertex in G. v1v1 v2v2 v6v6 v7v7 v3v3 v4v4 v5v5 2 4 2 1310 2 5 8 4 6 1 v1v1 v2v2 v6v6 v7v7 v3v3 v4v4 v5v5 2 4 2 1 3 –10 2 5 8 4 6 1 Negative-cost cycle Note: If there is no negative-cost cycle, the shortest path from s to s is defined to be zero. 1/17

3
§3 Shortest Path Algorithms Unweighted Shortest Paths v1v1 v2v2 v6v6 v7v7 v3v3 v4v4 v5v5 0 0: v 3 1: v 1 and v 6 1 1 2: v 2 and v 4 2 2 3: v5v5 and v 7 3 3 Sketch of the idea Breadth-first search Implementation Table[ i ].Dist ::= distance from s to v i /* initialized to be except for s */ Table[ i ].Known ::= 1 if v i is checked; or 0 if not Table[ i ].Path ::= for tracking the path /* initialized to be 0 */ 2/17

4
§3 Shortest Path Algorithms void Unweighted( Table T ) { int CurrDist; Vertex V, W; for ( CurrDist = 0; CurrDist < NumVertex; CurrDist ++ ) { for ( each vertex V ) if ( !T[ V ].Known && T[ V ].Dist == CurrDist ) { T[ V ].Known = true; for ( each W adjacent to V ) if ( T[ W ].Dist == Infinity ) { T[ W ].Dist = CurrDist + 1; T[ W ].Path = V; } /* end-if Dist == Infinity */ } /* end-if !Known && Dist == CurrDist */ } /* end-for CurrDist */ } The worst case: v1v1 v2v2 v6v6 v7v7 v3v3 v4v4 v5v5 v9v9 v8v8 T = O( |V| 2 ) If V is unknown yet has Dist < Infinity, then Dist is either CurrDist or CurrDist+1. 3/17

5
§3 Shortest Path Algorithms Improvement void Unweighted( Table T ) { /* T is initialized with the source vertex S given */ Queue Q; Vertex V, W; Q = CreateQueue (NumVertex ); MakeEmpty( Q ); Enqueue( S, Q ); /* Enqueue the source vertex */ while ( !IsEmpty( Q ) ) { V = Dequeue( Q ); T[ V ].Known = true; /* not really necessary */ for ( each W adjacent to V ) if ( T[ W ].Dist == Infinity ) { T[ W ].Dist = T[ V ].Dist + 1; T[ W ].Path = V; Enqueue( W, Q ); } /* end-if Dist == Infinity */ } /* end-while */ DisposeQueue( Q ); /* free memory */ } v1v1 v2v2 v6v6 v7v7 v3v3 v4v4 v5v5 0 v1v1 Dist Path v2v2 0 v3v3 v4v4 v5v5 v6v6 v7v7 0 0 0 0 0 0 0 v3v3 v7v7 1 v3v3 v1v1 1 v3v3 v6v6 1 1 2 2 v1v1 v2v2 2 2 v1v1 v4v4 3 3 v2v2 v5v5 3 3 v4v4 T = O( |V| + |E| ) 4/17

6
§3 Shortest Path Algorithms Dijkstra’s Algorithm ( for weighted shortest paths ) Let S = { s and v i ’s whose shortest paths have been found } For any u S, define distance [ u ] = minimal length of path { s ( v i S ) u }. If the paths are generated in non-decreasing order, then the shortest path must go through ONLY v i S ; Why? If it is not true, then there must be a vertex w on this path that is not in S. Then... u is chosen so that distance[ u ] = min{ w S | distance[ w ] } (If u is not unique, then we may select any of them) ; /* Greedy Method */ if distance [ u 1 ] ). 5/17

7
§3 Shortest Path Algorithms void Dijkstra( Table T ) { /* T is initialized by Figure 9.30 on p.303 */ Vertex V, W; for ( ; ; ) { V = smallest unknown distance vertex; if ( V == NotAVertex ) break; T[ V ].Known = true; for ( each W adjacent to V ) if ( !T[ W ].Known ) if ( T[ V ].Dist + Cvw < T[ W ].Dist ) { Decrease( T[ W ].Dist to T[ V ].Dist + Cvw ); T[ W ].Path = V; } /* end-if update W */ } /* end-for( ; ; ) */ } v1v1 v2v2 v6v6 v7v7 v3v3 v4v4 v5v5 2 4 2 1310 2 5 8 4 6 1 0 v1v1 Dist Path v2v2 v3v3 v4v4 v5v5 v6v6 v7v7 0 0 0 0 0 0 0 2v1v1 1v1v1 3v4v4 3v4v4 9v4v4 5v4v4 8v3v3 6v7v7 /* not work for edge with negative cost */ Please read Figure 9.31 on p.304 for printing the path. /* O( |V| ) */ 6/17

8
§3 Shortest Path Algorithms Implementation 1 V = smallest unknown distance vertex; /* simply scan the table – O( |V| ) */ T = O( |V| 2 + |E| ) Good if the graph is dense Implementation 2 V = smallest unknown distance vertex; /* keep distances in a priority queue and call DeleteMin – O( log|V| ) */ Decrease( T[ W ].Dist to T[ V ].Dist + Cvw ); /* Method 1: DecreaseKey – O( log|V| ) */ T = O( |V| log|V| + |E| log|V| ) = O( |E| log|V| ) /* Method 2: insert W with updated Dist into the priority queue */ /* Must keep doing DeleteMin until an unknown vertex emerges */ Good if the graph is sparse T = O( |E| log|V| ) but requires |E| DeleteMin with |E| space Other improvements: Pairing heap (Ch.12) and Fibonacci heap (Ch. 11) Home work: p.339 9.5 Find the shortest paths p.340 9.10 Modify Dijkstra’s algorithm 7/17

9
§3 Shortest Path Algorithms Graphs with Negative Edge Costs Hey I have a good idea: why don’t we simply add a constant to each edge and thus remove negative edges? Too simple, and naïve… Try this one out: 1 34 2 2 – 2 2 1 void WeightedNegative( Table T ) { /* T is initialized by Figure 9.30 on p.303 */ Queue Q; Vertex V, W; Q = CreateQueue (NumVertex ); MakeEmpty( Q ); Enqueue( S, Q ); /* Enqueue the source vertex */ while ( !IsEmpty( Q ) ) { V = Dequeue( Q ); for ( each W adjacent to V ) if ( T[ V ].Dist + Cvw < T[ W ].Dist ) { T[ W ].Dist = T[ V ].Dist + Cvw; T[ W ].Path = V; if ( W is not already in Q ) Enqueue( W, Q ); } /* end-if update */ } /* end-while */ DisposeQueue( Q ); /* free memory */ } /* negative-cost cycle will cause indefinite loop */ /* no longer once per edge */ /* each vertex can dequeue at most |V| times */ T = O( |V| |E| ) 8/17

10
§3 Shortest Path Algorithms Acyclic Graphs If the graph is acyclic, vertices may be selected in topological order since when a vertex is selected, its distance can no longer be lowered without any incoming edges from unknown nodes. T = O( |E| + |V| ) and no priority queue is needed. Application: AOE ( Activity On Edge ) Networks —— scheduling a project vjvj a i ::= activity Signals the completion of a i EC[ j ] \ LC[ j ] ::= the earliest \ latest completion time for node v j CPM ( Critical Path Method ) Lasting Time Slack Time EC Time LC Time Index of vertex 9/17

11
§3 Shortest Path Algorithms 〖 Example 〗 AOE network of a hypothetical project 0 1 2 3 4 5 6 7 8 start finish a0=6 a1=4 a2=5 a3=1 a4=1 a5=2 a6=9 a7=7 a8=4 a9=2 a10=4 Calculation of EC: Start from v0, for any a i =, we have 0 6 4 5 7 7 16 14 18 a11=0 Dummy activity Calculation of LC: Start from the last vertex v8, for any a i =, we have 18 16 14 7 7 5 66 0 Slack Time of = 2 3 2 Critical Path ::= path consisting entirely of zero-slack edges. 10/17

12
§3 Shortest Path Algorithms 2. All-Pairs Shortest Path Problem For all pairs of v i and v j ( i j ), find the shortest path between. Method 1 Use single-source algorithm for |V| times. T = O( |V| 3 ) – works fast on sparse graph. Method 2 O( |V| 3 ) algorithm given in Ch.10, works faster on dense graphs. 11/17

13
§4 Network Flow Problems 〖 Example 〗 Consider the following network of pipes: s dc b a t 3 3 3 2 2 2 1 4 source sink Note: Total coming in (v) Total going out (v) where v { s, t } Note: Total coming in (v) Total going out (v) where v { s, t } Determine the maximum amount of flow that can pass from s to t. 12/17

14
§4 Network Flow Problems 1. A Simple Algorithm s dc b a t 3 3 3 2 2 2 1 4 G s dc b a t Flow G f s dc b a t Residual G r Step 1: Find any path s t in G r ; augmenting path Step 2: Take the minimum edge on this path as the amount of flow and add to G f ; Step 3: Update G r and remove the 0 flow edges; Step 4: If (there is a path s t in G r ) Goto Step 1 ; Else End. 13/17

15
§4 Network Flow Problems s dc b a t 3 3 3 2 2 2 1 4 G It is simple indeed. But I bet that you will point out some problems here… You are right! What if I pick up the path s a d t first? Uh-oh… Seems we cannot be greedy at this point. 14/17

16
§4 Network Flow Problems 2. A Solution – allow the algorithm to undo its decisions For each edge ( v, w ) with flow f v, w in G f, add an edge ( w, v ) with flow f v, w in G r. s dc b a t Flow G f s dc b a t 3 3 3 2 2 2 1 4 G s dc b a t Residual G r 3 3 3 2 2 2 1 4 3 3 3 3 3 1 3 2 2 2 2 2 2 2 1 3 2 2 1 〖 Proposition 〗 If the edge capabilities are rational numbers, this algorithm always terminate with a maximum flow. Note: The algorithm works for G with cycles as well. 15/17

17
§4 Network Flow Problems 3. Analysis ( If the capacities are all integers ) An augmenting path can be found by an unweighted shortest path algorithm. T = O( ) where f is the maximum flow.f · |E| s t ab 1 000 000 1 Always choose the augmenting path that allows the largest increase in flow. /* modify Dijkstra’s algorithm */ T = T augmentation * T find a path = O( |E| log cap max ) * O( |E| log |V| ) = O( |E| 2 log |V| ) if cap max is a small integer. 16/17

18
§4 Network Flow Problems Always choose the augmenting path that has the least number of edges. T = T augmentation * T find a path = O( |E| ) * O( |E| · |V| ) = O( |E| 2 |V| ) /* unweighted shortest path algorithm */ Note: If every v { s, t } has either a single incoming edge of capacity 1 or a single outgoing edge of capacity 1, then time bound is reduced to O( |E| |V| 1/2 ). The min-cost flow problem is to find, among all maximum flows, the one flow of minimum cost provided that each edge has a cost per unit of flow. Note: If every v { s, t } has either a single incoming edge of capacity 1 or a single outgoing edge of capacity 1, then time bound is reduced to O( |E| |V| 1/2 ). The min-cost flow problem is to find, among all maximum flows, the one flow of minimum cost provided that each edge has a cost per unit of flow. Home work: p.341 9.11 A test case. 17/17

Similar presentations

Presentation is loading. Please wait....

OK

Shortest Paths Definitions Single Source Algorithms

Shortest Paths Definitions Single Source Algorithms

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google

Ppt on diversity in living organisms of class 9 Ppt on human evolution Ppt on dance steps Ppt on review of related literature on research Ppt on crop production management Ppt on question tags games Ppt on power sharing in democracy people Ppt on html tags with examples Ppt on business entrepreneurship Ppt on polynomials in maths class