Lecture 14: Graph Representation, DFS and Applications

Size: px

Start display at page:

Download "Lecture 14: Graph Representation, DFS and Applications"

Candice Coleen Skinner
5 years ago
Views:

1 Lecture 14: Graph Representation, FS and pplications SFO OR LX FW ourtesy to Goodrich, Tamassia and Olga Veksler Instructor: Yuzhen Xie

2 Outline Graph Representation dge List djacency List djacency Matrix Graph Traversals epth First Search (FS) pplications of FS 2

3 Graph Representation: dge List Structure Vertex objects stored in unsorted sequence Space O(n) dge Objects stored in unsorted sequence Space O(m) ( ) ach edge object has reference to origin and destination vertex object u v w z v u w z (u,v) (vw) (v,w) (u,w) (w,z) Total space: O(n + m) 3

4 Graph Representation: dge List Structure, Real picture a u c ach vertex object has a back b d pointer reference to the node v w z which references it in the linked list of vertices ( these references are in thick red in the example below ) ach dge 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 4

5 Graph Representation: dge List Structure v u w z (u,v) (v,w) (u,w) (w,z) dvantages: easy to implement Operation Time isadvantages: vertices O(n) inefficient edges O(m) ) incidentdges, aredjacent, endvertices(e), opposite(v,e) O(1) removevertex, incidentdges(v), aredjacent(v,w) O(m) ( ) take O(m), since replace(v,o), replace(e,o), insertvertex(o) O(1) we have to examine the insertdge(u,v),removedge(e) O(1) entire edge removevertex(v) O(m) sequence

6 How to Improve dge List Structure? v w z u v u 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 ach vertex can have lots of edges incident on it Thus we need a sequence of incident vertices Thus we need a sequence of incident vertices this sequence is called djacency List, because it s usually implemented as a list

7 Graph Representation: djacency List u v w z (u,v) (v,w) (u,v) (u,w) (u,w) (v,w) (w,z) (w,z) v u w z (u,v) (v,w) (u,w) (w,z) 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 dge List graph representation Solution: back link each edge (u,v) in the dge Sequence to where it is referenced in the adjacency list of u and v

8 Graph Representation: djacency List Structure u v w z (u,v) (v,w) (u,v) (u,w) (u,w) (v,w) (w,z) (w,z) v u w z (u,v) (v,w) (u,w) (w,z) 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 adjacency lists, 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

