151 Views

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

**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**• 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**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 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**r s t u v w x y**Breadth-First Search: Example**r s t u 0 v w x y Q: s**Breadth-First Search: Example**r s t u 1 0 1 v w x y Q: w r**Breadth-First Search: Example**r s t u 1 0 2 1 2 v w x y Q: r t x**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: Example**r s t u 1 0 2 3 2 1 2 v w x y Q: x v u**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: Example**r s t u 1 0 2 3 2 1 2 3 v w x y Q: u y**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: Example**r s t u 1 0 2 3 2 1 2 3 v w x y Q: Ø**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 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**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**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?**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?**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?)**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?**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?**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()?**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**sourcevertex**DFS Example**sourcevertex d f 1 | | | | | | | |**DFS Example**sourcevertex d f 1 | | | 2 | | | | |**DFS Example**sourcevertex d f 1 | | | 2 | | 3 | | |**DFS Example**sourcevertex d f 1 | | | 2 | | 3 | 4 | |**DFS Example**sourcevertex d f 1 | | | 2 | | 3 | 4 5 | |**DFS Example**sourcevertex d f 1 | | | 2 | | 3 | 4 5 | 6 |**DFS Example**sourcevertex d f 1 | | | 2 | 7 | 3 | 4 5 | 6 |**DFS Example**sourcevertex d f 1 | 8 | | 2 | 7 | 3 | 4 5 | 6 |**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 Example**sourcevertex d f 1 | 8 | | 2 | 7 9 |10 3 | 4 5 | 6 |**DFS Example**sourcevertex d f 1 | 8 |11 | 2 | 7 9 |10 3 | 4 5 | 6 |**DFS Example**sourcevertex d f 1 |12 8 |11 | 2 | 7 9 |10 3 | 4 5 | 6 |**DFS Example**sourcevertex d f 1 |12 8 |11 13| 2 | 7 9 |10 3 | 4 5 | 6 |**DFS Example**sourcevertex d f 1 |12 8 |11 13| 2 | 7 9 |10 3 | 4 5 | 6 14|**DFS Example**sourcevertex d f 1 |12 8 |11 13| 2 | 7 9 |10 3 | 4 5 | 6 14|15**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**• A graph G is acyclic iff a DFS of G yields no back edges sourcevertex d f 1 | | | 2 | | 3 | | |**Directed Acyclic Graphs**• A directed acyclic graph or DAG is a directed graph with no directed cycles: Cyclic Acyclic**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 Watch Pants Shoes Shirt Belt Tie Jacket**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() { // 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