Cs 3343 analysis of algorithms
This presentation is the property of its rightful owner.
Sponsored Links
1 / 54

CS 3343: Analysis of Algorithms PowerPoint PPT Presentation


  • 103 Views
  • Uploaded on
  • Presentation posted in: General

CS 3343: Analysis of Algorithms. Lecture 24: Graph searching, Topological sort. Review of MST and shortest path problem. Run Kruskal’s algorithm Run Prim’s algorithm Run Dijkstra’s algorithm. 2. f. c. 4. 7. 8. 8. a. d. g. 6. 7. 6. 1. 3. 5. 6. b. e. Graph Searching.

Download Presentation

CS 3343: Analysis of Algorithms

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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Cs 3343 analysis of algorithms

CS 3343: Analysis of Algorithms

Lecture 24: Graph searching, Topological sort


Review of mst and shortest path problem

Review of MST and shortest path problem

  • Run Kruskal’s algorithm

  • Run Prim’s algorithm

  • Run Dijkstra’s algorithm

2

f

c

4

7

8

8

a

d

g

6

7

6

1

3

5

6

b

e


Graph searching

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

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


Breadth first search1

Breadth-First Search

  • 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


Breadth first search2

Breadth-First Search

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.d represent?

What does v.p represent?


Breadth first search example

Breadth-First Search: Example

r

s

t

u

v

w

x

y


Breadth first search example1

Breadth-First Search: Example

r

s

t

u

0

v

w

x

y

Q:

s


Breadth first search example2

Breadth-First Search: Example

r

s

t

u

1

0

1

v

w

x

y

Q:

w

r


Breadth first search example3

Breadth-First Search: Example

r

s

t

u

1

0

2

1

2

v

w

x

y

Q:

r

t

x


Breadth first search example4

Breadth-First Search: Example

r

s

t

u

1

0

2

2

1

2

v

w

x

y

Q:

t

x

v


Breadth first search example5

Breadth-First Search: Example

r

s

t

u

1

0

2

3

2

1

2

v

w

x

y

Q:

x

v

u


Breadth first search example6

Breadth-First Search: Example

r

s

t

u

1

0

2

3

2

1

2

3

v

w

x

y

Q:

v

u

y


Breadth first search example7

Breadth-First Search: Example

r

s

t

u

1

0

2

3

2

1

2

3

v

w

x

y

Q:

u

y


Breadth first search example8

Breadth-First Search: Example

r

s

t

u

1

0

2

3

2

1

2

3

v

w

x

y

Q:

y


Breadth first search example9

Breadth-First Search: Example

r

s

t

u

1

0

2

3

2

1

2

3

v

w

x

y

Q:

Ø


Bfs the code again

Touch every vertex: Θ(n)

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

v = every vertex that appears in some other vert’s adjacency list

Total: Θ(m)

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?

Total running time: Θ(n+m)


Depth first search

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 search1

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;

for each vertex u  G->V

{

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;

}

Depth-First Search: The Code


Depth first search the code1

DFS(G)

