Find all sets of strongly-connected vertices - c

Question

I have a linked-list of edges to a digraph which I am trying to find all sets of strongly-connected components. Can anybody point me toward an algorithm with a good worst-case time (sample pseudo or C code would be much appreciated).
EDIT: I am trying to find all sets of edges that create strongly-connected components and not the vertices. In the graph below notice that there are 2 sets of edges to create a strongly-connected component, however only two edges on the graph are used for both (a->b and b->c). The algorithm should be able to produce sets { a->b, b->c, c->a } and { a->b, b->c, c->b, b->a }.
http://img521.imageshack.us/img521/8025/digraph.jpg
Hope that helps make more clear my goal.
EDIT2: I have a semi working implementation, however I noticed that it doesn't work if the graph which I am searching in is also strongly connected. Does anybody know of a way to find SCC within a SCC?

Answer 1

The Strongly connected component definition on wikipedia recommends three algorithms. I would go with Tarjan's as the best combination of efficiency and ease of implementation.
I've taken the Pseudo-code on wikipedia, and modified to keep a list of all SCCs. It follows:
Input: Graph G = (V, E)
List<Set> result = empty
index = 0 // DFS node number counter
S = empty // An empty stack of nodes
for all v in V do
if (v.index is undefined) // Start a DFS at each node
tarjan(v, result) // we haven't visited yet
procedure tarjan(v, result)
v.index = index // Set the depth index for v
v.lowlink = index
index = index + 1
S.push(v) // Push v on the stack
for all (v, v2) in E do // Consider successors of v
if (v2.index is undefined) // Was successor v' visited?
tarjan(v2, result) // Recurse
v.lowlink = min(v.lowlink, v2.lowlink)
else if (v2 is in S) // Was successor v' in stack S?
v.lowlink = min(v.lowlink, v2.index) // v' is in stack but not the dfs tree
if (v.lowlink == v.index) // Is v the root of an SCC?
set interconnected = empty
previous = v
repeat
v2 = S.pop
interconnected.add((previous,v2)) // record this edge
last = previous=v2
until (v2 == v)
result.add(interconnected)
Edit in response to further specification.
Do you see that the algorithm pushes the vertices onto the stack then pops them off again? I think this probably means that you can know that each consecutive stack element is connected to the one before by an edge. I've modified the pseudo-code above to reflect this, (but haven't tried it).

Answer 2

The wikipedia page for strongly connected components points to three algorithms, all of them explained in wikipedia in sufficient detail to directly translate into source code. If that information is insufficient, you probably should indicate what exactly is missing.

Answer 3

Even after your second edit, I'm still not sure what your goal actually is. This is hindered by your choice of terminology. SCCs as most people mean them are maximal sets of vertices that are all reachable from each other, and what paths may occur simply doesn't matter.
Does anybody know of a way to find SCC within a SCC?
By the usual definitions, there is no such thing as an SCC within an SCC, because an SCC is maximal.
You're looking for something else: you start with a connected graph, and want to find particular edge sets that you have not well characterized. I strongly suspect that if you do characterize what you want in a clear way, an algorithm will fall out.
My first guess, was that for a given connected graph, you want the edge sets of all possible combinations of all paths connecting each pair. If that's the case, the straightforward way to do this is: for each pair, find all paths, then find all combinations and eliminate duplicates. However, this generates more sets than you list in your example, as using all of the edges is certainly possible.
Instead, it appears you want all minimal edge sets that still let the original vertices remain an SCC. In this case, each element of the power set of the original edge set represents a possible candidate, and you want all of the candidates where the graph is still connected, but with no proper subset that is still connected.
This gives a straightforward algorithm of walking this lattice of sets and checking this condition. Checking if a graph is connected is straight-forward, as is removing or adding edges. However, similar graphs have most of the same structure, so you'll want to reuse what you can from previous problems.
Some references that may help:
Connectivity (graph theory)
Menger's Theorem
Max-flow min-cut theorem
Especially in terms of connecting global information of the graph to local information about edges and vertices.
Your starting graph G has a set of vertices V, and Edges E, and is strongly connected.
The goal is to output all "minimal" sets of edges E' such that removing any edge from E breaks the graph into multiple SCCs. We can do this by searching all possible edgesets.
Straightforwardly this is:
for E' in powerset(E):
if (V, E') strongly connected:
for e in E':
if (V, E' - e) strongly connected:
try next E' # Not minimal
add G' = (V, E') to list of minimal subsets.
However this is incredibly wasteful: Obviously unconnected graphs are
tested, and the connectivity of each graph is tested many many times.
We can eliminate the first by searching through the possible edgesets
in a much nicer order, arranging these edge sets in a lattice. Each
edgeset has "direct children" given by that edgeset minus one edge.
Once we run into a graph that is not an SCC, we need not check any of
its subsets, as they can't be SCCs either. The easiest way to express
this is as a graph search. While a depth first search is often the
way to go, as it uses less memory, I'm going to choose a breadth first
search, because later on we will use the order of traversal. (A depth
first search changes the queue to a stack).
push starting node on queue
while queue not empty:
pop node from queue
for c in suitable children, not on queue:
push c on queue
deal with node
The "not on queue" part is crucial, otherwise each node can be visited
many times. This turns our algorithm into:
push E on queue
while queue not empty:
pop E' from queue
if (V, E') strongly connected:
minimal = true
for e in E':
if (V, E' - e) strongly connected:
push E' - e on queue if not on queue
minimal = false
if minimal:
add G' = (V, E') to list of minimal subsets.
Now it skips all the edgesets that can't possibly be strongly connected,
because supersets aren't either. The downside is that it can
possibly use lots of space. It still, however, repeatedly checks for
connectivity. We can, however, cache that information.
check_or_add_cached_connected(E)
push E on queue
while queue not empty:
pop E' from queue
connected = cached (E')
if connected:
minimal = true
for e in E':
child_connected = check_or_add_cache(E' - e)
if child_connected:
push E' - e on queue if not on queue
minimal = false
if minimal:
add G' = (V, E') to list of minimal subsets.
remove E' from cache
Now that we've started caching, there's more we could cache. If
removing an edge breaks the graph, it will also break any subgraph.
This means we can keep track of "required edges" in a graph and
propagate them down to any subgraph. And we can check these required
edges to avoid checking subgraphs.
check_or_add_cached_connected(E)
push E on queue
while queue not empty:
pop E' from queue
(connected, required_edges) = cached (E')
if connected:
minimal = true
for e in E' and not in required_edges:
child_connected = check_or_add_cached_connected(E' - e)
if child_connected:
push E' - e on queue if not on queue
minimal = false
else:
add e to required_edges
if minimal:
add G' = (V, E') to list of minimal subsets.
else:
for e in E' and not in required_edges:
merge_cache(E' - e, required_edges)
remove E' from cache
The structure of the cache and queue do require a bit of work to ensure the operations used can be done efficiently, but this is fairly straightforward.