cs 3343: analysis of algorithms lecture 24: graph searching, topological sort

CS 3343: Analysis of Algorithms

Lecture 24: Graph searching, Topological sort

Midterm 2 overview

0 100

2

4

6

8

0 50

5

10

15

20

25

0 10 200

5

10

15

0 50

5

10

15

20

25

0 5 10 150

5

10

15

20

25

0 5 10 150

5

10

15

20

25

30

0 5 10 150

2

4

6

8

10

0 5 10 15 200

5

10

15

20

25

Midterm 2 overview: overall

50 60 70 80 90 100 1100

1

2

3

4

5

6

7

8

9

Semester overview

36 42 48 54 600

1

2

3

4

5

6

7

8

9

10

ABCD

Review of MST and shortest path problem

• Run Kruskal’s algorithm

• Run Prim’s algorithm

• Run Dijkstra’s algorithm

a

c

b

f

e

d g

4

5

6

1

6

2

8

6

8

3

7

7

Graph Searching

• Given: a graph G = (V, E), directed or undirected• Goal: methodically explore every vertex (and

every edge)• Ultimately: build a tree on the graph

– Pick a vertex as the root– Find (“discover”) its children, then their children, etc.– Note: might also build a forest if graph is not

connected– Here we only consider that the graph is connected

Breadth-First Search

• “Explore” a graph, turning it into a tree– Pick a source vertex to be the root– Expand frontier of explored vertices across

the breadth of the frontier


• Associate vertex “colors” to guide the algorithm– White vertices have not been discovered

• All vertices start out white

– Grey vertices are discovered but not fully explored• They may be adjacent to white vertices

– Black vertices are discovered and fully explored• They are adjacent only to black and gray vertices

• Explore vertices by scanning adjacency list of grey vertices


BFS(G, s) {

initialize vertices; // mark all vertices as white

Q = {s}; // Q is a queue; initialize to s

while (Q not empty) {

u = Dequeue(Q);

for each v adj[u] if (v.color == WHITE) {

v.color = GREY;

v.d = u.d + 1;

v.p = u;

Enqueue(Q, v);

}

u.color = BLACK;

}

}

What does v.p represent?

What does v.d represent?

Breadth-First Search: Example

r s t u

v w x y


0

r s t u

v w x y

sQ:


1

0

1

r s t u

v w x y

wQ: r


1

0

1

2

2

r s t u

v w x y

rQ: t x


1

2

0

1

2

2

r s t u

v w x y

Q: t x v


1

2

0

1

2

2

3

r s t u

v w x y

Q: x v u


1

2

0

1

2

2

3

3

r s t u

v w x y

Q: v u y


1

2

0

1

2

2

3

3

r s t u

v w x y

Q: u y


1

2

0

1

2

2

3

3

r s t u

v w x y

Q: y


1

2

0

1

2

2

3

3

r s t u

v w x y

Q: Ø

BFS: The Code Again

BFS(G, s) {

initialize vertices;

Q = {s};

while (Q not empty) {

u = Dequeue(Q);

for each v adj[u] if (v.color == WHITE) {

v.color = GREY;

v.d = u.d + 1;

v.p = u;

Enqueue(Q, v);

}

u.color = BLACK;

}

} What will be the running time?

Touch every vertex: Θ(n)

u = every vertex, but only once (Why?)

v = every vertex that appears in some other vert’s adjacency listTotal: Θ(m)

Total running time: Θ(n+m)

Depth-First Search

• Depth-first search is another strategy for exploring a graph– Explore “deeper” in the graph whenever

possible– Edges are explored out of the most recently

discovered vertex v that still has unexplored edges

– When all of v’s edges have been explored, backtrack to the vertex from which v was discovered

Depth-First Search

• Vertices initially colored white

• Then colored gray when discovered

• Then black when finished

Depth-First Search: The Code

DFS(G)

{

for each vertex u G->V {

u->color = WHITE;

}

time = 0;


if (u->color == WHITE)

DFS_Visit(u);

}

}

DFS_Visit(u)

{

u->color = GREY;

time = time+1;

u->d = time;

for each v u->Adj[] {

if (v->color == WHITE)

DFS_Visit(v);

}

u->color = BLACK;

time = time+1;

u->f = time;

}


DFS(G)

{


u->color = WHITE;

}

time = 0;



DFS_Visit(u);

}

}

DFS_Visit(u)

{

u->color = GREY;

time = time+1;

u->d = time;



DFS_Visit(v);

}

u->color = BLACK;

time = time+1;

u->f = time;

}

What does u->d represent?


DFS(G)

{


u->color = WHITE;

}

time = 0;



DFS_Visit(u);

}

}

DFS_Visit(u)

{

u->color = GREY;

time = time+1;

u->d = time;



DFS_Visit(v);

}

u->color = BLACK;

time = time+1;

u->f = time;

}

What does u->f represent?


DFS(G)

{


u->color = WHITE;

}

time = 0;



DFS_Visit(u);

}

}

DFS_Visit(u)

{

u->color = GREY;

time = time+1;

u->d = time;



DFS_Visit(v);

}

u->color = BLACK;

time = time+1;

u->f = time;

}Will all vertices eventually be colored black?

(How about in BFS?)


DFS(G)