{

for each vertex u  G->V

{

u->color = WHITE;

}

time = 0;

for each vertex u  G->V

{

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;

}

Depth-First Search: The Code

What does u->d represent?


Depth first search the code2

DFS(G)

{

for each vertex u  G->V

{

u->color = WHITE;

}

time = 0;

for each vertex u  G->V

{

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;

}

Depth-First Search: The Code

What does u->f represent?


Depth first search the code3

DFS(G)

{

for each vertex u  G->V

{

u->color = WHITE;

}

time = 0;

for each vertex u  G->V

{

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;

}

Depth-First Search: The Code

Will all vertices eventually be colored black? (How about in BFS?)


Depth first search the code4

DFS(G)

{

for each vertex u  G->V

{

u->color = WHITE;

}

time = 0;

for each vertex u  G->V

{

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;

}

Depth-First Search: The Code

What will be the running time?


Depth first search the code5

DFS(G)

{

for each vertex u  G->V

{

u->color = WHITE;

}

time = 0;

for each vertex u  G->V

{

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;

}

Depth-First Search: The Code

How many times will DFS_Visit() be called?


Depth first search the code6

DFS(G)

{

for each vertex u  G->V

{

u->color = WHITE;

}

time = 0;

for each vertex u  G->V

{

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;

}

Depth-First Search: The Code

How much time is needed within each DFS_Visit()?


Depth first search the code7

DFS(G)

{

for each vertex u  G->V

{

u->color = WHITE;

}

time = 0;

for each vertex u  G->V

{

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;

}

Depth-First Search: The Code

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


Dfs example

DFS Example

sourcevertex


Dfs example1

DFS Example

sourcevertex

d f

1 |

|

|

|

|

|

|

|


Dfs example2

DFS Example

sourcevertex

d f

1 |

|

|

2 |

|

|

|

|


Dfs example3

DFS Example

sourcevertex

d f

1 |

|

|

2 |

|

3 |

|

|


Dfs example4

DFS Example

sourcevertex

d f

1 |

|

|

2 |

|

3 | 4

|

|


Dfs example5

DFS Example

sourcevertex

d f

1 |

|

|

2 |

|

3 | 4

5 |

|


Dfs example6

DFS Example

sourcevertex

d f

1 |

|

|

2 |

|

3 | 4

5 | 6

|


Dfs example7

DFS Example

sourcevertex

d f

1 |

|

|

2 | 7

|

3 | 4

5 | 6

|


Dfs example8

DFS Example

sourcevertex

d f

1 |

8 |

|

2 | 7

|

3 | 4

5 | 6

|


Dfs example9

DFS Example

sourcevertex

d f

1 |

8 |

|

2 | 7

9 |

3 | 4

5 | 6

|

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


Dfs example10

DFS Example

sourcevertex

d f

1 |

8 |

|

2 | 7

9 |10

3 | 4

5 | 6

|


Dfs example11

DFS Example

sourcevertex

d f

1 |

8 |11

|

2 | 7

9 |10

3 | 4

5 | 6

|


Dfs example12

DFS Example

sourcevertex

d f

1 |12

8 |11

|

2 | 7

9 |10

3 | 4

5 | 6

|


Dfs example13

DFS Example

sourcevertex

d f

1 |12

8 |11

13|

2 | 7

9 |10

3 | 4

5 | 6

|


Dfs example14

DFS Example

sourcevertex

d f

1 |12

8 |11

13|

2 | 7

9 |10

3 | 4

5 | 6

14|


Dfs example15

DFS Example

sourcevertex

d f

1 |12

8 |11

13|

2 | 7

9 |10

3 | 4

5 | 6

14|15


Dfs example16

DFS Example

sourcevertex

d f

1 |12

8 |11

13|16

2 | 7

9 |10

3 | 4

5 | 6

14|15


Dfs and cycles in graph

DFS and cycles in graph

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

sourcevertex

d f

1 |

|

|

2 |

|

3 |

|

|


Directed acyclic graphs

Directed Acyclic Graphs

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

Cyclic

Acyclic


Topological sort

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

Getting Dressed

Underwear

Socks

Watch

Pants

Shoes

Shirt

Belt

Tie

Jacket


Getting dressed1

Getting Dressed

Underwear

Socks

Watch

Pants

Shoes

Shirt

Belt

Tie

Jacket

Socks

Underwear

Pants

Shoes

Watch

Shirt

Belt

Tie

Jacket


Topological sort algorithm

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  uf > vf


Correctness of topological sort

Correctness of Topological Sort

  • Claim: (u,v)  G  uf > vf

    • When (u,v) is explored, u is grey

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

      • v = white  v becomes descendent of u  vf < uf (since must finish v before backtracking and finishing u)

      • v = black  v already finished  vf < uf


Another algorithm

Another Algorithm

  • Store vertices in a priority min-queue, with thein-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

0

1

2

2

1

4

7

8

1

3

5

6

1

0

1

9

2

3


Another algorithm1

Another Algorithm

  • Store vertices in a priority min-queue, with thein-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

0

1

0

0

1

0

2

2

1

4

7

1

8

0

1

3

5

6

1

0

0

1

9

0

2

1

3

0

2


Topological sort runtime

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|)


  • Login