9 djacency List Structure (u,v) (v,w) (u,v) (u,w) (u,w) (v,w) (w,z) v u w z (w,z) (u,v) (v,w) (u,w) (w,z) Operation Time vertices O(n) edges O(m) ) endvertices, opposite O(1) incidentdges(v) O(deg(v)) aredjacent(v,w ) O(min(deg(v),deg(w)) replace O(1) insertvertex,insertdgeinsertdge O(1) removedge(v,w ) O(1) removevertex O((deg(v)) 9 dvantages: More efficient than edge list isadvantages: g More complicated to implement

10 Graph Representation: Traditional djacency 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 t there is an edge between v and w M[v,w] = false means that there is no edge between een v and w Space requirement: O(n 2 ) Therefore adjacency matrix should be used only for dense graphs graph is dense if m is O(n 2 ), that is it has a lot of edges If m is O(n), then graph is said to be sparse u v w z v u w z v u w z false true true true false false true false true true false true false false true false 10

11 Graph Representation: djacency Matrix Structure dge list structure Integer key (index) associated with vertex v u w z (u,v) (v,w) (u,w) (w,z) 2 adjacency array Reference to edge object for adjacent vertices Null for non-adjacent vertices Space requirement: O(n 2 ) v u w z v u w z 11

12 Graph Representation: djacency Matrix Structure v u w z (u,v) (v,w) (u,w) (w,z) Operation Time vertices O(n) edges O(m) endvertices(e), opposite(e,v) O(1) incidentdges(v) O(n) replace, aredjacent(v,w) O(1) insertdge(v,w), removedge(e) O(1) insertvertex(v), removevertex(v) O(n 2 ) v u w z v u w z 12

13 symptotic Performance n vertices, m edges no parallel edges no self-loops ounds are big-oh dge List djacency List djacency Matrix Space n + m n + m n 2 incidentdges(v) m deg(v) n aredjacent (v, w) m min(deg(v), deg(w)) 1 insertvertex(o) 1 1 n 2 insertdge(v, w, o) removevertex(v) m deg(v) n 2 removedge(e)

14 Summary of Graph ata Structures dge 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 djacency list Good performance for any graph Most complicated to implement 2 adjacency array, to be used when: Good choice only for dense graphs (m is O(n 2 ), that is it has a lot of edges) nd 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

15 Traversing a Graph v u w z (u,v) (v,w) (u,w) (w,z) 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? ould 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 lgorithm : Start at a vertex, and visit adjacent vertices However, we have a choice to make when visiting adjacent vertices 1. Go for breadth xplore all edges from the 3: go for breadth current vertex before going to u the next vertex 2. Go for depth Move to the next vertex from v w z the current vertex before finishing exploring current vertex (go deep in the graph) go for depth

16 epth First Search Systematic graph traversal go as deep into the graph as possible an start FS at any vertex v FS(v) Mark all vertices unvisited So that we don t get stuck in a cycle We maintain urrentvertex the vertex we are currently at In the beginning, urrentvertex = v Move away from urrentvertex to an adjacent unvisited vertex Mark urrentvertex as visited urrentvertex = unvisited adjacent vertex of urrentvertex curvertex curvertex

17 epth First Search curvertex curvertex curvertex now we are stuck in a dead end. No more unvisited adjacent vertices from urrentvertex Retrace to the previous vertex Vertex that was urrentvertex previously curvertex

18 epth First Search ontinue switching urrentvertex to the next adjacent unvisited vertex When in dead end, retrace to the previous urrentvertex curvertex curvertex curvertex We can keep a container of previous currentvertex to know which vertex to retrace to This data structure t has to be a stack FILO

19 FS: Non Recursive lgorithm FS(G,v) Mark all vertices UNVISIT onstruct a new empty stack urrentvertex = v while ( urrentvertex t is not null ) Mark urrentvertex VISIT if urrentvertex has adjacent UNVISIT vertex w stack.push(urrentvertex) urrentvertex = w else // ead end, retrace if stack is not empty urrentvertex = stack.pop() else urrentvertex = null

20 xample: FS() curvertex S={ } S={, } curvertex curvertex S={ { } S={,, } curvertex

21 xample ontinued: FS() S={,, } S={,, } curvertex curvertex S={, } S={, } curvertex curvertex

22 xample ontinued: FS() S={, } curvertex S={} curvertex curvertex S={ { } one! stack is empty curvertex VISIT

23 FS: Recursive lgorithm lgorithm FS(G) lgorithm FS(G, v) Input: graph G Input: graph G and a start vertex v of G for all u G.vertices() setlabel(v, VISIT) setlabel(u, UNVISIT) Print(v); //get first vertex in vertex sequence for all e G.incidentdges(v) v = G.vertices().next() w opposite(v,e) ( ) FS(G, v) if getlabel(w) = UNVISIT FS(G, w) 2 done3 done5 done done4 done1 4 Notice that after FS, 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 FS

24 erivation of FS lgorithm FS(G) Input: graph G for all e G.edges() setlabel(e, UNXPLOR) for all u G.vertices() setlabel(u, UNVISIT) //get first vertex in vertex sequence v = G.vertices().next() FS(G, ( v) ) FS code with labeling of edges into discovery and back edges lgorithm FS(G, v) Input: graph G and a start vertex v of G Output: t: labeling of the edges of G as discovery edges and back edges setlabel(v, VISIT) Print(v); ( ) for all e G.incidentdges(v) w opposite(v,e) if getlabel(w) = UNVISIT setlabel(e, ISOVRY) FS(G, w) else if getlabel(e) = UNXPLOR setlabel(e, K)

25 xample unvisited vertex visited vertex unexplored edge discovery edge back edge 25

26 xample (cont d) 26

27 erivation of FS (cont d) Our current version has only one problem now: it works only for connected graphs lgorithm FS(G) for all e G.edges() setlabel(e, UNXPLOR) for all u G.vertices() setlabel(u, UNVISIT) //get first vertex in vertex sequence v = G.vertices().next() FS(G, v) F G H lgorithm FS(G, v) Input : graph G and a start vertex v of G Output : labeling the edges of G as discovery edges and back edges setlabel(v, VISIT) Print(v); for all e G.incidentdges(v) ( ) w opposite(v,e) if getlabel(w) = UNVISIT setlabel(e, ISOVRY) FS(G, w) else if getlabel(e) = UNXPLOR setlabel(e, K)

28 Final lgorithm for FS To fix, so that t it works on any graph which h is simple Keep calling FS(G, v) from FS(G) for any unvisited v lgorithm FS(G) lgorithm FS(G, v) ) for all e G.edges() Input: graph G and a start vertex v of G setlabel(e, UNXPLOR) Output: labeling the edges of G for all u G.vertices() in the connected component of v setlabel(u, UNVISIT) as discovery edges and back edges for all v G.vertices() setlabel(v, VISIT) if getlabel(v) ( ) = UNVISIT for all e G.incidentdges(v) FS(G, v) w opposite(v,e) ( ) if getlabel(w) = UNVISIT setlabel(e, ISOVRY) FS(G, w) F H else if getlabel(e) = UNXPLOR setlabel(e, K) G no change in FS(G, v) code

29 Properties of FS Property 1 FS(G, v) visits all the vertices and edges in the connected component of v Property 2 The discovery edges labeled by FS(G, v) form a spanning tree of the connected component of v 29

30 nalysis of FS ssume adjacency list structure ssume setting/getting a vertex/edge label takes O(1) time FS(G) goes over all graph vertices 2 times and over all edges 1 time takes O(m+n) ( ) time, do not account time spend in FS(G,v). count time spend in FS(G,v) separately FS(Gv) FS(G,v) called 1 time for each vertex one call to FS(G,v) takes 1+deg(v) time all calls to FS(G,v) take time Σ v [1+deg(v)] = Σ v 1+Σ v deg(v) = n+2m FS runs in O(n + m) time (if the graph is represented by the adjacency list structure) lgorithm FS(G) for all e G.edges() setlabel(e, UNXPLOR) for all u G.vertices() setlabel(u, UNVISIT) for all v G.vertices() if getlabel(v) = UNVISIT FS(G, v) lgorithm FS(G, v) setlabel(v, VISIT) for all e G.incidentdges(v) w opposite(v,e) if getlabel(w) = UNVISIT setlabel(e, ISOVRY) FS(G, w) else if getlabel(e) = UNXPLOR setlabel(e, bl( K) )

31 Path Finding we call vertex v active if v is marked VISIT but call to FS(G,v) hasn t terminated yet ctive vertices form a single path In the non-recursive FS version, active vertices are in the stack lgorithm FS(G, v) setlabel(v, VISIT) for all e G.incidentdges(v) w opposite(v,e) if getlabel(w) = UNVISIT setlabel(e, ISOVRY) FS(G, w) ) else if getlabel(e) = UNXPLOR setlabel(e, K) active active done not visited active 31 If we keep track of this path, we can find a path between any 2 vertices, provided there is path between them

32 Path Finding We can specialize the FS algorithm to find a path between two given vertices u and z We call FS(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 pathfs is called s soon as destination vertex z is encountered, we return the path as the contents of the stack lgorithm pathfs(g, v, z) setlabel(v, VISIT) S.push(v) if v = z then // found path, return it return Selements() S.elements() for all e G.incidentdges(v) w opposite(v,e) if getlabel(w) ( ) = UNXPLOR result = pathfs(g, w, z) if!(result = null)then return result S.pop(v) return null //did not find path yet 32

33 Path Finding lgorithm pathfs(g, v, z) setlabel(v, VISIT) S.push(v) if v = z then // found path, return it return S.elements() for all e G.incidentdges(v) w opposite(v,e) ( ) if getlabel(w) = UNXPLOR result = pathfs(g, w, z) if!(result = null) ) then return result S.pop(v) return null //did not find path yet S = xample: path between and S =, 33

34 Path Finding lgorithm pathfs(g, v, z) S =, g p (,, ) setlabel(v, VISIT) S.push(v) if v = z then // found path, return it return Selements() S.elements() for all e G.incidentdges(v) w opposite(v,e) if getlabel(w) ( ) = UNXPLOR result = pathfs(g, w, z) if!(result = null)then return result S.pop(v) return null //did not find path yet S =,, 34 S =,,,

35 Path Finding lgorithm pathfs(g, v, z) S =,,, setlabel(v, VISIT) S.push(v) if v = z then // found path, return it return S.elements() for all e G.incidentdges(v) w opposite(v,e) if getlabel(w) = UNXPLOR result = pathfs(g, w, z) if!(result = null)then return result S.pop(v) return null //did not find path yet S =,, 35 S =,,,

36 ycle Finding lgorithm cyclefs(g, v) can specialize FS algorithm to find a simple cycle Mark all edges and vertices as UNXPLOR before call to cyclefs(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 e cyclefs lfsis called s 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: cyclefs(g,v) will only find a cycle in the connected component of v setlabel(v, VISIT) S.push(v) for all e G.incidentdges(v) w opposite(v,e) if getlabel(w) =UNXPLOR setlabel(e, ISOVRY) result = cyclefs(g, w) if!(result = null) then return result else if getlabel(e) = UNXPLOR // found cycle! setlabel(e, K) 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

37 ycle Finding S =,, S = S =,,, S =, w =

38 ycle Finding S =,,, S =,,, w = T = S =,, T =, S =, T =,, S = T =,,, cycle lgorithm cyclefs(g, v) setlabel(v, VISIT) S.push(v) for all e G.incidentdges(v) w opposite(v,e) if getlabel(w) =UNXPLOR setlabel(e, bl( ISOVRY) ) result = cyclefs(g, w) if!(result = null) then return result else if getlabel(e) = UNXPLOR // found cycle! setlabel(e, K) 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

39 epth-first Search Summary epth-first search (FS) is a general technique for traversing a graph FS traversal of a graph G Visits all the vertices and edges of G etermines whether G is connected omputes the connected components of G omputes a spanning forest of G 39 FS on a graph with n vertices and m edges takes O(n + m ) time with adjacency list implementation FS can be further extended to solve other graph problems Find and report a path between two given vertices Find a cycle in the graph epth-first search is to graphs what uler tour is to binary trees

Depth-First Search A B D E C

Depth-First Search A B D E C epth-first Search Outline and Reading efinitions (6.1) Subgraph onnectivity Spanning trees and forests epth-first search (6.3.1) lgorithm xample Properties nalysis pplications of FS (6.5) Path finding