1. Graph Algorithms Searching

2. Review: Graphs ● A graph G = (V, E) ■ V = set of vertices, E = set of edges ■ Dense graph: |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 matrix represents 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->p represent? What does v->d represent?

8. Breadth-First Search: Example         rstu vwxy

9.   0      rstu vwxy s Q: Front

10. Breadth-First Search: Example 1  0 1     rstu vwxy w Q: r r->p = s

11. Breadth-First Search: Example 1  0 1 2 2   rstu vwxy r Q: tx

12. Breadth-First Search: Example 1 2 0 1 2 2   rstu vwxy Q: txv

13. Breadth-First Search: Example 1 2 0 1 2 2 3  rstu vwxy Q: xvu

14. Breadth-First Search: Example 1 2 0 1 2 2 3 3 rstu vwxy Q: vuy

15. Breadth-First Search: Example 1 2 0 1 2 2 3 3 rstu vwxy Q: uy

16. Breadth-First Search: Example 1 2 0 1 2 2 3 3 rstu vwxy Q: y

17. Breadth-First Search: Example 1 2 0 1 2 2 3 3 rstu vwxy Q: Ø

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

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

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

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

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

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

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

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

33. DFS Example 1 | | | | | | | | source vertex d f

34. DFS Example 1 | | | | | | 2 | | source vertex d f

35. DFS Example 1 | | | | |3 | 2 | | source vertex d f

36. DFS Example 1 | | | | |3 | 4 2 | | source vertex d f

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

38. DFS Example 1 | | | |5 | 63 | 4 2 | | source vertex d f

39. DFS Example 1 |8 | | |5 | 63 | 4 2 | 7 | source vertex d f

40. DFS Example 1 |8 | | |5 | 63 | 4 2 | 7 | source vertex d f

41. DFS Example 1 |8 | | |5 | 63 | 4 2 | 79 | source vertex d f

42. DFS Example 1 |8 | | |5 | 63 | 4 2 | 79 |10 source vertex d f

43. DFS Example 1 |8 |11 | |5 | 63 | 4 2 | 79 |10 source vertex d f

44. DFS Example 1 |128 |11 | |5 | 63 | 4 2 | 79 |10 source vertex d f

45. DFS Example 1 |128 |1113| |5 | 63 | 4 2 | 79 |10 source vertex d f

46. DFS Example 1 |128 |1113| 14|5 | 63 | 4 2 | 79 |10 source vertex d f

47. DFS Example 1 |128 |1113| 14|155 | 63 | 4 2 | 79 |10 source vertex d f

48. DFS Example 1 |128 |1113|16 14|155 | 63 | 4 2 | 79 |10 source vertex d f

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 1 |128 |1113|16 14|155 | 63 | 4 2 | 79 |10 source vertex d f Tree edges

51. DFS: Kinds of edges ● DFS introduces an important distinction among edges in original graph ■ Tree edge: encounter new (white) vertex ■ Back edge: from descendent to ancestor ○ Encounter a grey vertex (grey to grey)

52. DFS Example 1 |128 |1113|16 14|155 | 63 | 4 2 | 79 |10 source vertex d f Tree edges Back edges

53. DFS And Graph Cycles ● Thm: An undirected graph is acyclic iff a DFS yields no back edges ● Thus, can run DFS to find whether a graph has a cycle