1. 1 Testing for Connectedness and Cycles Connectedness of Undirected Graphs Implementation of Connectedness detection Algorithm for Undirected Graphs. Implementation of Strong Connectedness Algorithm. Cycles in Directed Graphs. Implementation of Cycle detection Algorithm for Directed Graphs. Cycles in Undirected Graphs Review Questions.

2. 2 Connectedness of Undirected Graphs An undirected graph G = (V, E) is connected if there is a path between every pair of vertices. Although the figure below appears to be two graphs, it is actually a single graph. Clearly, G is not connected. For example there is no path between A and D. G consists of two unconnected parts, each of which is a maximal connected sub-graph (i.e., a connected component).

3. 3 Implementation of Connectedness Algorithm for Undirected Graphs A simple way to test for connectedness in an undirected graph is to use either depth-first or breadth-first traversal starting from any vertex - Only if all the vertices are visited is the graph connected. The algorithm uses the following visitor: public class CountingVisitor extends AbstractVisitor { protected int counter; public int getCount(){ return counter;} public void visit(Object obj) {counter++;} } Using the CountingVisitor, the isConnected method is implemented as follows: public boolean isConnected() { if(this.isDirected()) throw new InvalidOperationException( "Invalid for Directed Graphs"); CountingVisitor visitor = new CountingVisitor(); Iterator i = getVertices(); Vertex start = (Vertex) i.next(); breadthFirstTraversal(visitor, start); return visitor.getCount() == numberOfVertices; }

4. 4 Connectedness of Directed Graphs A directed graph G = (V, E) is strongly connected if there is a directed path between every pair of vertices [i.e, given any pair of vertices v 1 and v 2, there is a directed path from v 1 to v 2, and there is a directed path from v 2 to v 1 ]. A directed graph G =(V, E) is weakly connected if: –The underlying undirected graph is connected, and if –The is at least one pair of vertices v 1 and v 2 that are not reachable from one another. A directed graph G = (V, E) is disconnected if the underlying undirected graph is disconnected. Example: A weakly connected directed graph

5. 5 Implementation of Strong Connectedness Algorithm A simple way to test for strong connectedness in a directed graph G = (V, E) is to use |V| traversals, each traversal starting from a different graph vertex - The graph is strongly connected if in each traversal all vertices are visited; otherwise it is either disconnected or it is weakly connected. public boolean isStronglyConnected() { if (!this.isDirected()) throw new InvalidOperationException( "Invalid for Undirected Graphs"); Iterator it = getVertices(); while(it.hasNext()) { CountingVisitor visitor = new CountingVisitor(); breadthFirstTraversal(visitor, (Vertex) it.next()); if(visitor.getCount() != numberOfVertices) return false; } return true; } Note: The implementation of weak connectedness algorithm is a task in the Lab.

6. 6 Detection of Cycles in Directed Graphs One algorithm to detect the presence of cycles in a directed graph uses source-removal topological order traversal algorithm. –This algorithm visits all the vertices of a directed graph if the graph has no cycles; otherwise not all vertices are visited. Example: In the graph below, after A is visited and removed, all the remaining vertices have in-degree of one. Thus, a topological order traversal cannot complete. This is because of the presence of the cycle { B, C, D, B}. public boolean isCyclic() { if (!this.isDirected()) throw new InvalidOperationException( "Invalid for Undirected Graphs"); CountingVisitor visitor = new CountingVisitor(); topologicalOrderTraversal(visitor); return visitor.getCount() != numberOfVertices; }

7. 7 Detection of Cycles in Directed Graphs: DFS based Algorithm A cycle exits in a directed graph if a back edge is detected during a DFS traversal. A back edge exists in a directed graph if the currently explored vertex has an adjacent vertex that was already colored gray dfsAllVertices(G){ color all vertices white; for( each v  V) if (v is white){ if (DFS(v)) Output(“cycle detected”); exit;} Output(“No cycle detected”); } boolean DFS(v){ color[v] = “gray”; [previsit(v)] for (each w adjacent to v){ if(color[w] == “gray”){ return true;} // Cycle exists if (color[w] == “white”){ [ Add edge (v, w) to DFS tree] DFS(w); } [postvisit(v)] color[v] = black; return false; // No cycle exists in the group of vertices reachable from current v }

8. 8 Detection of Cycles in Undirected Graphs: Algorithm1 The algorithm traverses the graph, ignoring each back edge from a vertex to the parent of that vertex. If an edge (v, w) is encountered where both v and w are colored gray, and v is not the parent of w in the DFS tree, a cycle exists in the graph. dfsAll(G){ for each vertex v of G{ color[v] = “white”; parent[v] = null; } for each vertex v of G { if( color[v] == “white”) if(DFS(v)) {Output(“Cycle detected”); exit;}; } Output(“No cycle detected”); } boolean DFS(v){ color[v] = “gray”; for( each vertex w adjacent to v ){ if (color[w] == “white”){ parent[w] = v; DFS(w); } else if( color[w] == “gray” and parent[w] != v) return true; // cycle detected } color[v] = black; return false; // no cycle detected in this component }

9. 9 Detection of Cycles in Undirected Graphs: Algorithm1 (Cont’d) Exercise: Trace the algorithm in the previous slide on the graph given below starting at vertex A : Note: The graph is represented as shown below. The representation is not a multi-graph:

10. 10 Detection of Cycles in Undirected Graphs: Algorithm2 This algorithm is based on the fact that an undirected acyclic graph G = (V, E) is a free tree, in which |E| = |V| - 1; however since each edge in an undirected graph is represented by two edges; the relationship used in the algorithm is |E|/2 = |V| - 1 Thus a connected component of an undirected graph has a cycle if |E component | / 2  |V component | The algorithm is given in the next slide

11. 11 Detection of Cycles in Undirected Graphs: Algorithm2 (Cont’d) DFSAll(G){ Mark all vertices as unvisited; for(i = 0; i < numberOfVertices; i++){ if(vertex i is not visited){ ncce = 0; // global variable, numberOfConnectedComponentEdges nccv = 0; // global variable, numberOfConnectedComponentVertices DFS(vertex i, nccv, ncce); if(ncce/2  nccv){ Output("There is a cycle"); return; } Output("There is no cycle"); } DFS(v, nccv, ncce){ mark v visited; nccv++; for(each vertex w adjacent to v){ ncce++; if(w is not visited) DFS(w, nccv, ncce); }

12. 12 Review Questions 1. Every tree is a directed, acyclic graph (DAG), but there exist DAGs that are not trees. a) How can we tell whether a given DAG is a tree? b) Devise an algorithm to test whether a given DAG is a tree. 2. Consider an acyclic, connected, undirected graph G that has n vertices. How many edges does G have? 3. In general, an undirected graph contains one or more connected components. a) Devise an algorithm that counts the number of connected components in a graph. b) Devise an algorithm that labels the vertices of a graph in such a way that all the vertices in a given connected component get the same label and vertices in different connected components get different labels. 4. Devise an algorithm that takes as input a graph, and a pair of vertices, v and w, and determines whether w is reachable from v.