Graphs

1. Graphs 15-211 Fundamental Data Structures and Algorithms Ananda Gunawardena April 4, 2006

2. In this lecture • concept • Representations • Adjacency matrix • Adjacency List • Graph Traversals • BFS, DFS • Minimum Spanning Trees • Search Engines

3. Introduction to Graphs

4. Definition • Graph G = <V,E> • Set V of vertices (nodes) • Set E of edges • Elements of E are pair (v,w) where v,w  V. • An edge (v,v) is a self-loop. (Usually assume no self-loops.) • Weighted graph • Elements of E are ((v,w),x) where x is a weight. • Directed graph (digraph) • The edge pairs are ordered • Undirected graph (ugraph) • The edge pairs are unordered • E is a symmetric relation • (v,w)  E implies (w,v)  E • In an undirected graph (v,w) and (w,v) are the same edge

5. Paths and cycles • A path is a sequence of nodes v1, v2, …, vN such that (vi,vi+1)E for 0<i≤N • The length of the path is N-1. • Simple path: all vi are distinct, 0<i ≤ N • A cycle is a path such that v1=vN • An acyclic graph has no cycles • A graph is connected if • given any two vertices vi and vj there exists A path from vi to vj figure 14.1 A directed graph

6. Vertices (aka nodes) Edges A weighted Graph BOS 618 DTW SFO 2273 211 190 PIT 318 JFK 1987 344 2145 2462 LAX Weights (Undirected)

7. Applications of directed graphs • Many of the common applications of graphs use directed graphs. • Often this occurs when the edges represent an asymmetric relationship. • E.g., the inheritance relationship between classes. • E.g., scheduling constraints.

8. Example: Course prerequisites 15-111 21-127 15-211 15-251 15-212 15-213 15-312 15-411 15-462 15-412 15-451

9. Example: Construction plan Building permit Pour foundation Framing Electrical wiring Plumbing Paint exterior Paint interior

10. Graph Density • Max number of edges in a digraph with n vertices • Max number of edges in a ugraph with n vertices?

11. Dense Graphs vs Sparse Graphs • A dense graph is a graph where the number of edges is relatively large compared to number of nodes • When is a graph a dense graph? • We could use • |E| = O(|V|2) - Dense • |E| = O(|V|) - Sparse • Examples of • Dense Graphs • Each node is connected to at least 25% of other nodes • Sparse Graphs • Each node is connected to only a constant number of other nodes

12. Relevance of a Node • Suppose G =<V,E> is a digraph and u is a vertex in V. Then • indegree(u) = {v | (v,u) in E} • That is, number of links into node u • outdegree(u) = {v | (u,v) in E} • i.e. number of links out of u

13. Finding indeg and outdeg • Find the indegree and outdegree for each of the nodes

14. Graph Representations

15. 1 2 3 4 5 6 7 1 x x 2 x x 3 x 4 x x x 1 2 5 x x 3 6 4 7 5 1 2 6 3 4 7 4 5 3 4 5 6 3 6 7 4 7 6 7 Representing graphs • Adjacency matrix • Adjacency lists

16. Implementing Adjacency List figure 14.4

17. Graph Representations • Draw the adjacency matrix and list representations of the following digraph (unweighted).

18. 1 2 3 4 5 6 7 1 x x 2 x x 3 x 4 x x x 1 2 5 x x 3 6 4 7 5 6 3 4 7 4 5 6 3 6 7 4 7 Space Complexity • Memory Requirements for • Adjacency List – O(|V|+|E|) • Adjacency Matrix – O(|V|2) • We can reduce the memory requirements by using “packed” arrays

19. Time Complexity • Query: Does (u,v) Є E ? • Time complexity depends on graph representation • Adjacency list – O(|V|+|E|) • Adjacency matrix – O(1)

20. More on Time Complexity

21. Reversing a Graph • Suppose Gr = <V, Er> where (u,v) in E if and only if (v,u) is in Er • Example: Let G = {(1,2), (2,3), (3,1)}, then Gr = { } • Give an algorithm to compute Gr • If G is represented as adjacency matrix • If G is represented as adjacency list • What is the complexity of your algorithm in each case?

22. Trees are graphs • A dag is a directed acyclic graph • A forest is a dag in which every node has indegree at most 1. • A tree is a forest with exactly one root.

23. Detecting Cycles BOS DTW SFO PIT JFK LAX How do you detect a cycle in a graph?

24. Reachability

25. Reachability • Given a node u in V, find all the nodes v in V that are reachable from u. That is, find the set • R(u) = {v|There is a path from u to v} • How do we compute R(u)? • u is in R(u) – trivial or base case • If v is in R(u) and (v,z) in E, then z is in R(u) • So we can inductively find the set R(u)

26. Reachability Algorithms • There are two algorithms • Depth First Search (DFS) • Explore the nodes by going deeper and deeper into the graph. Use back tracking to try different paths (uses a stack) • Breadth First Search (BFS) • Explore the nodes in an orderly manner. Look at the nodes that are closest to source. Then look at their neighbors, etc.. (uses a queue)