{


u->color = WHITE;

}

time = 0;



DFS_Visit(u);

}

}

DFS_Visit(u)

{

u->color = GREY;

time = time+1;

u->d = time;



DFS_Visit(v);

}

u->color = BLACK;

time = time+1;

u->f = time;

}

What will be the running time?


DFS(G)

{


u->color = WHITE;

}

time = 0;



DFS_Visit(u);

}

}

DFS_Visit(u)

{

u->color = GREY;

time = time+1;

u->d = time;



DFS_Visit(v);

}

u->color = BLACK;

time = time+1;

u->f = time;

}

How many times will DFS_Visit() be called?


DFS(G)

{


u->color = WHITE;

}

time = 0;



DFS_Visit(u);

}

}

DFS_Visit(u)

{

u->color = GREY;

time = time+1;

u->d = time;



DFS_Visit(v);

}

u->color = BLACK;

time = time+1;

u->f = time;

}

How much time is needed within each DFS_Visit()?


DFS(G)

{


u->color = WHITE;

}

time = 0;



DFS_Visit(u);

}

}

DFS_Visit(u)

{

u->color = GREY;

time = time+1;

u->d = time;



DFS_Visit(v);

}

u->color = BLACK;

time = time+1;

u->f = time;

}

So, running time of DFS = O(V+E)

DFS Examplesourcevertex

DFS Example

1 | | |

| | 3 |

2 | |

d f

sourcevertex

DFS Example

1 | | |

| | 3 | 4

2 | |

d f

sourcevertex

DFS Example

1 | | |

| 5 | 3 | 4

2 | |

d f

sourcevertex

DFS Example

1 | | |

| 5 | 63 | 4

2 | |

d f

sourcevertex

DFS Example

1 | | |

| 5 | 63 | 4

2 | 7 |

d f

sourcevertex

DFS Example

1 | 8 | |

| 5 | 63 | 4

2 | 7 |

d f

sourcevertex

DFS Example

1 | 8 | |

| 5 | 63 | 4

2 | 7 9 |

d f

What is the structure of the grey vertices? What do they represent?

sourcevertex

DFS Example

1 | 8 | |

| 5 | 63 | 4

2 | 7 9 |10

d f

sourcevertex

DFS Example

1 | 8 |11 |

| 5 | 63 | 4

2 | 7 9 |10

d f

sourcevertex

DFS Example

1 |12 8 |11 |

| 5 | 63 | 4

2 | 7 9 |10

d f

sourcevertex

DFS Example

1 |12 8 |11 13|

| 5 | 63 | 4

2 | 7 9 |10

d f

sourcevertex

DFS Example

1 |12 8 |11 13|

14| 5 | 63 | 4

2 | 7 9 |10

d f

sourcevertex

DFS Example

1 |12 8 |11 13|

14|155 | 63 | 4

2 | 7 9 |10

d f

sourcevertex

DFS Example

1 |12 8 |11 13|16

14|155 | 63 | 4

2 | 7 9 |10

sourcevertex

d f

DFS and cycles in graph

• A graph G is acyclic iff a DFS of G yields no back edges

1 | | |

| | 3 |

2 | |

d f

sourcevertex

Directed Acyclic Graphs

• A directed acyclic graph or DAG is a directed graph with no directed cycles:

Acyclic Cyclic

Topological Sort

• Topological sort of a DAG:– Linear ordering of all vertices in graph G such

that vertex u comes before vertex v if edge (u, v) G

• Real-world example: getting dressed

Getting Dressed

Underwear Socks

ShoesPants

Belt

Shirt

Watch

Tie

Jacket

Getting Dressed

Underwear Socks

ShoesPants

Belt

Shirt

Watch

Tie

Jacket

Socks Underwear Pants Shoes Watch Shirt Belt Tie Jacket

Topological Sort Algorithm

Topological-Sort()

{ // condition: the graph is a DAG

Run DFS

When a vertex is finished, output it

Vertices are output in reverse topological order

}

• Time: O(V+E)

• Correctness: Want to prove that(u,v) G uf > vf

Correctness of Topological Sort

• Claim: (u,v) G uf > vf– When (u,v) is explored, u is grey

• v = grey (u,v) is back edge. Contradiction (Why?)

• v = white v becomes descendent of u vf < uf (since must finish v before backtracking and finishing u)

• v = black v already finished vf < uf

Another Algorithm• Store vertices in a priority min-queue, with the in-degree of the vertex as the key• While queue is not empty

• Extract minimum vertex v, and give it next number• Decrease keys of all adjacent vertices by 1

33 55 66

44

22

77

99

88110 22

1

1

3

1 10

Another Algorithm• Store vertices in a priority min-queue, with the in-degree of the vertex as the key• While queue is not empty

• Extract minimum vertex v, and give it next number• Decrease keys of all adjacent vertices by 1

33 55 66

44

22

77

99

88110 22

1

1

3

1 10

1

2

0

0

0

1

0

0

0

10

Topological Sort Runtime

Runtime:• O(|V|) to build heap + O(|E|) DECREASE-KEY ops O(|V| + |E| log |V|) with a binary heap O(|V|2) with an array

Compare to DFS: O(|V|+|E|)

cs 3343: analysis of algorithms lecture 24: graph searching, topological sort

Documents