Graphs

1. B F G A C D E Graphs • Graph G(V,E): finite set V of nodes (vertices) plus a finite set E of arcs (or edges) between nodes • V = {A, B, C, D, E, F, G} • E = {AA, AB, AD, CD, DE, BF, EF, FG, EG } Graphs

2. Terminology • Two vertices are adjacent if they are connected with an edge • Adjacent or neighbor vertices • Subgraph of G=(V,E): a graph G’=(V’,E’) where V’, E’ are subsets of V, E • |V|,|E|: number of nodes, edges of G • Complete graph: contains all possible edges • |E| in Θ(|V|2) Graphs

3. B C A G E D H F Undirected Graphs • The edges are not directed from one vertex to another Graphs

4. B C A G E D H F Directed Graphs • The edges are directed from one vertex to another Graphs

5. A A B C B C D D E F G Graphs

6. More Definitions • Vertex degree: maximum number of incoming or outgoing edges • in-degree: number of incoming edges • out-degree: number outgoing edges • RelationRonA: R = {<x, y>| x, y ∊ N} • x < y • x mod y = odd • Labeled graph: labels on vertices or edges • Weighted graph: weights on edges Graphs

7. 1 relation weighted 3 10 3 10 7 3 1 5 8 5 8 17 17 1 5 6 6 Graphs

8. Paths • There exist edges connecting two nodes • Length of path: number of edges • Weighted graphs: sum of weights on path • Cycle: path (of length 3 or more) connecting a vertex with itself • Cyclic graph: contains cycle • Acyclic graph: does not contain cycle • DAG:Directed Acyclic Graph Graphs

9. 7 2 6 0 4 3 5 1 Connected Graphs • An undirected graph is connected if there is a path between any two vertices • Connected components: maximally connected subgraphs Graphs

10. a b a b a b a b a b a b a b c Operations on Graphs • join (a,b) • join (a,b,x) • remv[wt] (a,b,x) • adjacent (a,b) x adjacent (a,b) = true adjacent (a,c) = false Graphs

11. Build a Graph read(n); // number of nodes read and create n nodes label them from 1 .. n while not eof(..) { read(node1, node2, w12); joinwt(node1, node2, w12); } any graph algorithm Graphs

12. directed graph 0 1 2 3 4 0 2 0 1 1 1 1 4 2 1 1 3 3 1 4 1 adjacency matrix 0 1 4 1 3 2 4 3 adjacency list 2 4 1 Representation of Directed Graphs Graphs

13. undirected graph 0 1 2 3 4 0 1 1 0 2 1 1 1 1 2 1 1 4 3 1 1 1 4 1 1 1 3 0 1 4 1 0 3 4 2 3 4 3 1 2 adjacency list 4 0 1 2 Representation of Undirected Graphs adjacency matrix Graphs

14. Matrix Implementation • Simple but difficult to process edges, unused space in matrix • mark: 1D array marking vertices • mark[i] = 1 if vertex i has been visited • typedef int *Edge; • matrix: the actual Graph implemented as an 1D array of size n2 • edge (i, j) is found at matrix[i*n + j] • if edge exists matrix[i*n + j] = wt • otherwise matrix[i*n + j] = NOEDGE Graphs

