Download presentation

Presentation is loading. Please wait.

Published byKayley Wheelock Modified over 3 years ago

2
§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

3
§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 ). C1C3 i is a predecessor of j ::= there is a path from i to j i is an immediate predecessor of 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 ). Feasible AOV network must be a dag (directed acyclic graph). 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. 2/17

4
§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

5
§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. Goal Test an AOV for feasibility, and generate a topological order if possible. 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

6
§2 Topological Sort Improvement: Keep all the unassigned vertices of degree 0 in a special box (queue or stack). v1v1 v2v2 v6v6 v7v7 v3v3 v4v4 v5v5 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 */ } 0 v1v1 Indegree 1 v2v2 2 v3v3 3 v4v4 1 v5v5 3 v6v6 2 v7v7 v1v1 0 v2v2 1 21 0 v5v5 0 v4v4 1 v6v6 0 v3v3 2 0 v7v7 1 0 T = O( |V| + |E| ) Home work: p.339 9.2 What if a stack is used instead of a queue? 5/17 Mistakes in Fig 9.4 on p.289

7
§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. 6/17

8
§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 */ 7/17

9
§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. 8/17

10
§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| ) 9/17

11
§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 ] ). 10/17

12
§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| ) */ 11/17

13
§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 12/17

14
§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| ) 13/17

15
§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 14/17

16
§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. 15/17

17
§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. 16/17

18
Detailed requirements can be downloaded from http://10.71.45.99/list.asp?boardid=47 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. Due: Thursday, December 7th, 2006 at 10:00pm §3 Shortest Path Algorithms Laboratory Project 5 Saving James Bond 17/17

Similar presentations

Presentation is loading. Please wait....

OK

Graphs Upon completion you will be able to:

Graphs Upon completion you will be able to:

© 2018 SlidePlayer.com Inc.

All rights reserved.

Ads by Google

Ppt on web portal project Ppt on mughal emperor akbar Ppt on conservation of momentum worksheet Ppt on articles of association form Ppt on basic proportionality theorem for class 10 Vlsi physical design ppt on high level synthesis Ppt on how industries are polluting our water resources Ppt on production and operations management Ppt on soft skills for teachers Ppt on bluetooth and wifi