CSE 30331 Lectures 18 & 19 – Graphs

1. CSE 30331Lectures 18 & 19 – Graphs • Graphs & Characteristics • Graph Representations • A Representation in C++ (Ford & Topp) • Searching (DFS & BFS) • Connected Components • Graph G and Its Transpose GT • Shortest-Path Example • Dijkstra’s Minimum-Path Algorithm • Minimum Spanning Tree

2. What is a graph? • Formally, a graph G(V,E) is • A set of vertices V • A set of edges E, such that each edge ei,j connects two vertices vi and vj in V • V and E may be empty

3. Graph Categories • A graph is connected if each pair of vertices have a path between them • A complete graph is a connected graph in which each pair of vertices are linked by an edge

4. Example of Digraph • Graphs with ordered edges are called directed graphs or digraphs

5. B A B A C E C D E D Not Strongly or Weakly Connected Strongly Connected (No path E to D or D to E ) (b) (a) Strength of Connectedness (digraphs only) • Strongly connected if there is a path from each • vertex to every other vertex.

6. A B A B E D C C D Not Strongly or Weakly Connected Weakly Connected (No path E to D or D to E ) (No path from D to a vertex) (a) ( c) Strength of Connectedness (digraphs only) • Weakly connected if, for each pair of vertices vi and vj, there is either a path P(vi, vj) or a path P(vi, vj).

7. Representing Graphs • Adjacency Matrix • Edges are represented in a 2-D matrix • Adjacency Set (or Adjacency List) • Each vertex has an associated set or list of edges leaving • Edge List • The entire edge set for the graph is in one list • Mentioned in discrete math (probably)

8. A B E C D Adjacency Matrix • An m x m matrix, called an adjacency matrix, identifies graph edges. • An entry in row i and column j corresponds to the edge e = (vi, vj). Its value is the weight of the edge, or -1 if the edge does not exist.

9. Vertices Set of Neighbors A C 1 B 1 (a) A B C 1 B C E B 1 D 1 C D D E B 1 Adjacency Set (or List) • An adjacency set or adjacency list represents the edges in a graph by using … • An m element map or vector of vertices • Where each vertex has a set or list of neighbors • Each neighbor is at the end of an out edge with a given weight

10. 4 B A 2 3 7 C 6 1 2 E 4 D Set of Neighbors Vertices A B 4 C 7 D 6 4 B A 2 A 2 B 3 7 B 3 E 2 C C 6 1 2 D E 4 E 4 D E C 1 Adjacency Matrix and Adjacency Set (side-by-side)

11. Building a graph class • Neighbor • Identifies adjacent vertex and edge weight • VertexInfo • Contains all characteristics of a given vertex, either directly or through links • VertexMap • Contains names of vertices and links to the associated VertexInfo objects

12. vertexInfo Object • A vertexInfo object consists of seven data members. • The first two members, called vtxMapLoc and edges, identify the vertex in the map and its adjacency set.

13. vertexInfo object • vtxMapLoc – iterator to vertex (name) in map • edges – set of vInfo index / edge weight pairs • Each is an OUT edge to an adjacent vertex • vInfo[index] is vertexInfo object for adjacent vertex • inDegree – # of edges coming into this vertex • outDegree is simply edges.size() • occupied – true (this vertex is in the graph), false (this vertex was removed from graph) • color – (white, gray, black) status of vertex during search • dataValue – value computed during search (distance from start, etc) • parent – parent vertex in tree generated by search

