1 / 54

CS 3343: Analysis of Algorithms

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.

dominique-dudley
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. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CS 3343: Analysis of Algorithms Lecture 24: Graph searching, Topological sort

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

  3. 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

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

  5. 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

  6. 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?

  7. Breadth-First Search: Example r s t u         v w x y

  8. Breadth-First Search: Example r s t u  0       v w x y Q: s

  9. Breadth-First Search: Example r s t u 1 0    1   v w x y Q: w r

  10. Breadth-First Search: Example r s t u 1 0 2   1 2  v w x y Q: r t x

  11. Breadth-First Search: Example r s t u 1 0 2  2 1 2  v w x y Q: t x v

  12. Breadth-First Search: Example r s t u 1 0 2 3 2 1 2  v w x y Q: x v u

  13. Breadth-First Search: Example r s t u 1 0 2 3 2 1 2 3 v w x y Q: v u y

  14. Breadth-First Search: Example r s t u 1 0 2 3 2 1 2 3 v w x y Q: u y

  15. Breadth-First Search: Example r s t u 1 0 2 3 2 1 2 3 v w x y Q: y

  16. Breadth-First Search: Example r s t u 1 0 2 3 2 1 2 3 v w x y Q: Ø

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

  18. 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

  19. Depth-First Search • Vertices initially colored white • Then colored gray when discovered • Then black when finished

  20. 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

  21. 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?

  22. 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?

  23. 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?)

  24. 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?

  25. 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?

  26. 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()?

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

  28. DFS Example sourcevertex

  29. DFS Example sourcevertex d f 1 | | | | | | | |

  30. DFS Example sourcevertex d f 1 | | | 2 | | | | |

  31. DFS Example sourcevertex d f 1 | | | 2 | | 3 | | |

  32. DFS Example sourcevertex d f 1 | | | 2 | | 3 | 4 | |

  33. DFS Example sourcevertex d f 1 | | | 2 | | 3 | 4 5 | |

  34. DFS Example sourcevertex d f 1 | | | 2 | | 3 | 4 5 | 6 |

  35. DFS Example sourcevertex d f 1 | | | 2 | 7 | 3 | 4 5 | 6 |

  36. DFS Example sourcevertex d f 1 | 8 | | 2 | 7 | 3 | 4 5 | 6 |

  37. 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?

  38. DFS Example sourcevertex d f 1 | 8 | | 2 | 7 9 |10 3 | 4 5 | 6 |

  39. DFS Example sourcevertex d f 1 | 8 |11 | 2 | 7 9 |10 3 | 4 5 | 6 |

  40. DFS Example sourcevertex d f 1 |12 8 |11 | 2 | 7 9 |10 3 | 4 5 | 6 |

  41. DFS Example sourcevertex d f 1 |12 8 |11 13| 2 | 7 9 |10 3 | 4 5 | 6 |

  42. DFS Example sourcevertex d f 1 |12 8 |11 13| 2 | 7 9 |10 3 | 4 5 | 6 14|

  43. DFS Example sourcevertex d f 1 |12 8 |11 13| 2 | 7 9 |10 3 | 4 5 | 6 14|15

  44. DFS Example sourcevertex d f 1 |12 8 |11 13|16 2 | 7 9 |10 3 | 4 5 | 6 14|15

  45. 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 | | |

  46. Directed Acyclic Graphs • A directed acyclic graph or DAG is a directed graph with no directed cycles: Cyclic Acyclic

  47. 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

  48. Getting Dressed Underwear Socks Watch Pants Shoes Shirt Belt Tie Jacket

  49. Getting Dressed Underwear Socks Watch Pants Shoes Shirt Belt Tie Jacket Socks Underwear Pants Shoes Watch Shirt Belt Tie Jacket

  50. 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

More Related