1. Mudasser Naseer 1 1/9/2016 CS 201: Design and Analysis of Algorithms Lecture # 17 Elementary Graph Algorithms (CH # 22)

2. Graphs ● Graphs are one of the unifying themes of computer science. A graph G = (V, E) is defined by a set of vertices V, and a set of edges E consisting of ordered or unordered pairs of vertices from V. ● Thus a graph G = (V, E) ■ V = set of vertices ■ E = set of edges = subset of V  V ■ Thus |E| = O(|V| 2 ) Mudasser Naseer 2 1/9/2016

3. Examples ● Road Networks ■ In modeling a road network, the vertices may represent the cities or junctions, certain pairs of which are connected by roads/edges. Mudasser Naseer 3 1/9/2016

4. Examples ● Electronic Circuits ■ In an electronic circuit, with junctions as vertices and components as edges. Mudasser Naseer 4 1/9/2016

5. Graph Variations ● Variations: ■ A connected graph has a path from every vertex to every other ■ In an undirected graph: ○ Edge (u,v) = Edge (v,u) ○ Thus |E| <= |V| (|V|-1)/2 ○ No self-loops A ONM LKJ EFGH DCB I P Mudasser Naseer 5 1/9/2016

6. ■ In a directed graph: ○ Edge (u,v) goes from vertex u to vertex v, notated u  v ○ (u,v) is different from (v,u) ○ Thus |E| <= |V| (|V|-1) ● Road networks between cities are typically undirected. ● Street networks within cities are almost always directed because of one-way streets. ● Most graphs of graph-theoretic interest are undirected. A EFGH DCB I Graph Variations Mudasser Naseer 6 1/9/2016

7. Graph Variations ● More variations: ■ A weighted graph associates weights with either the edges or the vertices ○ E.g., a road map: edges might be weighted with their length, drive-time or speed limit. ■ In unweighted graphs, there is no cost distinction between various edges and vertices. Mudasser Naseer 7 1/9/2016

8. ■ A multigraph allows multiple edges between the same vertices ○ E.g., the call graph in a program (a function can get called from multiple points in another function) Mudasser Naseer 8 1/9/2016

9. Simple vs. Non-simple Graphs ● Certain types of edges complicate the task of working with graphs. A self-loop is an edge (x; x) involving only one vertex. ● An edge (x; y) is a multi-edge if it occurs more than once in the graph. ● Any graph which avoids these structures is called simple. Mudasser Naseer 9 1/9/2016

10. Spars Vs Dense Graphs ● Graphs are sparse when only a small fraction of the possible number of vertex pairs actually have edges defined between them. ● Graphs are usually sparse due to application- specific constraints. ● Road networks must be sparse because of road junctions. Mudasser Naseer 10 1/9/2016

11. ● Typically dense graphs have a quadratic number of edges while sparse graphs are linear in size. ● We will typically express running times in terms of |E| and |V| (often dropping the |’s) ■ If |E|  |V| 2 the graph is dense ■ If |E|  |V| the graph is sparse ● If you know you are dealing with dense or sparse graphs, different data structures may make sense Spars Vs Dense Graphs Mudasser Naseer 11 1/9/2016

12. ● An acyclic graph does not contain any cycles. Trees are connected acyclic undirected graphs. ● Directed acyclic graphs are called DAGs. They arise naturally in scheduling problems, where a directed edge (x; y) indicates that x must occur before y. Cyclic vs. Acyclic Graphs Mudasser Naseer 12 1/9/2016

13. Labeled vs. Unlabeled Graphs ● In labeled graphs, each vertex is assigned a unique name or identifier to distinguish it from all other vertices. ● An important graph problem is isomorphism testing, determining whether the topological structure of two graphs are in fact identical if we ignore any labels. Mudasser Naseer 13 1/9/2016

14. Subgraphs ● A subgraph S of a graph G is a graph such that ■ The edges of S are a subset of the edges of G ● A spanning subgraph of G is a subgraph that contains all the vertices of G Subgraph Spanning subgraph

15. Trees and Forests ● A (free) tree is an undirected graph T such that ■ T is connected ■ T has no cycles This definition of tree is different from the one of a rooted tree ● A forest is an undirected graph without cycles ● The connected components of a forest are trees Tree Forest

16. Spanning Trees and Forests ● A spanning tree of a connected graph is a spanning subgraph that is a tree ● A spanning tree is not unique unless the graph is a tree ● Spanning trees have applications to the design of communication networks ● A spanning forest of a graph is a spanning subgraph that is a forest Graph Spanning tree

17. Graph in Applications ● Internet: web graphs ■ Each page is a vertex ■ Each edge represent a hyperlink ■ Directed ● GPS: highway maps ■ Each city is a vertex ■ Each freeway segment is an undirected edge ■ Undirected ● Graphs are ubiquitous in computer science Mudasser Naseer 17 1/9/2016

18. 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 Mudasser Naseer 18 1/9/2016

19. Graphs: Adjacency Matrix ● Example: 1 24 3 a d bc A1234 1 2 ? 3 4 Mudasser Naseer 19 1/9/2016

20. Graphs: Adjacency Matrix ● Example: 1 24 3 a d bc A1234 10110 20010 30000 40010 Mudasser Naseer 20 1/9/2016

