 Download Presentation Elementary Graph Algorithms

# Elementary Graph Algorithms - PowerPoint PPT Presentation Download Presentation ## Elementary Graph Algorithms

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
##### Presentation Transcript

1. Graph Terminology • A graph G = (V, E) • V = set of vertices • E = set of edges • In an undirected graph: • edge(u, v) = edge(v, u) • In a directed graph: • edge(u,v) goes from vertex u to vertex v, notated u  v • edge(u, v) is not the same as edge(v, u)

2. Graph Terminology A A B B C C D D Directed graph: V = {A, B, C, D} E = {(A,B), (A,C), (A,D), (C,B)} Undirected graph: V = {A, B, C, D} E = {(A,B), (A,C), (A,D), (C,B), (B,A), (C,A), (D,A), (B,C)}

3. Graph Terminology a b d e c a b d e c Vertex a is adjacent to c and vertex cis adjacent to a Vertex c is adjacent to a, but vertex a is NOT adjacent to c • Adjacent vertices: connected by an edge • Vertex v is adjacent to u if and only if (u, v)  E. • In an undirected graph with edge (u, v), and hence (v, u), v is adjacent to u and u is adjacent to v.

4. a b d e c a b d e c Graph Terminology • A Path in a graph from u to v is a sequence of edges between vertices w0, w1, …, wk, such that (wi, wi+1) E, u = w0 and v = wk, for 0 ik • The length of the path is k, the number of edges on the path abedce is a path. cdeb is a path. bca is NOT a path. acde is a path. abec is NOT a path.

5. a b d e c a b d e c Graph Terminology • Loops • If the graph contains an edge (v, v) from a vertex to itself, then the path v, v is sometimes referred to as aloop. • The graphs we will consider will generally be loopless. • A simplepath is a path such that all vertices are distinct, except that the first and last could be the same. abedc is a simple path. cdec is a simple path. abedce is NOT a simple path.

6. Graph Terminology • simple path:no repeated vertices

7. abeda is a simple cycle. abeceda is a cycle, but is NOT a simple cycle. abedc is NOT a cycle. a b d e c a b d e c aba is NOT a cycle. abedceda is NOT a cycle. abedcea is a cycle, but NOT simple. abea is a simple cycle. Graph Terminology • Cycles • Acyclein a directed graph is a path of length at least 2 such that the first vertex on the path is the same as the last one; if the path is simple, then the cycle is asimple cycle. • Acycle in a undirected graph • A path of length at least 3 such that the first vertex on the path is the same as the last one. • The edges on the path are distinct.

8. Graph Terminology • If each edge in the graph carries a value, then the graph is called weighted graph. • A weighted graph is a graph G = (V, E, W), where each edge, e E is assigned a real valued weight, W(e). • A complete graph is a graph with an edge between every pair of vertices. • A graph is called complete graph if every vertex is adjacent to every other vertex.

9. Graph Terminology n = 4 n = 1 n = 2 n = 3 • Complete Undirected Graph • has all possible edges

10. Graph Terminology • connected graph:any two vertices are connected by some path • An undirected graph is connected if, for every pair of vertices u and v there is a path from u to v.

11. Graph Terminology • tree- connected graph without cycles • forest - collection of trees

12. Graph Terminology

13. V a b h j U d X Z c e i W g f Y Graph Terminology • End vertices (or endpoints) of an edge a • U and V are the endpoints of a • Edges incident on a vertex V • a, d, and b are incident on V • Adjacent vertices • U and V are adjacent • Degree of a vertex X • X has degree 5 • Parallel edges • h and i are parallel edges • Self-loop • j is a self-loop

14. Graph Terminology • Path • sequence of alternating vertices and edges • begins with a vertex • ends with a vertex • Simple path • path such that all its vertices and edges are distinct. • Examples • P1 = (V, X, Z) is a simple path. • P2 = (U, W, X, Y, W, V) is a path that is not simple. V b a P1 d U X Z P2 h c e W g f Y

15. Graph Terminology • Cycle • circular sequence of alternating vertices and edges • Simple cycle • cycle such that all its vertices and edges are distinct • Examples • C1 = (V, X, Y, W, U, V) is a simple cycle • C2 = (U, W, X, Y, W, V, U) is a cycle that is not simple V a b d U X Z C2 h e C1 c W g f Y

16. In-Degree of a Vertex 2 3 8 1 10 4 5 9 11 6 7 • in-degree is number of incoming edges • indegree(2) = 1, indegree(8) = 0

17. Out-Degree of a Vertex 2 3 8 1 10 4 5 9 11 6 7 • out-degree is number of outbound edges • outdegree(2) = 1, outdegree(8) = 2

18. Applications: Communication Network 2 3 8 1 10 4 5 9 11 6 7 • vertex = city, edge = communication link

19. Driving Distance/Time Map 2 4 3 8 8 1 6 10 2 4 5 4 4 3 5 9 11 5 6 7 6 7 • vertex = city, • edge weight = distance/time

20. Street Map • Some streets are one way • A bidirectional link represented by 2 directed edge • (5, 9) (9, 5) 2 3 8 1 10 4 5 9 11 6 7

21. Computer Networks • Electronic circuits • Printed circuit board • Computer networks • Local area network • Internet • Web

22. Graphs • We will typically express running times in terms of • |V| = number of vertices, and • |E| = number of edges • 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

24. Adjacency Matrix • Assume V = {1, 2, …, n} • An adjacency matrixrepresents the graph as a n n matrix A: • A[i, j] = 1 if edge(i, j)  E (or weight of edge) = 0 if edge(i, j)  E

25. Adjacency Matrix • Example: 1 a d 2 4 b c 3

