CS2210 Data Structures and Algorithms Graph Representation: Edge List Structure Vertex objects stored in unsorted sequence Space O(n) u Lecture 15 : Graph Representation, DFS, applications of DFS SFO 337 Edge Objects stored in unsorted sequence 1843 43 17 v w z ORD 802 Space O(m) LAX 1233 Each edge object has reference to origin and destination vertex object Total space: O(n + m) v u w z DFW (u,v) (v,w) (u,w) (w,z) 2004 Goodrich, Tamassia 3 Outline Graph Representation Edge List Adjacency List Adjacency Matrix Graph Representation: Edge List Structure, Real picture u a c b v w d z Graph Traversals Depth First Search (DFS) Applications of DFS Each vertex object has a back pointer reference to the node which references it in the linked list of vertices ( these references are in thick red in the example below ) Each Edge object has a back pointer reference to the node which references it in the linked list of edges (thick green references in the example below) u v w z a b c d 2 4 1 Graph Representation: Edge List Structure v u w z Graph Representation: Adjacency List v (u,v) (v,w) (u,v) (u,w) (u,w) (v,w) (w,z) u w (w,z) z (u,v) (v,w) (u,w) (w,z) Time O(n) O(m) O(1) O(m) O(1) O(1) O(m) Operation vertices edges endVertices(e), opposite(v,e) incidentEdges(v), areAdjacent(v,w) replace(v,o), replace(e,o), insertVertex(o) insertEdge(u,v),removeEdge(e) removeVertex(v) Advantages: easy to implement Disadvantages: inefficient v u w z (u,v) (v,w) (u,w) (w,z) incidentEdges, areAdjacent, removeVertex, take O(m), since we have to examine the entire edge sequence How to remove edge (u,v) efficiently? First remove edge from the edge list, O(1) Then we have to remove pointer to edge (u,v) from the adjacency list of u and the adjacency list of v This will take O((deg(v)+deg(w)), which is not bad, but worse than O(1), complexity of the Edge List graph representation Solution: back link each edge (u,v) in the Edge Sequence to where it is referenced in the adjacency list of u and v How to Improve Edge List Structure? v u Graph Representation: Adjacency List Structure w z v (u,v) (v,w) (u,v) (u,w) (u,w) (v,w) (w,z) u w (w,z) z v u w z v u w z (u,v) (v,w) (u,w) (w,z) (u,v) (v,w) (u,w) (w,z) The problem with edge list structure is that each vertex does not know which edges are incident on it Solution: put pointers (reference) from each vertex to the edge object incident on this vertex Each vertex can have lots of edges incident on it Thus we need a sequence of incident vertices this sequence is called Adjacency List, because it s usually implemented as a list Space requirement: O(n) for the vertex sequence, O(m) for the edge sequence For vertex v, O(deg(v)) for the adjacency list of v. For all <a href="/keyword/adjacency-lists/" >adjacency lists</a> , O( v deg(v) ) = 2m = O(m) by property 1 from the beginning of lecture For the back links O(m) Thus total space is O(n + m) 8 2 Adjacency List Structure (u,v) (v,w) (u,v) (u,w) (u,w) (v,w) (w,z) (w,z) Graph Representation: Adjacency Matrix Structure Edge list structure Integer key (index) associated with vertex 2D adjacency array Reference to edge object for adjacent vertices Null for non nonadjacent vertices v u w z v u w z (u,v) (v,w) (u,w) (w,z) (u,v) (v,w) (u,w) (w,z) Operation vertices edges endVertices, opposite incidentEdges(v) areAdjacent(v,w ) replace insertVertex,insertEdge removeEdge(v,w ) removeVertex Time O(n) O(m) O(1) O(deg(v)) O(min(deg(v),deg(w)) O(1) O(1) O(1) O((deg(v)) Advantages: More efficient than edge list Disadvantages: More complicated to implement v v u w z u w z Space requirement: O(n2) 9 11 Graph Representation: Traditional Adjacency Matrix Structure Integer key (index) associated with vertex, indexes from 0 to n 2 dimensional boolean adjacency array M of size n by n M[v,w] = true means that there is an edge between v and w M[v,w] = false means that there is no edge between v and w Space requirement: O(n2) Therefore adjacency matrix should be used only for dense graphs graph is dense if m is O(n2), that is it has a lot of edges If m is O(n), than graph is said to be sparse u Graph Representation: Adjacency Matrix Structure v w z u w z v (u,v) Operation Time O(n) O(m) O(1) O(n) O(1) O(1) O(n2) (v,w) (u,w) (w,z) v u w z v falsetrue true false u true false true false w true true false true z false false true false vertices edges endVertices(e), opposite(e,v) incidentEdges(v) replace, areAdjacent(v,w) insertEdge(v,w), removeEdge(e) insertVertex(v), removeVertex(v) v v u w z u w z 10 12 3 Asymptotic Performance n vertices, m edges no parallel edges no self-loops Bounds are big-Oh Traversing a Graph v u w z (u,v) (v,w) (u,w) (w,z) Edge List n+m m m 1 1 m 1 Adjacency List n+m deg(v) min(deg(v), deg(w)) 1 1 deg(v) 1 Adjacency Matrix n2 n 1 n2 1 n2 1 13 Space incidentEdges(v) areAdjacent (v, w) insertVertex(o) insertEdge(v, w, o) removeVertex(v) removeEdge(e) The most basic operation on a graph is traversing How do we traverse the graph so that we visit each vertex exactly once and also learn something useful about the graph? Could go through the vertex/edge sequences, but won t learn anything useful, we will just randomly visit vertices/edges To learn anything useful, need to traverse in some natural order for the specific graph Algorithm : Start at a vertex, and visit adjacent vertices However, we have a choice to make when visiting adjacent vertices 1. Go for breadth Explore all edges from the 3: go for breadth current vertex before going to the next vertex u 2. Go for depth Move to the next vertex from the current vertex before finishing exploring current vertex (go deep in the graph) v w z 1 2 3 go for depth A Summary of Graph Data Structures Edge list structure To be used only out of laziness There are no lazy people in this class. Why did we study it? It s a good starting point (as well as part of) for the other data structures Depth First Search Systematic graph traversal go as deep into the graph as possible B C D E Can start DFS at any vertex v DFS(v) Mark all vertices unvisited So that we don t get stuck in a cycle Adjacency list Good performance for any graph Most complicated to implement 2D adjacency array, to be used when: Good choice only for dense graphs (m is O(n2), that is it has a lot of edges) And used only in case when the set of vertices stays fixed (no vertex insertion or deletion) In cases when the above 2 conditions hold, then the adjacency array is the best choice 14 We maintain CurrentVertex the vertex we are currently at In the beginning, CurrentVertex = v Move away from CurrentVertex to an adjacent unvisited vertex Mark CurrentVertex as visited CurrentVertex = unvisited adjacent vertex of CurrentVertex A B C curVertex B curVertex C A D E D E 4 Depth First Search A B curVertex C A curVertex B C D E A B C D E D E B C curVertex A D E DFS: Non Recursive Algorithm DFS(G,v) mark all vertices UNVISITED construct a new empty stack CurrentVertex = v while ( CurrentVertex is not null ) mark CurrentVertex VISITED if CurrentVertex has adjacent UNVISITED vertex w stack.push(CurrentVertex) CurrentVertex = w else // Dead end, retrace if stack is not empty CurrentVertex = stack.pop() else CurrentVertex = null now we are stuck in a dead end . No more unvisited adjacent vertices from CurrentVertex Retrace to the previous vertex Vertex that was CurrentVertex previously curVertex Depth First Search Continue switching CurrentVertex to the next adjacent unvisited vertex When in dead end , retrace to the previous CurrentVertex A B C A B C D E D E B C A D E curVertex B Example: DFS(A) curVertex A D C S={ } B E A S={ B,A } D E C curVertex curVertex A curVertex We can keep a container of previous currentVertex to know which vertex to retrace to This data structure has to be a stack FILO curVertex B C D S={ A } E B A S={ C,B,A } curVertex D E C 5 Example Continued: DFS(A) A B C DFS: Recursive Algorithm Algorithm DFS(G) Input graph G for all u G.vertices() setLabel(u, UNVISITED) //get first vertex in vertex sequence v = G.vertices().next() DFS(G, v) done5 Algorithm DFS(G, v) Input graph G and a start vertex v of G setLabel(v, VISITED) Print(v); for all e G.incidentEdges(v) w opposite(v,e) if getLabel(w) = UNVISITED DFS(G, w) S={ C,B,A } curVertex D E B A S={ C,B,A } D E curVertex C A B C S={ B,A } D E B A S={ B,A } D E A 1 5 done1 E 2 done3 B C done2 D done4 4 curVertex C curVertex 3 Notice that after DFS, all edges are divided in 2 groups: Red (solid) discovery edges. These edges are used for discovering new parts of the graph Green(dashed) back edges. These are not explored It is useful to mark these 2 types of edges when doing DFS Example Continued: DFS(A) A B C curVertex Derivation of DFS Continued Algorithm DFS(G) Input graph G for all e G.edges() setLabel(e, UNVISITED) for all u G.vertices() setLabel(u, UNVISITED) //get first vertex in vertex sequence v = G.vertices().next() DFS(G, v) Algorithm DFS(G, v) Input graph G and a start vertex v of G Output labeling of the edges of G as discovery edges and back edges setLabel(v, VISITED) Print(v); for all e G.incidentEdges(v) w opposite(v,e) if getLabel(w) = UNEXPLORED setLabel(e, DISCOVERY) DFS(G, w) else if getLabel(e) = UNEXPLORED setLabel(e, BACK) S={ B,A } D E curVertex A B C S={} D E A B curVertex C S={ A } D E Done! stack is empty curVertex VISITED DFS code with labeling of edges into discovery and back edges 6 Example A A Derivation of DFS Continued A B C D E unexplored vertex visited vertex unexplored edge discovery edge back edge A B C D E Our current version has only one problem now: it works only for connected graphs Algorithm DFS(G) for all e G.edges() setLabel(e, UNVISITED) for all u G.vertices() setLabel(u, UNVISITED) //get first vertex in vertex sequence v = G.vertices().next() DFS(G, v) Algorithm DFS(G, v) Input graph G and a start vertex v of G Output labeling of the edges of G as discovery edges and back edges setLabel(v, VISITED) Print(v); for all e G.incidentEdges(v) w opposite(v,e) if getLabel(w) = UNEXPLORED setLabel(e, DISCOVERY) DFS(G, w) H else if getLabel(e) = UNEXPLORED setLabel(e, BACK) A B C 25 D E B A D C E F G Example (cont.) A B C D E B C A D E Final Algorithm for DFS The fix so that it works on any graph is simple Keep calling DFS(G) from DFS(G,v) for any unexplored v Algorithm DFS(G) for all e G.edges() setLabel(e, UNVISITED) for all u G.vertices() setLabel(u, UNEXPLORED) for all v G.vertices() if getLabel(v) = UNEXPLORED DFS(G, v) A Algorithm DFS(G, v) Input graph G and a start vertex v of G Output labeling of the edges of G in the connected component of v as discovery edges and back edges setLabel(v, VISITED) for all e G.incidentEdges(v) w opposite(v,e) if getLabel(w) = UNEXPLORED setLabel(e, DISCOVERY) DFS(G, w) else if getLabel(e) = UNEXPLORED setLabel(e, BACK) A B C D E B A D C 26 E B C D E F G H no change in DFS(G, v) code 7 Properties of DFS Property 1 DFS(G, v) visits all the vertices and edges in the connected component of v A Path Finding we call vertex v active if v is marked VISITED but call to DFS(G,v) hasn t terminated yet Active vertices form a single path D E In the non-recursive DFS version, active vertices are in the stack active C active B A done D not visited E Algorithm DFS(G, v) setLabel(v, VISITED) for all e G.incidentEdges(v) w opposite(v,e) if getLabel(w) = UNEXPLORED setLabel(e, DISCOVERY) DFS(G, w) else if getLabel(e) = UNEXPLORED setLabel(e, BACK) Property 2 The discovery edges labeled by DFS(G, v) form a spanning tree of the connected component of v B active 29 C If we keep track of this path, we can find a path between any 2 vertices, provided there is path between them 31 Analysis of DFS Assume adjacency list structure Assume setting/getting a vertex/edge label takes O(1) time DFS(G) goes over all graph vertices 2 times and over all edges 1 time takes O(m+n) time, not accounting for time spend in DFS(G,v), we will count time spend in DFS(G,v) separately Algorithm DFS(G) for all e G.edges() setLabel(e, UNVISITED) for all u G.vertices() setLabel(u, UNEXPLORED) for all v G.vertices() if getLabel(v) = UNEXPLORED DFS(G, v) Algorithm DFS(G, v) setLabel(v, VISITED) for all e G.incidentEdges(v) w opposite(v,e) if getLabel(w) = UNEXPLORED setLabel(e, DISCOVERY) DFS(G, w) else if getLabel(e) = UNEXPLORED setLabel(e, BACK) Path Finding We can specialize the DFS algorithm to find a path between two given vertices u and z We call DFS(G, u) with u as the start vertex We use a stack S to keep track of the path between the start vertex u and the current vertex Stack holds active vertices Stack S is an instance variable initialized to empty before pathDFS is called DFS(G,v) called 1 time for each vertex one call to DFS(G,v) takes 1+deg(v) time all calls to DFS(G,v) take time v [1+deg(v)] = v 1+ v deg(v) = n+2m DFS runs in O(n + m) time (if the graph is represented by the adjacency list structure) As soon as destination vertex z is encountered, we return the path as the contents of the stack Algorithm pathDFS(G, v, z) setLabel(v, VISITED) S.push(v) if v = z then // found path, return it return S.elements() for all e G.incidentEdges(v) w opposite(v,e) if getLabel(w) = UNEXPLORED result = pathDFS(G, w, z) if !(result = null) then return result S.pop(v) return null //did not find path yet 32 8 Path Finding Algorithm pathDFS(G, v, z) setLabel(v, VISITED) S.push(v) if v = z then // found path, return it return S.elements() for all e G.incidentEdges(v) w opposite(v,e) if getLabel(w) = UNEXPLORED result = pathDFS(G, w, z) if !(result = null) then return result S.pop(v) return null //did not find path yet B A D C E Path Finding A B D C E S=A S = D,C,B,A Algorithm pathDFS(G, v, z) setLabel(v, VISITED) S.push(v) if v = z then // found path, return it return S.elements() for all e G.incidentEdges(v) w opposite(v,e) if getLabel(w) = UNEXPLORED result = pathDFS(G, w, z) if !(result = null) then return result S.pop(v) return null //did not find path yet A A B C D E A B C D E Example: path between A and E B C D E S = B,A 33 S = C,B,A S = E,C,B,A 35 Path Finding A B C D E Cycle Finding Algorithm pathDFS(G, v, z) setLabel(v, VISITED) S.push(v) if v = z then // found path, return it return S.elements() for all e G.incidentEdges(v) w opposite(v,e) if getLabel(w) = UNEXPLORED result = pathDFS(G, w, z) if !(result = null) then return result S.pop(v) return null //did not find path yet A can specialize DFS algorithm to find a simple cycle Mark all edges and vertices as UNEXPLORED before call to cycleDFS(G,v) use stack S to keep track of the path between the start vertex and the current vertex Stack holds active vertices Stack S is an instance variable initialized to empty before cycleDFS is called S = B,A A B C D E B D C E As soon as a back edge (v, w) is encountered, we return the cycle as the portion of the stack from the top to vertex w Note: cycleDFS(G,v) will only find a cycle in the connected component of v Algorithm cycleDFS(G, v) setLabel(v, VISITED) S.push(v) for all e G.incidentEdges(v) w opposite(v,e) if getLabel(w) =UNEXPLORED setLabel(e, DISCOVERY) result = cycleDFS(G, w) if !(result = null) then return result else if getLabel(e) = UNEXPLORED // found cycle! setLabel(e, BACK) T new empty stack T.push(w) repeat o S.pop() T.push(o) until o = w return T.elements() S.pop(v) return null S = C,B,A S = D,C,B,A 34 9 Cycle Finding A B B C D E A D C E Depth-First Search Summary S = A,C,E Depth-first search (DFS) is a general technique for traversing a graph A DFS traversal of a graph G Visits all the vertices and edges of G Determines whether G is connected Computes the connected components of G Computes a spanning forest of G S=E A A B B C D E C DFS on a graph with n vertices and m edges takes O(n + m ) time with adjacency list implementation DFS can be further extended to solve other graph problems Find and report a path between two given vertices Find a cycle in the graph S = B,A,C,E D E S = C,E w =C Depth-first search is to graphs what Euler tour is to binary trees 39 Cycle Finding A B C S = B,A,C,E D E w =C S= S= S= S= B,A,C,E T = C A,C,E T = B,C C,E T = A,B,C E T = C,A,B,C cycle Algorithm cycleDFS(G, v) setLabel(v, VISITED) S.push(v) for all e G.incidentEdges(v) w opposite(v,e) if getLabel(w) =UNEXPLORED setLabel(e, DISCOVERY) result = cycleDFS(G, w) if !(result = null) then return result else if getLabel(e) = UNEXPLORED // found cycle! setLabel(e, BACK) T new empty stack T.push(w) repeat o S.pop() T.push(o) until o = w return T.elements() S.pop(v) return null 10