1 / 64

Understanding Graph Algorithms: BFS and Representation Techniques

This document delves into key graph algorithms, primarily focusing on Graph Representation and Breadth-First Search (BFS). It explains graph structures, including undirected and directed graphs, as well as dense and sparse representations. The BFS algorithm is illustrated, highlighting its methodical approach to explore vertices and edges. The document details the vertex coloring technique to guide the search process and provides code examples, explaining runtime and storage complexities. Suitable for students and enthusiasts eager to learn fundamental graph algorithms.

saddam
Download Presentation

Understanding Graph Algorithms: BFS and Representation Techniques

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 332: Algorithms Graph Algorithms David Luebke 16/3/2014

  2. Administrative • Test postponed to Friday • Homework: • Turned in last night by midnight: full credit • Turned in tonight by midnight: 1 day late, 10% off • Turned in tomorrow night: 2 days late, 30% off • Extra credit lateness measured separately David Luebke 26/3/2014

  3. 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 David Luebke 36/3/2014

  4. 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(V2) • A dense representation • But, can be very efficient for small graphs • Especially if store just one bit/edge • Undirected graph: only need one diagonal of matrix David Luebke 46/3/2014

  5. Review: 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 • Choose certain edges to produce a tree • Note: might also build a forest if graph is not connected David Luebke 56/3/2014

  6. Review: 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. David Luebke 66/3/2014

  7. Review: Breadth-First Search • Again will 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 David Luebke 76/3/2014

  8. Review: Breadth-First Search BFS(G, s) { initialize vertices; Q = {s}; // Q is a queue (duh); initialize to 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 does v->d represent? What does v->p represent? David Luebke 86/3/2014

  9. Breadth-First Search: Example r s t u         v w x y David Luebke 96/3/2014

  10. Breadth-First Search: Example r s t u  0       v w x y Q: s David Luebke 106/3/2014

  11. Breadth-First Search: Example r s t u 1 0    1   v w x y Q: w r David Luebke 116/3/2014

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

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

  14. Breadth-First Search: Example r s t u 1 0 2 3 2 1 2  v w x y Q: x v u David Luebke 146/3/2014

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

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

  17. Breadth-First Search: Example r s t u 1 0 2 3 2 1 2 3 v w x y Q: y David Luebke 176/3/2014

  18. Breadth-First Search: Example r s t u 1 0 2 3 2 1 2 3 v w x y Q: Ø David Luebke 186/3/2014

  19. 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) David Luebke 196/3/2014

  20. 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 storage cost in addition to storing the graph? Total space used: O(max(degree(v))) = O(E) David Luebke 206/3/2014

  21. 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 • Proof given in the book (p. 472-5) • 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 David Luebke 216/3/2014

  22. 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 David Luebke 226/3/2014

  23. Depth-First Search • Vertices initially colored white • Then colored gray when discovered • Then black when finished David Luebke 236/3/2014

  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 David Luebke 246/3/2014

  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 What does u->d represent? David Luebke 256/3/2014

  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 What does u->f represent? David Luebke 266/3/2014

  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 Will all vertices eventually be colored black? David Luebke 276/3/2014

  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 = 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? David Luebke 286/3/2014

  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 = 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 Running time: O(n2) because call DFS_Visit on each vertex, and the loop over Adj[] can run as many as |V| times David Luebke 296/3/2014

  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 = 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 BUT, there is actually a tighter bound. How many times will DFS_Visit() actually be called? David Luebke 306/3/2014

  31. 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) David Luebke 316/3/2014

  32. 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 • Important to be comfortable with this kind of reasoning and analysis David Luebke 326/3/2014

  33. DFS Example sourcevertex David Luebke 336/3/2014

  34. DFS Example sourcevertex d f 1 | | | | | | | | David Luebke 346/3/2014

  35. DFS Example sourcevertex d f 1 | | | 2 | | | | | David Luebke 356/3/2014

  36. DFS Example sourcevertex d f 1 | | | 2 | | 3 | | | David Luebke 366/3/2014

  37. DFS Example sourcevertex d f 1 | | | 2 | | 3 | 4 | | David Luebke 376/3/2014

  38. DFS Example sourcevertex d f 1 | | | 2 | | 3 | 4 5 | | David Luebke 386/3/2014

  39. DFS Example sourcevertex d f 1 | | | 2 | | 3 | 4 5 | 6 | David Luebke 396/3/2014

  40. DFS Example sourcevertex d f 1 | 8 | | 2 | 7 | 3 | 4 5 | 6 | David Luebke 406/3/2014

  41. DFS Example sourcevertex d f 1 | 8 | | 2 | 7 | 3 | 4 5 | 6 | David Luebke 416/3/2014

  42. 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? David Luebke 426/3/2014

  43. DFS Example sourcevertex d f 1 | 8 | | 2 | 7 9 |10 3 | 4 5 | 6 | David Luebke 436/3/2014

  44. DFS Example sourcevertex d f 1 | 8 |11 | 2 | 7 9 |10 3 | 4 5 | 6 | David Luebke 446/3/2014

  45. DFS Example sourcevertex d f 1 |12 8 |11 | 2 | 7 9 |10 3 | 4 5 | 6 | David Luebke 456/3/2014

  46. DFS Example sourcevertex d f 1 |12 8 |11 13| 2 | 7 9 |10 3 | 4 5 | 6 | David Luebke 466/3/2014

  47. DFS Example sourcevertex d f 1 |12 8 |11 13| 2 | 7 9 |10 3 | 4 5 | 6 14| David Luebke 476/3/2014

  48. DFS Example sourcevertex d f 1 |12 8 |11 13| 2 | 7 9 |10 3 | 4 5 | 6 14|15 David Luebke 486/3/2014

  49. DFS Example sourcevertex d f 1 |12 8 |11 13|16 2 | 7 9 |10 3 | 4 5 | 6 14|15 David Luebke 496/3/2014

  50. DFS: Kinds of edges • DFS introduces an important distinction among edges in the original graph: • Tree edge: encounter new (white) vertex • The tree edges form a spanning forest • Can tree edges form cycles? Why or why not? David Luebke 506/3/2014

More Related