1 / 60

Graphs

Graphs. 15-211 Fundamental Data Structures and Algorithms. Ananda Gunawardena April 4, 2006. In this lecture. concept Representations Adjacency matrix Adjacency List Graph Traversals BFS, DFS Minimum Spanning Trees Search Engines. Introduction to Graphs.

Download Presentation

Graphs

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. 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

More Related