§2 Topological Sort

§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


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


【 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


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


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


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


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


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


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


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


〖 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


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


Laboratory Project 5Saving James Bond

17/17

http://10.71.45.99/list.asp?boardid=47

§2 Topological Sort

Documents

Transcript of §2 Topological Sort