Kosaraju算法（发现强连通分图算法）

        看论文的时候，看到Kosaraju算法。Kosaraju是一个强连通分图的发现算法，如有代码中有详细的注释，所以就不赘述了。直接上码（使用webgraph库实现，在我之前的文章中，对webgraph有相关的介绍）：

package cn.edu.dlut.wisdom;
import it.unimi.dsi.fastutil.ints.*;
import it.unimi.dsi.fastutil.objects.*;
import it.unimi.dsi.webgraph.*;
import java.util.Comparator;
/**
 * @author You Wang
 * Kosaraju算法，用来发现强连通分量
 * 算法过程如下：
 * G：有向图；S：空栈
 * while S中不包含G中所有顶点
 *     任选一个不在S中的节点v
 *     从v开始进行深度优先搜素，每次将访问到的节点u压入S中
 * 反转G中所有的边
 * while S非空
 *     从S中弹出结点v
 *     从v开始进行深度优先搜索，所有访问到的结点构成强连通分图，记录下来
 *     从G和S中删除这些结点
 */
public class Kosaraju {
    private ImmutableGraph graph;
    private ImmutableGraph igraph;
    private ImmutableGraph workGraph;
    private ObjectAVLTreeSet<IntAVLTreeSet> sccs;
    private IntArrayList stack;
    private boolean[] visited;
    private int numNodes;
    public Kosaraju(ImmutableGraph graph) {
        this.graph = graph;
        igraph = Transform.transpose(graph);
        numNodes = graph.numNodes();
    }
    public Kosaraju(ImmutableGraph graph, ImmutableGraph igraph) {
        this.graph = graph;
        this.igraph = igraph;
        numNodes = graph.numNodes();
    }
    public ObjectAVLTreeSet<IntAVLTreeSet> compute() {
        stack = new IntArrayList();
        visited = new boolean[numNodes];
        workGraph = graph;
        // dfs the graph, adding nodes to the stack
        for(int i = 0; i < numNodes; i++)
            if(!stack.contains(i))
                dfs(i, true);
        workGraph = igraph;
        Comparator cmp = new Comparator() {
            public int compare(Object o1, Object o2) {
                if(o1 instanceof IntAVLTreeSet && o2 instanceof IntAVLTreeSet) {
                    IntAVLTreeSet s1 = (IntAVLTreeSet)o1;
                    IntAVLTreeSet s2 = (IntAVLTreeSet)o2;
                    if (s1.size() != s2.size())
                        return s1.size() - s2.size();
                    else
                    {
                        int[] a1 = s1.toIntArray();
                        int[] a2 = s2.toIntArray();
                        for (int i = 0; i < a1.length; i++)
                            if (a1[i] != a2[i])
                                return a1[i] - a2[i];
                        return 0;
                    }
                }
                else
                    throw new IllegalArgumentException("The argument must be an IntAVLTreeSet");
            }
        };
        sccs = new ObjectAVLTreeSet<IntAVLTreeSet>(cmp);
        while(!stack.isEmpty()) {
            IntAVLTreeSet component = new IntAVLTreeSet();
            int v = stack.popInt();
            component.add(v);
            dfs(v, false);
            // any components we visited are strongly connected
            // remove them from the starck and add them to the component
            IntIterator it = stack.iterator();
            while(it.hasNext()) {
                int n = it.nextInt();
                if(!visited[n]) {
                    component.add(n);
                    it.remove();
                }
            }
            if(component.size() != 0)
                sccs.add(component);
        }
        return sccs;
    }
    private void dfs(int node, boolean forward) {
        visited[node] = forward;
        if(workGraph.outdegree(node) == 0) {
            if(forward)
                stack.push(node);
            return;
        }
        for(int n : workGraph.successorArray(node))
            if(visited[n] != forward)
                dfs(n, forward);
        if(forward)
            stack.push(node);
    }
}

 

        其中的set排序，个人感觉不尽完美，不知道各位有何高见，欢迎指正。