1. Podcast Ch24b Title: Strongly Connected Components
Description: Overview of strongly connected components; strongComponents method
Participants: Barry Kurtz (instructor); John Helfert and Tobie Williams (students)
Textbook: Data Structures for Java; William H. Ford and William R. Topp

2. Strongly Connected Components
Any graph can be partitioned into a unique set of strong components.

3. Student Question
What are the strong components in graph G?

4. Strongly Connected Components (continued)
The algorithm for finding the strong components of a directed graph G uses the transpose of the graph.
The transpose GT has the same set of vertices V as graph G but a new edge set consisting of the edges of G but with the opposite direction.

5. Strongly Connected Components (continued)
Execute the depth-first search dfs() for the graph G which creates the list dfsList consisting of the vertices in G in the reverse order of their finishing times.
Generate the transpose graph GT.
Using the order of vertices in dfsList, make repeated calls to dfsVisit() for vertices in GT. The list returned by each call is a strongly connected component of G.

6. Strongly Connected Components (continued)

7. Strongly Connected Components (continued)
dfsList: [A, B, C, E, D, G, F]
Using the order of vertices in dfsList, make successive
calls to dfsVisit() for graph GT
Vertex A: dfsVisit(A) returns the list [A, C, B] of vertices reachable
from A in GT.
Vertex E: The next unvisited vertex in dfsList is E. Calling dfsVisit(E) returns the list [E].
Vertex D: The next unvisited vertex in dfsList is D; dfsVisit(D) returns the list [D, F, G] whose elements form the last
strongly connected component.

8. strongComponents() // find the strong components of the graph;
// each element of component is a LinkedList
// of the elements in a strong component
public static <T> void strongComponents(DiGraph<T> g,
ArrayList<LinkedList<T>> component) {
T currVertex = null;
// list of vertices visited by dfs() for graph g
LinkedList<T> dfsList = new LinkedList<T>();
// list of vertices visited by dfsVisit()
// for g transpose
LinkedList<T> dfsGTList = null;
// used to scan dfsList
Iterator<T> gIter;
// transpose of the graph
DiGraph<T> gt = null;

9. strongComponents() (cont)
// clear the return vector
component.clear();
// execute depth-first traversal of g
dfs(g, dfsList);
// compute gt
gt = transpose(g);
// initialize all vertices to WHITE (unvisited)
gt.colorWhite();
// call dfsVisit() for gt from vertices in dfsList
gIter = dfsList.iterator();
while(gIter.hasNext()) {
currVertex = gIter.next();

10. strongComponents() (concluded)
// call dfsVisit() only if vertex
// has not been visited
if (gt.getColor(currVertex) ==
VertexColor.WHITE) {
// create a new LinkedList to hold
// next strong component
dfsGTList = new LinkedList<T>();
// do dfsVisit() in gt for starting
// vertex currVertex
dfsVisit(gt, currVertex, dfsGTList, false);
// add strong component to the ArrayList
component.add(dfsGTList); }

11. Running Time of strongComponents()
Recall that the depth-first search has running time O(V+E), and the computation for GT is also O(V+E). It follows that the running time for the algorithm to compute the strong components is O(V+E).

12. Student Question
List the vertices in reverse order of finish time for a depth-first search of this digraph.
dfsList: [ _________________________________________ ]
Display the transpose of the graph.
List the strong components by doing a depth-first search of the transpose in the order specified by your dfsList.
_____________________________________________