14. A Neighbor class (edges to adjacent vertices) class neighbor { public: int dest; // index of destination vertex in vInfo vector int weight; // weight of this edge // constructor neighbor(int d=0, int c=0) : dest(d), weight(c) {} // operators to compare destination vertices friend bool operator<(const neighbor& lhs, const neighbor& rhs) { return lhs.dest < rhs.dest; } friend bool operator==(const neighbor& lhs, const neighbor& rhs) { return lhs.dest == rhs.dest; } };

15. vertexInfo object (items in vInfo vector) template <typename T> class vertexInfo { public: enum vertexColor { WHITE, GRAY, BLACK }; map<T,int>::iterator vtxMapLoc; // to pair<T,int> in map set<neighbor> edges; // edges to adjacent vertices int inDegree; // # of edges coming into vertex bool occupied; // currently used by vertex or not vertexColor color; // vertex status during search int dataValue; // relevant data values during search int parent; // parent in tree built by search // default constructor vertexInfo(): inDegree(0), occupied(true) {} // constructor with iterator pointing to vertex in map vertexInfo(map<T,int>::iterator iter) : vtxMapLoc(iter), inDegree(0), occupied(true) {} };

16. vtxMapLoc edges inDegree occupied color mIter dataValue vertex index (iterator parent location) . . . index vtxMap vInfo A graph using a vertexMap and vertexInfo vector • Graph vertices are stored in a map<T,int>, called vtxMap • Each entry is a <vertex name, vertexInfo index> key, value pair • The initial size of the vertexInfo vector is the number of vertices in the graph • There is a 1-1 correspondence between an entry in the map and a vertexInfo entry in the vector

17. A graph class (just the private members) private: typedef map<T,int> vertexMap; vertexMap vtxMap; // store vertex in a map with its name as the key // and the index of the corresponding vertexInfo // object in the vInfo vector as the value vector<vertexInfo<T> > vInfo; // list of vertexInfo objects for the vertices int numVertices; int numEdges; // current size (vertices and edges) of the graph stack<int> availStack; // availability stack, stores unused vInfo indices

18. A B C D VtxMap and Vinfo Example

19. Find the location for vertexInfo of vertex with name v // uses vtxMap to obtain the index of v in vInfo. // this is a private helper function template <typename T> int graph<T>::getvInfoIndex(const T& v) const { vertexMap::const_iterator iter; int pos; // find the vertex : the map entry with key v iter = vtxMap.find(v); if (iter == vtxMap.end()) pos = -1; // wasn’t in the map else pos = (*iter).second; // the index into vInfo return pos; }

20. Find in and out degree of v // return the number of edges entering v template <typename T> int graph<T>::inDegree(const T& v) const { int pos=getvInfoIndex(v); if (pos != -1) return vInfo[pos].inDegree; else throw graphError("graph inDegree(): v not in the graph"); } // return the number of edges leaving v template <typename T> int graph<T>::outDegree(const T& v) const { int pos=getvInfoIndex(v); if (pos != -1) return vInfo[pos].edges.size(); else throw graphError("graph outDegree(): v not in the graph"); }

21. Insert a vertex into graph template <typename T> void graph<T>::insertVertex(const T& v) { int index; // attempt insertion, set vInfo index to 0 for now pair<vertexMap::iterator, bool> result = vtxMap.insert(vertexMap::value_type(v,0)); if (result.second) { // insertion into map succeeded if (!availStack.empty()) { // there is an available index index = availStack.top(); availStack.pop(); vInfo[index] = vertexInfo<T>(result.first); } else { // vInfo is full, increase its size vInfo.push_back(vertexInfo<T>(result.first)); index = numVertices; } (*result.first).second = index; // set map value to index numVertices++; // update size info } else throw graphError("graph insertVertex(): v in graph"); }

22. Insert an edge into graph // add the edge (v1,v2) with specified weight to the graph template <typename T> void graph<T>::insertEdge(const T& v1, const T& v2, int w) { int pos1=getvInfoIndex(v1), pos2=getvInfoIndex(v2); if (pos1 == -1 || pos2 == -1) throw graphError("graph insertEdge(): v not in the graph"); else if (pos1 == pos2) throw graphError("graph insertEdge(): loops not allowed"); // insert edge (pos2,w) into edge set of vertex pos1 pair<set<neighbor>::iterator, bool> result = vInfo[pos1].edges.insert(neighbor(pos2,w)); if (result.second) // it wasn’t already there { // update counts numEdges++; vInfo[pos2].inDegree++; } }

23. Erase an edge from graph // erase edge (v1,v2) from the graph template <typename T> void graph<T>::eraseEdge(const T& v1, const T& v2) { int pos1=getvInfoIndex(v1), pos2=getvInfoIndex(v2); if (pos1 == -1 || pos2 == -1) throw graphError("graph eraseEdge(): v not in the graph"); // find the edge to pos2 in the list of pos1 neighbors set<neighbor>::iterator setIter; setIter = vInfo[pos1].edges.find(neighbor(pos2)); if (setIter != edgeSet.end()) { // found edge in set, so remove it & update counts vInfo[pos1].edges.erase(setIter); vInfo[pos2].inDegree--; numEdges--; } else throw graphError("graph eraseEdge(): edge not in graph"); }

24. Erase a vertex from graph(algorithm) • Find index of vertex v in vInfo vector • Remove vertex v from map • Set vInfo[index].occupied to false • Push index onto availableStack • For every occupied vertex in vInfo • Scan neighbor set for edge pointing back to v • If edge found, erase it • For each neighbor of v, • decrease its inDegree by 1 • Erase the edge set for vInfo[index]

25. End Lecture 18 Begin Lecture 19

26. Graph traversals & searches • Breadth first search (BFS) • Searches in expanding rings • All vertices one edge away, then all vertices two edges away, etc • Depth first search (DFS) • Searches as deeply as possible until trapped, then backtracks and searches again • Search backtracks when • No more edges exit current vertex • No more of unused out edges from current node go to vertices that have not been already discovered

27. Breadth First Search (traversal) • Uses a queue to order search and a set to store visited vertices • Start with all unvisited (white) vertices • Push start vertex onto Q • While Q is not empty • Remove vertex V from Q • Mark V as visited (black) • Insert V into the visited set • For each adjacent vertex (each neighbor) U • If U is unvisited (white) • Mark it seen (gray) and push it onto Q • Return visited set (vertices reached from start) • Running time – O(V + E)

28. Breadth-First Search Algorithm

29. Breadth-First Search Algorithm (continued)

30. Breadth-First Search Algorithm

31. Depth first search (traversal) • Emulates a postorder traversal, backtracking search • Visits occur while backing out • DfsVisit(V, checkCycles) • If V is unvisited (white) • Mark V as seen (gray) • For each neighbor U of V • If U is unvisited (white) • DfsVisit(U,checkCycles) • Else if U is previously discovered (gray) && checkCycles • Throw exception (found cycle) • Mark V as visited (black) • Push V onto FRONT of dfsList

32. 1/7 A 2/3 5/6 B E 3/2 6/4 7/5 Back edge C F G 4/1 m/n == discovered/visited D dfs() discovery and visiting

33. Strong Components • A strongly connected component of a graph G is a maximal set of vertices SC in G that are mutually accessible.

34. Graph G and Its Transpose GT • The transpose has the same set of vertices V as graph G but a new edge set ET consisting of the edges of G but with the opposite direction.

35. Finding Strong Components • Perform dfs() of graph G, creating dfsGList • Create GT (transform of graph G) • Color all vertices in GT white • For each vertex V in GT taken in order of dfsGList • If V is white • Perform dfsVisit() of GT from V and create dfsGTList • Append dfsGTList to component vector • At end of process, the component vector contains a set of vertices for each strong component in the graph G • Finding GT is O(V+E) and dfs() is O(V+E) • So, finding strong components is also O(V+E)

36. G, GT and its Strong Components • dfsGList: A B C E D G F • dfsGTLists: {A C B} , {E} , {D F G}

37. Topological sort of acyclic graphs • Important in determining precedence order in graphs representing scheduling of activities • Dfs() produces a topological sort of the vertices in the graph, returning them in the dfsList • Graph must be acyclic • To show that dfs() performs a topological sort • show that if a path exists from V to W then V always appears ahead of W in dfsList • We examine the three colors W may have when first encountered in path …

38. Path(v,w) found, v must precede W in dfsList

39. Shortest-Path Example • Shortest-path is a modified breadth-first search • Path length is number of edges traversed and is stored in dataValue field of vertex at time of its discovery • The parent field is set to the index of the parent at the same time • Path is recovered in reverse, using parent fields

40. Shortest-Path Example(path from F to C) • Start: visitQ = F:0:F format(vertex:dataValue:parent) • Next: visitQ = D:1:F, E:1:F • Next: visitQ = E:1:F, A:2:D • Next: visitQ = A:2:D • Next: visitQ = B:3:A, C:3:A • Next: visitQ = C:3:A • Finish: C found, path length = 3, path = F,D,A,C : parent( parent( parent(C) ) )

41. Minimum (weight) path – Dijkstra’s algorithm • Uses priority queue containing identities of all fringe vertices and the length of the minimum path to each from the start • Algorithm builds a tree of all minimum length paths from start • Each vertex is either tree, fringe or unseen At each step The fringe vertex V with the minimum path is removed from priorityQ and added to the tree V’s non-tree neighbors U become fringe and the minimum path length is computed from start, thru V to U and is stored in U.dataValue, V is saved as U.parent and U is added to priorityQ • Process stops when queue is empty, or chosen destination vertex is found

42. Dijkstra Minimum-Path Algorithm (Example A to D) PriQ: (A,0) Tree (vertices & path weight) (B,4) (C,11) (E,4) A,0 (E,4) (C,11) (C,10) (D,12) A,0 B,4 (C,10) (C,11) (D,12) A,0 B,4 E,4 (C,11) (D,12) A,0 B,4 E,4 C,10 (D,12) A,0 B,4 E,4 C,10 empty A,0 B,4 E,4 C,10 D,12

43. Minimum Spanning TreePrim’s Algorithm • Spanning tree for graph with minimum TOTAL weight • Minimum Spanning Tree may not be unique, but total weight is same value for all • All vertices are either tree, fringe, or unseen • Priority queue is used to hold fringe vertices and the minimum weight edge connecting each to the tree Put start vertex in priorityQ While priorityQ not empty The nearest vertex V is removed from the queue and added to the tree For each non-tree neighbor U of V if the edge V,U weight < current U.dataValue U.dataValue is set to weight of edge V,U U.parent is set to V push U:weight pair onto priority queue

44. Minimum Spanning Tree Example

45. A A 2 12 2 B C 5 B 7 8 Spanning tree with vertices A, B D minSpanTreeSize = 2, minTreeWeight = 2 Minimum Spanning Tree: Step 1 (edge A-B)

46. A A 2 2 12 5 B B C 5 7 8 D D Spanning tree with vertices A, B, D minSpanTreeSize = 3, minTreeWeight = 7 Minimum Spanning Tree:Step 2 (Edge A-D)

47. A A 2 2 12 5 B B C 5 C 7 7 8 D D Spanning tree with vertices A, B, D, C minSpanTreeSize = 4, minTreeWeight = 14 Minimum Spanning Tree:Step 3 (Edge D-C)

48. Runtime Orders of Complexity • Min Spanning Tree – O(V + E log2E) • Min Path (Dijkstra) – O(V + E log2E) • Strong Components – O(V + E) • Dfs – O(V+E) • BFS – O(V+E)

49. Graphs – Important Terms • Vertex, edge, adjacency, path, cycle • Directed (digraph), undirected • Complete • Connected (strongly, weakly, components) • Searches (DFS, BFS) • Shortest Path, Minimum Path • Euler Path, Hamiltonian Path • Minimum Spanning Tree

50. Searching Graphs • Breadth-First Search, bfs() • Locates all vertices reachable from a starting vertex • Uses a queue in process • Can be used to find the minimum distance from a starting vertex to an ending vertex in a graph.