21. Graphs: Adjacency Matrix ● How much storage does the adjacency matrix require? ● A: O(V 2 ) ● What is the minimum amount of storage needed by an adjacency matrix representation of an undirected graph with 4 vertices? ● A: 6 bits ■ Undirected graph  matrix is symmetric ■ No self-loops  don’t need diagonal Mudasser Naseer 21 1/9/2016

22. Graphs: Adjacency Matrix ● The adjacency matrix is a dense representation ■ Usually too much storage for large graphs ■ But can be very efficient for small graphs ● Most large interesting graphs are sparse ■ E.g., planar graphs, in which no edges cross, have |E| = O(|V|) by Euler’s formula ■ For this reason the adjacency list is often a more appropriate respresentation Mudasser Naseer 22 1/9/2016

23. Graphs: Adjacency List ● Adjacency list: for each vertex v  V, store a list of vertices adjacent to v ● Example: ■ Adj[1] = {2,3} ■ Adj[2] = {3} ■ Adj[3] = {} ■ Adj[4] = {3} ● Variation: can also keep a list of edges coming into vertex 1 24 3 Mudasser Naseer 23 1/9/2016

24. Graphs: Adjacency List ● How much storage is required? ■ The degree of a vertex v in an undirected graph = # incident edges ○ Directed graphs have in-degree, out-degree ■ For directed graphs, # of items in adjacency lists is  out-degree(v) = |E| takes  (V + E) storage (Why?) ■ For undirected graphs, # items in adj lists is  degree(v) = 2 |E| also  (V + E) storage ● So: Adjacency lists take O(V+E) storage Mudasser Naseer 24 1/9/2016

25. Graph Representation Mudasser Naseer 25 1/9/2016

26. Google Problem:Graph Searching ● How to search and explore in the Web Space? ● How to find all web-pages and all the hyperlinks? ■ Start from one vertex “www.google.com” ■ Systematically follow hyperlinks from the discovered vertex/web page ■ Build a search tree along the exploration Mudasser Naseer 26 1/9/2016

27. General 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 Mudasser Naseer 27 1/9/2016

28. 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. Mudasser Naseer 28 1/9/2016

29. 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 Mudasser Naseer 29 1/9/2016

30. A ONM LKJ EFGH DCB I P 0 Mudasser Naseer 30 1/9/2016

31. A ONM LKJ EFGH DCB I P 0 1 1 1 Mudasser Naseer 31 1/9/2016

32. A ONM LKJ EFGH DCB I P 0 1 1 1 2 2 Mudasser Naseer 32 1/9/2016

33. A ONM LKJ EFGH DCB I P 0 1 1 1 2 2 33 3 3 3 Mudasser Naseer 33 1/9/2016

34. A ONM LKJ EFGH DCB I P 0 1 1 1 2 2 33 3 3 3 44 4 Mudasser Naseer 34 1/9/2016

35. A ONM LKJ EFGH DCB I P 0 1 1 1 2 2 33 3 3 3 44 4 5 5 Mudasser Naseer 35 1/9/2016

36. A ONM LKJ EFGH DCB I P 0 1 1 1 2 2 33 3 3 3 44 4 5 5 Mudasser Naseer 36 1/9/2016

37. A ONM LKJ EFGH DCB I P 0 1 1 1 2 2 33 3 3 3 44 4 5 5 Mudasser Naseer 37 1/9/2016

38. 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->p represent? What does v->d represent? Mudasser Naseer 38 1/9/2016

39. Breadth-First Search: Example         rstu vwxy Mudasser Naseer 39 1/9/2016

40. Breadth-First Search: Example   0      rstu vwxy s Q: Mudasser Naseer 40 1/9/2016

41. Breadth-First Search: Example 1  0 1     rstu vwxy w Q: r Mudasser Naseer 41 1/9/2016

42. Breadth-First Search: Example 1  0 1 2 2   rstu vwxy r Q: tx Mudasser Naseer 42 1/9/2016

43. Breadth-First Search: Example 1 2 0 1 2 2   rstu vwxy Q: txv Mudasser Naseer 43 1/9/2016

44. Breadth-First Search: Example 1 2 0 1 2 2 3  rstu vwxy Q: xvu Mudasser Naseer 44 1/9/2016

45. Breadth-First Search: Example 1 2 0 1 2 2 3 3 rstu vwxy Q: vuy Mudasser Naseer 45 1/9/2016

46. Breadth-First Search: Example 1 2 0 1 2 2 3 3 rstu vwxy Q: uy Mudasser Naseer 46 1/9/2016

47. Breadth-First Search: Example 1 2 0 1 2 2 3 3 rstu vwxy Q: y Mudasser Naseer 47 1/9/2016

48. Breadth-First Search: Example 1 2 0 1 2 2 3 3 rstu vwxy Q: Ø Mudasser Naseer 48 1/9/2016

49. 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) Mudasser Naseer 49 1/9/2016

50. 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 tree? Total space used: O(max(degree(v))) = O(E) Mudasser Naseer 50 1/9/2016

51. 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 Mudasser Naseer 51 1/9/2016

52. Properties of BFS ● Proposition: Let G be a graph with n vertices and m edges. A BFS traversal of G takes time O(n + m). Also, there exist O(n + m) time algorithms based on BFS for the following problems: ■ Testing whether G is connected. ■ Computing a spanning tree of G ■ Computing the connected components of G ■ Computing, for every vertex v of G, the minimum number of edges of any path between s and v. Mudasser Naseer 52 1/9/2016