1 / 17

§2 Topological Sort

§2 Topological Sort. 〖 Example 〗 Courses needed for a computer science degree at a hypothetical university. How shall we convert this list into a graph?. 1/17. §2 Topological Sort.

umay
Download Presentation

§2 Topological Sort

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. §2 Topological Sort 〖Example〗 Courses needed for a computer science degree at a hypothetical university How shall we convert this list into a graph? 1/17

  2. §2 Topological Sort  AOV Network ::= digraph G in which V( G ) represents activities ( e.g. the courses ) and E( G ) represents precedence relations ( e.g. means that C1 is a prerequisite course of C3 ). C1 C3  i is a predecessor of j ::= there is a path from i to j i is an immediate predecessor of j ::= < i, j >  E( G ) Then j is called a successor ( immediate successor ) of i  Partial order ::= a precedence relation which is both transitive ( i k, k j  i j ) and irreflexive ( i i is impossible ). Note: If the precedence relation is reflexive, then there must be an i such that i is a predecessor of i. That is, i must be done before i is started. Therefore if a project is feasible, it must be irreflexive. Feasible AOV network must be a dag (directed acyclic graph). 2/17

  3. §2 Topological Sort 【Definition】A topological order is a linear ordering of the vertices of a graph such that, for any two vertices, i, j, if i is a predecessor of j in the network then i precedes j in the linear ordering. 〖Example〗One possible suggestion on course schedule for a computer science degree could be: 3/17

  4. §2 Topological Sort Note: The topological orders may not be unique for a network. For example, there are several ways (topological orders) to meet the degree requirements in computer science. Test an AOV for feasibility, and generate a topological order if possible. Goal void Topsort( Graph G ) { int Counter; Vertex V, W; for ( Counter = 0; Counter < NumVertex; Counter ++ ) { V = FindNewVertexOfDegreeZero( ); if ( V == NotAVertex ) { Error ( “Graph has a cycle” ); break; } TopNum[ V ] = Counter; /* or output V */ for ( each W adjacent to V ) Indegree[ W ] – – ; } } /* O( |V| ) */  T = O( |V|2 ) 4/17

  5. §2 Topological Sort v1 v2 v3 v4 v5 Indegree v1 0 v2 1 v6 v7 v3 2 v4 3 v5 1 v6 3 v7 2 Improvement: Keep all the unassigned vertices of degree 0 in a special box (queue or stack). Mistakes in Fig 9.4 on p.289 void Topsort( Graph G ) { Queue Q; int Counter = 0; Vertex V, W; Q = CreateQueue( NumVertex ); MakeEmpty( Q ); for ( each vertex V ) if ( Indegree[ V ] == 0 ) Enqueue( V, Q ); while ( !IsEmpty( Q ) ) { V = Dequeue( Q ); TopNum[ V ] = ++ Counter; /* assign next */ for ( each W adjacent to V ) if ( – – Indegree[ W ] == 0 ) Enqueue( W, Q ); } /* end-while */ if ( Counter != NumVertex ) Error( “Graph has a cycle” ); DisposeQueue( Q ); /* free memory */ } T = O( |V| + |E| ) Home work: p.339 9.2 What if a stack is used instead of a queue? v6 v7 0 v3 1 0 v4 2 0 1 v5 0 2 1 0 v2 1 0 v1 5/17

  6. 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). 2 v1 v2 2 v1 v2 4 1 –10 4 1 3 10 3 2 2 v3 v4 v5 2 2 v3 v4 v5 8 4 8 6 5 4 6 5 1 v6 v7 1 v6 v7 §3 Shortest Path Algorithms 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. Negative-cost cycle Note: If there is no negative-cost cycle, the shortest path from s to s is defined to be zero. 6/17

  7. §3 Shortest Path Algorithms v1 v2 v3 v4 v5 v6 v7  Unweighted Shortest Paths  Sketch of the idea 0: v3 1 2 Breadth-first search 1:  v1 and v6 2 0 3 2:  v2 and v4 3:  1 3 v5 and v7  Implementation Table[ i ].Dist ::= distance from s to vi/* initialized to be  except for s */ Table[ i ].Known ::= 1 if vi is checked; or 0 if not Table[ i ].Path ::= for tracking the path /* initialized to be 0 */ 7/17

  8. §3 Shortest Path Algorithms v8 v7 v6 v5 v3 v2 v1 v9 v4 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 */ } If V is unknown yet has Dist < Infinity, then Dist is either CurrDist or CurrDist+1.  T = O( |V|2 ) The worst case: 8/17

  9. §3 Shortest Path Algorithms v1 v2 v3 v4 v5 v6 v7 DistPath v1  0 v2  0 v3 0 0 v4  0 v5  0 v6  0 v7  0  Improvement 1 2 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 */ } 0 3 2 3 1 1 v3 v7 2 v1 v5 v4 2 v1 v2 3 v2 1 v3 v6 3 v4 v3 v1 T = O( |V| + |E| ) 9/17

  10. §3 Shortest Path Algorithms Dijkstra’s Algorithm (for weighted shortest paths) Let S = { s and vi’s whose shortest paths have been found } For any u S, define distance [ u ] = minimal length of path { s ( vi S )  u }. If the paths are generated in non-decreasing order, then  the shortest path must go through ONLYvi S ;  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 */ Why? If it is not true, then there must be a vertex w on this path that is not in S. Then ...  if distance [ u1 ] < distance [ u2 ] and we add u1 into S, then distance [ u2 ] may change. If so, a shorter path from s to u2 must go through u1 and distance’ [ u2 ] = distance [ u1 ] + length(< u1, u2>). 10/17

  11. §3 Shortest Path Algorithms Dist Path v1 0 0 6 8 9 5 1 3 3 2 v3 v7 v4 v1 v4 v4 v4 v1 v2  0 v3  0 v4  0 v5  0 2 v1 v2 v6  0 4 1 3 10 v7  0 2 2 v3 v4 v5 8 4 6 5 1 v6 v7 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( ; ; ) */ } /* O( |V| ) */ /* not work for edge with negative cost */ Please read Figure 9.31 on p.304 for printing the path. 11/17

  12. §3 Shortest Path Algorithms  Implementation 1 V = smallest unknown distance vertex; /* simply scan the table – O( |V| ) */ Good if the graph is dense T = O( |V|2 + |E| )  Implementation 2 Home work: p.339 9.5 Find the shortest paths p.340 9.10 Modify Dijkstra’s algorithm 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 ); Good if the graph is sparse /* 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 */ T = O( |E| log|V| ) but requires |E| DeleteMin with |E| space  Other improvements: Pairing heap (Ch.12) and Fibonacci heap (Ch. 11) 12/17

  13. §3 Shortest Path Algorithms Too simple, and naïve… Try this one out: 2 1 2 – 2 1 3 4 2  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? 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 */ } T = O( |V|  |E| ) /* each vertex can dequeue at most |V| times */ /* no longer once per edge */ /* negative-cost cycle will cause indefinite loop */ 13/17

  14. §3 Shortest Path Algorithms Signals the completion ofai ai ::= activity vj Index of vertex EC Time Lasting Time Slack Time LC Time  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  EC[ j ] \ LC[ j ] ::= the earliest \ latest completion time for node vj  CPM ( Critical Path Method ) 14/17

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

  16. §3 Shortest Path Algorithms 2. All-Pairs Shortest Path Problem For all pairs of vi and vj( i j ), find the shortest path between. Method 1 Use single-source algorithmfor |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. 16/17

  17. §3 Shortest Path Algorithms Laboratory Project 5 Saving James Bond Due: Thursday, December 7th, 2006 at 10:00pm Detailed requirements can be downloaded from http://10.71.45.99/list.asp?boardid=47 Courseware Download Don’t forget to sign you names and duties at the end of your report. 17/17

More Related