27. DFS Algorithm • Let R be the set of vertices reachable from starting node x, let S be a stack DFS(vertex x) S.push(x); put x into R while (S is not empty) u = S.pop(); for all (u,y) in E { if y is not in R put y into R S.push(y) } } // end while

28. Recursively DFS(vertex x) { put x into R; for all (x,y) in E do if (y is not in R) DFS(y); }

29. Example - DFS

30. Finding Cycles in a Graph

31. When does a graph has a cycle? • If every node in a graph has out-degree at least 1, then the graph has a cycle. • Proof: (informally) Start from any node and walk through the graph • Since you can go out from any node, you can touch all the nodes and eventually you will run into a node that you have already visited. • So that is a cycle. • We can make similar statement about in-degree

32. Finding a Cycle • We can do DFS to traverse the graph • We can use colors to keep track of • Nodes that are not visited • Nodes we are visiting now • Nodes that are already visited

33. Example DFS(1)  DFS(2) DFS(7)DFS(3)DFS(4)DFS(5) If DFS runs into a node still visiting, then we have a cycle

34. Breadth First Search (BFS) BFS (node x){ Q.enque(x) ; // assume Q is a Queue put x into R; // R is the set of vertices visited in BFS while (Q is not empty) u = Q.deque(); for all neighbors v of u if v is not in R put v into R Q.enque(v);

35. Homework • Perform BFS starting from 1. Show the state of the queue and nodes visited at each stage.

36. Minimum Spanning Trees

37. Problem: Laying Telephone Wire Central office

38. Wiring: Naïve Approach Central office Expensive!

39. Wiring: Better Approach Central office Minimize the total length of wire connecting the customers

40. Minimum Spanning Tree (MST) (see Weiss, Section 24.2.2) A minimum spanning tree is a subgraph of an undirected weighted graph G, such that • it is a tree (i.e., it is acyclic) • it covers all the vertices V • contains |V| - 1 edges • the total cost associated with tree edges is the minimum among all possible spanning trees • not necessarily unique

41. 9 b 9 b a 6 2 a 6 2 d d 4 5 4 5 5 4 5 4 e 5 e 5 c c How Can We Generate a MST?

42. 9 b a 6 2 d 4 5 5 4 e 5 c e a b c d 0     Prim’s Algorithm Initialization a. Pick a vertex r to be the root b. Set D(r) = 0, parent(r) = null c. For all vertices v  V,v  r, set D(v) =  d. Insert all vertices into priority queue P, using distances as the keys Vertex Parent e -

43. Prim’s Algorithm While P is not empty: 1. Select the next vertex u to add to the tree u = P.deleteMin() 2. Update the weight of each vertex w adjacent to u which is not in the tree (i.e., w  P) If weight(u,w)< D(w), a. parent(w) = u b. D(w) = weight(u,w) c. Update the priority queue to reflect new distance for w

44. d b c a 4 5 5  Prim’s algorithm Vertex Parent e - b e c e d e 9 b a 6 2 d 4 5 5 4 e 5 c The MST initially consists of the vertex e, and we update the distances and parent for its adjacent vertices

45. Prim’s algorithm Vertex Parent e - b e c d d e a d 9 b a 6 2 d 4 5 5 4 e 5 c The final minimum spanning tree

46. Prim’s Algorithm Invariant • At each step, we add the edge (u,v) s.t. the weight of (u,v) is minimum among all edges where u is in the tree and v is not in the tree • Each step maintains a minimum spanning tree of the vertices that have been included thus far • When all vertices have been included, we have a MST for the graph!

47. Initialization of priority queue (array): O(|V|) • Update loop: |V| calls • Choosing vertex with minimum cost edge: O(|V|) • Updating distance values of unconnected vertices: each edge is considered only once during entire execution, for a total of O(|E|) updates • Overall cost without heaps: • What is the run time complexity if heaps are used? O(|E| + |V|2)) Running time of Prim’s algorithm(without heaps)

48. Correctness • Lemma: Let G be a connected weighted graph and T be a MST. Let G’ be a subgraph of T. Let C be a component of G’ .Let S be the set of all edges with one vertex in C and other not in C. If we add a minimum edge weight in S to G’, then the resulting graph is contained in a minimal spanning tree of G

49. Correctness • Theorem: Prim’s algorithm correctly finds a minimal spanning tree • Proof: by induction show that tree constructed at each iteration is contained in a MST. Then at the termination, the tree constructed is a MST • Base case: tree has no edges, and therefore contained in every spanning tree • Inductive case: Let T be the current tree constructed using Prim’s algorithm. By inductive argument, T is contained in some MST. • Let (u,v) be the next edge selected by Prim’s, such that u in T and v not in T. Let G’ be T together with all vertices not in T. Then T is a component of G’ and (u,v) is a minimum weight edge with one vertex in T and one not in T. Then by lemma, when (u,v) is added to G’ , the resulting graph is also contained in a MST.

50. Web Search Engines A Cool Application of Graphs