§2 topological sort 〖 example 〗 courses needed for a computer science degree at a hypothetical...
TRANSCRIPT
§2 Topological Sort
〖 Example〗 Courses needed for a computer science degree at a hypothetical university
Course number Course name PrerequisitesC1 Programming I NoneC2 Discrete Mathematics NoneC3 Data Structure C1, C2C4 Calculus I NoneC5 Calculus II C4C6 Linear Algebra C5C7 Analysis of Algorithms C3, C6C8 Assembly Language C3C9 Operating Systems C7, C8C10 Programming Languages C7C11 Compiler Design C10C12 Artificial Intelligence C7C13 Computational Theory C7C14 Parallel Algorithms C13C15 Numerical Analysis C6
How shall we convert this list into a graph?
1/17
§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 ).
Feasible AOV network must be a Feasible AOV network must be a dagdag (directed acyclic graph). (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.
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
§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:
Course number Course name Prerequisites
C1 Programming I None C2 Discrete Mathematics None C4 Calculus I None C3 Data Structure C1, C2 C5 Calculus II C4 C6 Linear Algebra C5 C7 Analysis of Algorithms C3, C6 C15 Numerical Analysis C6 C8 Assembly Language C3 C10 Programming Languages C7 C9 Operating Systems C7, C8 C12 Artificial Intelligence C7 C13 Computational Theory C7 C11 Compiler Design C10 C14 Parallel Algorithms C13
3/17
§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.
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.
GoalGoal 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
§2 Topological Sort
Improvement: Keep all the unassigned vertices of degree 0 in a special box (queue or stack).
v1 v2
v6 v7
v3 v4 v5
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 */}
0v1
Indegree
1v2
2v3
3v4
1v5
3v6
2v7v1
0
v2
1210 v5
0 v4
1
v6
0 v3
20
v7
10
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
§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).Pe
i
i
ec )(
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.
v1 v2
v6 v7
v3 v4 v5
2
4
2
1 3 10
2
58 4 6
1
v1 v2
v6 v7
v3 v4 v5
2
4
2
13
–10
2
58 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.
Note: If there is no negative-cost cycle, the shortest path from s to s is defined to be zero.
6/17
§3 Shortest Path Algorithms
Unweighted Shortest Paths
v1 v2
v6 v7
v3 v4 v50
0: v3
1: v1 and v6
1
1
2: v2 and v4
2
2
3: v5 and v7
3
3
Sketch of the idea
Breadth-first search
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
§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: v1v2v6v7 v3v4v5v9 v8
T = O( |V|2 )
If V is unknown yet has Dist < Infinity, then Dist is either CurrDist or Cur
rDist+1.
8/17
§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 */}
v1 v2
v6 v7
v3 v4 v5
0
v1
Dist Path
v2
0v3
v4
v5
v6
v7
0000000 v3
v71 v3
v1
1 v3 v6
1
1
2
2
v1
v2
2
2
v1
v4
3
3
v2
v5
3
3
v4
T = O( |V| + |E| )
9/17
§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 ONLY vi S ;
Why? If it is not true, thenthere must be a vertex w on this path
that is not in S. Then ...
u is chosen so that distance[ u ] = min{ wS | distance[
w ] } (If u is not unique, then we may select any of them) ; /* Greedy Method */
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 ] = dist
ance [ u1 ] + length(< u1, u2>).
10/17
§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( ; ; ) */}
v1 v2
v6 v7
v3 v4 v5
2
4
2
1 3 10
2
58 4 6
1
0v1
Dist Path
v2
v3
v4
v5
v6
v7
0
0
0
0
0
0
0
2 v1
1 v1
3 v4
3 v4
9 v4
5 v4
8 v36 v7/* not work for edge with negative cost */
Please read Figure 9.31 on p.304 for printing the path.
/* O( |V| ) */
11/17
§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 pathsp.340 9.10
Modify Dijkstra’s algorithm
12/17
§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 removenegative edges?
Too simple, and naïve… Try this one out:
1
3 4
22
– 2
21
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
§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
vjai ::= activity Signals the completion of ai
EC[ j ] \ LC[ j ] ::= the earliest \ latest completion time for node vj
CPM ( Critical Path Method )Lasting Time
Slack Time
EC Time
LC Time
Index of vertex
14/17
§3 Shortest Path Algorithms
〖 Example〗 AOE network of a hypothetical project
01
2
3
4
5
6
78
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 ai = <v, w>, we have}][{max][ ,
),(wv
EwvCvECwEC
06
4
5
7
7
16
14
18
a11=0
Dummy activity
Calculation of LC: Start from the last vertex v8, for any ai = <v, w>, we have }][{min][ ,
),(wv
EwvCwLCvLC
18
16
14
7
75
6
60
Slack Time of <v,w> = wvCvECwLC ,][][
2
3
2
Critical Path ::= path consisting entirely of zero-slack edges.
15/17
§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 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
Detailed requirements can be downloaded from http://10.71.45.99/list.asp?boardid=47
Courseware Download
Don’t forget to signyou names
and duties at the end of your report.
Due: Thursday, December 7th, 2006 at 10:00pm
§3 Shortest Path Algorithms
Laboratory Project 5Saving James Bond
17/17