15. Graph class: Adjacency Matrix template <class Edge> class Graph { private: Edge* matrix; // the edge matrix int numVertex, numEdge; // number of vertices, edges bool* Mark; // the mark array public: Graph( ); ~Graph( ); // constructor, destructor int n( ), e ( ) // number of vertices, edges Edge first(int); // get the first edge for a vertex bool isEdge(Edge); // TRUE if this is an edge Edge next(Edge); // get next edge for a vertex int v1(Edge), v2(Edge) // vertex edge comes from, goes to int weight(int, int); // return weight of edge int weight(Edge); // return weight of edge }; Graphs

16. Constructor, Destructor template <class Edge> Graph<Edge>::Graph( ) { mark = NULL; matrix = NULL; } template <class Edge> Graph<Edge>::~Graph( ) { if (mark != NULL) delete [ ] mark; if (matrix != NULL) delete [ ] matrix; } Graphs

17. Member Functions template <class Edge> int Graph<Edge>::n( ) { return numVertex; } template <class Edge> int Graph<Edge>::e( ) { return numEdge; } Graphs

18. Member Functions (cont.) template <class Edge> Edge Graph<Edge>::first(int v) { //first edge of node int stop = (v+1) *numVertex; // pos. at end of v’s row for ( int pos = v * numVertex; pos < stop; pos++) //scans entire row if ( matrix[pos] != NOEDGE) return &matrix[pos]; return NULL; } Graphs

19. Member Functions (cont.) template <class Edge> bool Graph<Edge>::isEdge(Edge w) { return w != NULL; } template <class Edge> Edge Graph<Edge>::next(Edge w) { // next edge of (w,0) int stop = (v1(w) + 1) * numVertex; // pos at end of row for (int pos = (w – matrix) + 1; pos < stop; pos++) if (matrix[pos] != NOEDGE) return &matrix[pos]; return NULL; } Graphs

20. Member Functions (cont.) template <class Edge> int Graph<Edge>::v1(Edge w) // 1st vertex of edge { return ( w – matrix ) / numVertex; } template <class Edge> int Graph<Edge>::v2(Edge w) // 2nd vertex edge { return ( w – matrix ) % numVertex; } Graphs

21. Member Functions (cont.) template <class Edge> int Graph<Edge>::weight( int i, int j) { // return weight of edge if ( matrix[ i * numVertex + j ] == NOEDGE ) return INFINITY; else return matrix[ i * numVertex + j ]; } template <class Edge> int Graph<Edge>::weight(Edge w) { // return weight of edge if ( *w == NOEDGE ) return INFINITY; else return *w; } Graphs

22. Graph Class: Adjacency List template <class Edge> class Graph { private: Edge *list; // the vertex list int numVertex; // number of vertices int numEdge; // number of edges bool *Mark; // the mark array public: Graph( ); ~Graph( ); // constructor, destructor int n( ), e( ); // number of vertices, edges Edge first(int); // get the first edge of vertex bool isEdge(Edge); // TRUE if this is an edge Edge next(Edge); // get next edge for a vertex int v1(Edge), v2(Edge); // return vertex edge comes from, goes to int v2(Edge); // return vertex edge goes to int weight(int, int), // return weight of edge int weight(weight); // return weight of edge }; Graphs

23. A Singly-Linked List Node • class EdgeLink { public: int weight; // edge weight int v1; // 1st vertex of edge int v2; // 2nd vertex of edge EdgeLink *next; // pointer to next edge in list EdgeLink(int vt1, int vt2, int w, EdgeLink *nxt = NULL) // constructor { v1 = vt; v2 = vt2; weight = w; next = nxt; } }; • Graph<EdgeLink> g; Graphs

24. Member Functions template <class Edge> Graph<Edge>::Graph( ) { // constructor Mark = NULL; list = NULL; } template <class Edge> Graph<Edge>::~Graph( ) { // destructor: return allocated space if (Mark != NULL) delete [ ] Mark; if (list != NULL) { // remove all of the edges for (int v = 0; v < n( ); v++) // for each vertex return all edges while (list[v] != NULL) { list[v]= list[v]next; delete temp; } delete [ ] list; // remove the vertex list headers } } Graphs

25. Member Functions (cont.) template <class Edge> int Graph<Edge>::n( ) { return numVertex; } // number of vertices template <class Edge> int Graph<Edge>::e( ) { return numEdge; } // number of edges template <class Edge> Edge Graph<Edge>::first(int v) // get the first edge {return list[v]; } template <class Edge> bool Graph<Edge>::isEdge(Edge w) // TRUE if it is an edge { return w != NULL; } Graphs

26. Member Functions (cont.) template <class Edge> Edge Graph<Edge>::next(Edge w) { // get next edge for a vertex if (w == NULL) return NULL; else return wnext; } template <class Edge> int Graph<Edge>::v1(Edge w) // return vertex edge comes from { return wv1; } template <class Edge> int Graph<Edge>::v2(Edge w) // return vertex edge goes to { return wv2; } Graphs

27. Member Functions (cont.) template <class Edge> int Graph<Edge>::weight( int i, int j) { // return weight of edge for (Edge curr = list[i]; curr != NULL; curr = curr->next) if (currv2 == j ) return curr-> weight; return INFINITY; } template <class Edge> int Graph<Edge>::weight(Edge w) { // return weight of edge if ( w == NULL ) return INFINITY; else return w -> weight; } Graphs

28. ndptr nextarc arcptr info nextnode info: data arcptr: pointer to an adjacent node nextnode: pointer to a graph node ndptr: pointer to adjacent node nextarc: pointer to next edge B A D C E A Better Implementation Graphs

29. graph C D n i l E n i l n i l n i l Β A <D,B> n i l <C,E> n i l <A,B> <A,C> <A,D> <A,E> Graphs

30. Graph Traversal • Trees • preorder • inorder • postorder • Graphs • Depth First Search (DFS) • Breadth First Search (BFS) Graphs

31. Depth First Search (DFS) • Starting from vertex v, initially all vertices are “unvisited” • void DFS(v) { Mark(v) = true; for each vertex w adjacent to v if (!Mark(w)) DFS(w) } Graphs

32. Complexity of DFS • O(|V| + |E|): adjacency list representation • O(|V|2) in dense graphs • O(|V|2):matrix representation Graphs

33. v = v1 7 v3 v2 v1 v6 v5 v4 v8 v7 1 1 7 5 6 8 2 2 5 3 3 4 2 4 6 8 8 8 3 DFS : V1V2V4V8V5V6V3V7 v1 v2 v3 v7 v4 v5 v6 v8 Graphs

34. v = v1 ΒFS : V1V2V3V4V5V6V7V8 v1 v2 v3 v7 v4 v5 v6 v8 Breadth-First Search (BFS) Graphs

35. BFS (cont.) • Starting from vertex v, all nodes “unvisited”, visit adjacent nodes (use a queue) void DFS(v) { visited(v) = true; enqueue(v, Q); while ( Q ≠ 0 ) { x = dequeue(Q); for each y adjacent x do if ! Mark(y) { Mark(y) = TRUE; enqueue(y,Q); } } } Graphs

36. front rear output(v1) v2 v3 v1 v5 v4 v8 v4 v7 v8 v7 v5 v6 v5 v8 v6 v7 v6 v6 v3 v1 front v2 v3 output(v2) rear v7 v4 v5 v6 output(v3) front front v8 front output(v4) rear rear rear front output(v5) output(v6) front output(v7) v = v1 Graphs

37. Complexity of BFS • O(|V|+|E|) : adjacency list representation • d1 + d2 + ...+ dn = |E| • di= degree (vi) • O(|V|2) : adjacency matrix representation Graphs

38. DFS Algorithm template <class Edge> void DFS (Graph<Edge>& G, int v){ action(G,v); G.Mark[v] = VISITED; for ( Edge w = G.first(v); G.isEdge(w); w = G.next(w)) if (G.Mark[G.v2(w)] = = UNVISITED)DFS ( G, G.v2(w)); action(G,v); } Graphs

39. BFS Algorithm template <class Edge> void BFS (Graph<Edge>& G, int start){ Queue Q(G.n( )); Q.enqueue(start); G.Mark[start] = VISITED; While ( !Q.isempty( )) { int v = Q.dequeue( ); action(G,v); for ( Edge w = G.first(v); G.isEdge(w); w = G.next(w)) if (G.Mark[G.v2(w)] = = UNVISITED){ G.Mark[G.v2(w)] = VISITED;Q.enqueue(G.v2(w)); } action(G,v); } Graphs

40. B C A D E F A E B G C D connected components Connected - Unconnected connected graph: undirected graph, there is a path connecting any two nodes unconnected graph: not always a path Graphs

41. Connected Components • If there exist unconnected nodes in a DFS or BFS traversal of G then G is unconnected • Find all connected components: void COMP(G, n) { for i = 1 to n if Mark(i) == UNVISITED then DFS(i) [or BFS(i)]; } • Complexity: O(|V| + |E|) Graphs

42. (G,E) Spanning Trees Tree formed from edges and nodes of G Spanning Tree Graphs

43. Spanning Forest • Set of disjoint spanning trees Tiof G=(V,E) • Ti = ( Vi , Ei ) 1≤ i ≤ k, Vi,Ei:subsets of V, E • DFS producesdepth first spanning trees or forest • BFS breadth first spanning trees or forest • Undirected graphs provide more traversals • produce less but short spanning trees • Directed graphs provide less traversals • produce more and higher spanning trees Graphs

44. DFS spanning tree A A B B C C D E A DFS A D E B F DFS spanning forest DFS B C C E F D D E G G DFS Graphs

45. A ΒFS A B F B C E C F D D E H H BFS A A BFS spanning tree ΒFS B C D B C D E F G E F G BFS spanning forest Graphs

46. 1 Prim’s algorithm: Complexity O(|V|2) 6 5 1 5 5 2 3 4 6 4 2 3 5 6 6 1 1 1 1 1 1 1 1 1 1 5 5 3 3 3 4 2 3 4 2 3 4 4 4 2 4 2 4 2 3 6 6 6 5 6 costT = 1 + 5 + 2 + 4 + 3 Min. Cost Spanning Tree Graphs

47. Prim’s Algorithm template <class Edge> void Prim(Graph<Edge>& G, int s) { / /prim’s MST algorithm int D[G.n( )]; // distance vertex int V[G.n( )]; // who’s closest for (int i=0; i<G.n( ); i++); D[i] = INFINITY; // initialize D[s] = 0; for ( i=0; i<G.n( ); i++) { // process the vertices int v = minVertex(G, D); G.Mark[v] = VISITED; if ( v != s ) AddEdgetoMST(V[v], v); // add this edge to MST if (D[v] = = INFINITY ) return; // unreachable vertices for ( Edge w = G.first(v); G.isEdge(w); w = G.next(w)) if (D[G.v2(w)] > G.weight(w)) { D[G.v2(w)] = G.weight(w); // update distance and V[G.v2(w)] = v; // who it came from } } } Graphs

48. Prim’s Algorithm (cont.) template <class Edge> ){ // find min cost vertex void minVertex(Graph<Edge>& G, int* D int v; for (int i = 0; i < G.n( ); i++) // initialize if (G.Mark[i] = = UNVISITED) { v = i; break; } for ( i=0; i<G.n( ); i++) // find smallest value if ((G.Mark[i] = = UNVISITED) && ( D[i] < D[v] )) v = i; return v; } Graphs

49. Dijkstra’s Algorithm • Find the shortest path from a given node to every other node in a graph G • no better algorithm for single ending node • Notation: • G = (V,E) : input graph • C[i,j] : distance between nodes i, j • V : starting node • S : set of nodes for which the shortest path from v has been computed • D(W) : length of shortest path from v to w passing through nodes in S Graphs

50. starting point: v = 1 1 10 100 30 2 5 10 60 50 4 3 20 Graphs