1 / 53

Understanding Graph Searching Algorithms

Learn about graph representation, graph searching methods like Breadth-First Search (BFS) and Depth-First Search (DFS), with code examples for BFS, properties of BFS, and Depth-First Search exploration strategy.

zimmermann
Download Presentation

Understanding Graph Searching 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. Graph Algorithms Searching

  2. Review: Graphs • A graph G = (V, E) • V = set of vertices, E = set of edges • Densegraph: |E|  |V|2; Sparse graph: |E|  |V| • Undirected graph: • Edge (u,v) = Edge (v,u) • No self-loops • Directed graph: • Edge (u,v) goes from vertex u to vertex v, notated uv • A weighted graph associates weights with either the edges or the vertices

  3. Review: Representing Graphs • Assume V = {1, 2, …, n} • An adjacency matrixrepresents the graph as a n x n matrix A: • A[i, j] = 1 if edge (i, j)  E (or weight of edge) = 0 if edge (i, j)  E • Storage requirements: O(|V|2) • A dense representation • An adjacency list represents the graph as n lists of adjacent vertices • Storage requirements: O(|V| + |E|)

  4. 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 (origin of search) • Choose certain edges to produce a tree • Note: might also build a forest if graph is not connected

  5. Breadth-First Search • “Explore” a graph, turning it into a tree • One vertex at a time • Expand frontier of explored vertices across the breadth of the frontier • Builds a tree over the graph • Pick a source vertex to be the root • Find (“discover”) its children, then their children, etc.

  6. 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 are enqueued • Black vertices are discovered and fully explored • They are adjacent only to black and gray vertices • Fully explored  adjacency list fully processed • Explore vertices by scanning adjacency list of grey vertices

  7. Breadth-First Search BFS(G, s) { initialize vertices; // (For all v) [ v->color = WHITE, v->d = INF ] // s->color = GREY, s->d = 0 Q = {s}; // Q is a queue; initialize to s while (Q not empty) { u = RemoveFront(Q); for each v  u->Adj[] { 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?

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

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

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

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

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

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

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

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

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

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

  18. Touch every vertex: O(V) u = every vertex, but only once (Why?) So v = every vertex that appears in some other vert’s adjacency list BFS: The Code Again BFS(G, s) { initialize vertices; Q = {s}; while (Q not empty) { u = RemoveTop(Q); for each v  u->Adj[] { 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: O(V+E)

  19. BFS: The Code Again BFS(G, s) { initialize vertices; Q = {s}; while (Q not empty) { u = RemoveTop(Q); for each v  u->Adj[] { if (v->color == WHITE) v->color = GREY; v->d = u->d + 1; v->p = u; Enqueue(Q, v); } u->color = BLACK; } }

  20. Breadth-First Search: Properties • BFS calculates the shortest-path distance to the source node • Shortest-path distance (s,v) = minimum number of edges from s to v, or  if v not reachable from s • BFS builds breadth-first tree, in which paths to root represent shortest paths in G • Thus can use BFS to calculate shortest path from one vertex to another in O(V+E) time

  21. 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 most recently discovered vertex v that still has unexplored edges • When all of v’s edges have been explored, backtrack to vertex from which v was discovered

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

  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; u->d = time; for each v  u->Adj[] { if (v->color == WHITE) DFS_Visit(v); } u->color = BLACK; ++time; u->f = time; } Depth-First Search: Code

  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; u->d = time; for each v  u->Adj[] { if (v->color == WHITE) DFS_Visit(v); } u->color = BLACK; ++time; u->f = time; } Depth-First Search: Code What does u->d represent?

  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; u->d = time; for each v  u->Adj[] { if (v->color == WHITE) DFS_Visit(v); } u->color = BLACK; ++time; u->f = time; } Depth-First Search: Code What does u->f represent?

  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; u->d = time; for each v  u->Adj[] { if (v->color == WHITE) DFS_Visit(v); } u->color = BLACK; ++time; u->f = time; } Depth-First Search: Code Will all vertices eventually be colored black?

  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; u->d = time; for each v  u->Adj[] { if (v->color == WHITE) DFS_Visit(v); } u->color = BLACK; ++time; u->f = time; } Depth-First Search: Code What will be the running time?

  28. 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; u->d = time; for each v  u->Adj[] { if (v->color == WHITE) DFS_Visit(v); } u->color = BLACK; ++time; u->f = time; } Depth-First Search: Code Running time: O(n2) because call DFS_Visit on each vertex, and the loop over Adj[] can run as many as |V| times

  29. 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; u->d = time; for each v  u->Adj[] { if (v->color == WHITE) DFS_Visit(v); } u->color = BLACK; ++time; u->f = time; } Depth-First Search: Code BUT, there is actually a tighter bound. How many times will DFS_Visit() actually be called?

  30. 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; u->d = time; for each v  u->Adj[] { if (v->color == WHITE) DFS_Visit(v); } u->color = BLACK; ++time; u->f = time; } Depth-First Search: Code So, running time of DFS = O(V+E)

  31. Depth-First Sort Analysis • This running time argument is an informal example of amortized analysis • “Charge” the exploration of edge to the edge • Each loop in DFS_Visit can be attributed to an edge in the graph • Runs once/edge if directed graph, twice if undirected • Thus loop will run in O(E) time, algorithm O(V+E) • Considered linear for graph, b/c adj list requires O(V+E) storage

  32. DFS Example sourcevertex

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  49. DFS: Kinds of edges • DFS introduces an important distinction among edges in original graph • Tree edge: encounter new (white) vertex • Form a spanning forest • Can tree edges form cycles? Why or why not?

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

More Related