26. Adjacency Matrix • Example: 1 a d 2 4 b c 3

27. Adjacency Matrix 1 2 3 4 5 2 1 3 2 1 3 4 4 5 5 • 0/1 nn matrix, where n = # of vertices • A(i, j) = 1 iff (i, j) is an edge 0 1 0 1 0 1 0 0 0 1 0 0 0 0 1 1 0 0 0 1 0 1 1 1 0

28. Adjacency Matrix 1 2 3 4 5 2 1 0 1 0 1 0 3 2 1 0 0 0 1 1 3 0 0 0 0 1 4 4 1 0 0 0 1 5 5 0 1 1 1 0 • Diagonal entries are zero • Adjacency matrix of an undirected graph is symmetric • A(i, j) = A(j, i) for all i and j

29. Adjacency Matrix 1 2 3 4 5 2 1 0 0 0 1 0 3 2 1 0 0 0 1 1 3 0 0 0 0 0 4 4 0 0 0 0 1 5 5 0 1 1 0 0 • Diagonal entries are zero • Adjacency matrix of a digraph need not be symmetric

30. Adjacency Matrix • How much storage does the adjacency matrix require? • Answer: O(|V|2) • What is the minimum amount of storage needed by an adjacency matrix representation of an undirected graph with 4 vertices? • (|V|-1)|V|/2 • Answer: 6 bits • Undirected graph  matrix is symmetric • No self-loops  don’t need diagonal

31. 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 • For this reason the adjacency list is often a more appropriate representation

32. Adjacency List 2 3 1 4 5 • Adjacency list: for each vertex v  V, store a list of vertices adjacent to v. • Adjacency list for vertex i is a linear list of vertices adjacent from vertex i • Each adjacency list is a chain. aList 2 4  1 5  5  5 1 aList 2 4 3 # of chain nodes = 2|E| (undirected graph) # of chain nodes = |E| (digraph)

34. Adjacency List • How much storage is required? • The degree of a vertex v = # incident edges • Directed graphs have in-degree and 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 adjacency lists is  degree(v) = 2|E| • also (V + E) storage • So: Adjacency lists take O(V + E) storage

35. Graph Search Methods • Many graph problems solved using a search method • Path from one vertex to another • Is the graph connected? • etc. • Commonly used search methods: • Breadth-first search • Depth-first search

36. Graph Search Methods 2 3 8 1 4 5 9 10 6 7 11 • A vertex u is reachable from vertex v iff there is a path from v to u. • A search method starts at a given vertex v and visits every vertex that is reachable from v.

37. Breadth-First Search • Visit start vertex (s) and put into a FIFO queue. • Repeatedly remove a vertex from the queue, visit its unvisited adjacent vertices, put newly visited vertices into the queue. • All vertices reachable from the start vertex (s) (including the start vertex) are visited.

38. Breadth-First Search • Again will associate vertex “colors” to guide the algorithm • White vertices have not been discovered • All vertices start out white • Gray 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 gray vertices

39. Breadth-First Search BFS(G, s) { // initialize vertices; 1 for each u  V(G) – {s}{ 2 do color[u] = WHITE 3 d[u] =  // distance from s to u 4 p[u] = NIL // predecessor or parent of u } 5 color[s] = GRAY 6 d[s] = 0 7 p[s] = NIL 8 Q = Empty; 9 Enqueue (Q,s); // Q is a queue; initialize to s 10 while (Q not empty) { 11 u = Dequeue(Q); 12 for each v  adj[u] { 13 if (color[v] == WHITE) 14 color[v] = GRAY; 15 d[v] = d[u] + 1; 16 p[v] = u; 17 Enqueue(Q, v); } 18 color[u] = BLACK; } } What does d[v] represent? What does p[v] represent?

40. Breadth-First Search • Lines 1-4 paint every vertex white, set d[u] to be infinity for each vertex (u), and set p[u] the parent of every vertex to be NIL. • Line 5 paints the source vertex (s) gray. • Line 6 initializes d[s] to 0. • Line 7 sets the parent of the source to be NIL. • Lines 8-9 initialize Q to the queue containing just the vertex (s). • The while loop of lines 10-18 iterates as long as there remain gray vertices, which are discovered vertices that have not yet had their adjacency lists fully examined. • This while loop maintains the test in line 10, the queue Q consists of the set of the gray vertices.

41. Breadth-First Search • Prior to the first iteration in line 10, the only gray vertex, and the only vertex in Q, is the source vertex (s). • Line 11 determines the gray vertex (u) at the head of the queue Q and removes it from Q. • The for loop of lines 12-17 considers each vertex (v) in the adjacency list of (u). • If (v) is white, then it has not yet been discovered, and the algorithm discovers it by executing lines 14-17. • It is first grayed, and its distance d[v] is set to d[u]+1. • Then, u is recorded as its parent. • Finally, it is placed at the tail of the queue Q. • When all the vertices on (u’s) adjacency list have been examined, u is blackened in line 18.

42. Breadth-First Search: Example r s t u         v w x y

43. Breadth-First Search: Example r s t u  0       v w x y Q: s

44. Breadth-First Search: Example r s t u 1 0    1   v w x y Q: w r

45. Breadth-First Search: Example r s t u 1 0 2   1 2  v w x y Q: r t x

46. Breadth-First Search: Example r s t u 1 0 2  2 1 2  v w x y Q: t x v

47. Breadth-First Search: Example r s t u 1 0 2 3 2 1 2  v w x y Q: x v u

48. Breadth-First Search: Example r s t u 1 0 2 3 2 1 2 3 v w x y Q: v u y

49. Breadth-First Search: Example r s t u 1 0 2 3 2 1 2 3 v w x y Q: u y