有向图的强连通性（java）

Kosaraju算法

一句话理解Kosaraju算法：按从终点向起点遍历的顺序遍历有向图，如果能遇到起点，那么就说明该两点之间是强连接关系。

Tarjan算法

package graph.digraph;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.Scanner;
import java.util.Stack;

import list.Bag;

/**
 * 计算强连通分量的Tarjan算法
 * 思路：为每个节点记录下其遍历的次序，
 * 和一个动态的标识，该标识表示此结点最小强连通图的根结点，即记录该结点属于哪个最小子树，
 * 那么如何记录呢，通过递归的方法从下到上（从叶子结点到根结点）回溯，倒着更新每个结点的标识，
 * 这样如果遇到了子结点是已经访问过的结点，此时更新其上一个结点的标识（取子结点的次序和本结点的标识的最小值）；
 * 如果遇到了子结点是新结点，那么就继续下递归。
 * 每次更新完一个结点的标识，就和自己的次序做一个比较，看自己是不是最小连通图的根结点，是的话就把从自己往后的结点全部出栈。
 */
public class SCC2 {

    //遍历标记
    private boolean[] marked;
    //连通分量标记
    private int[] id;
    //遍历次序记录
    private int[] dfn;
    //所在最小子树的根结点记录
    private int[] low;
    //遍历栈
    private Stack<Integer> stack = new Stack<>();
    private int index = 0;
    private int count = 0;

    public SCC2(Digraph D) {
        marked = new boolean[D.V()];
        dfn = new int[D.V()];
        low = new int[D.V()];
        id = new int[D.V()];
        for (int i=0; i < D.V(); ++i){
            if (!marked[i]){
                dfs(D, i);
            }
        }
    }

    private void dfs(Digraph D, int v){
        //初始化次序和标识
        low[v] = dfn[v] = ++index;
        //入栈遍历的结点
        stack.push(v);
        marked[v] = true;

        for (int w:D.adj(v)){
            //未访问过的子结点，继续向下遍历，然后通过回溯再更新自己的标识
            if (!marked[w]){
                dfs(D, w);
                low[v] = Math.min(low[v], low[w]);
            //如果该子结点仍在栈中，那么取两者的最小值，更新自己的标识
            }else if (stack.contains(w)){
                low[v] = Math.min(low[v], dfn[w]);//此处有疑问，不知道为何要取两者的最小值，不是dfn[w]就可以了吗 TODO
            }
        }

        //自己是根结点，出栈
        if (low[v] == dfn[v]){
            ++count;
            int tmp;
            do {
                tmp = stack.pop();
                id[tmp] = count;
            }while (tmp != v);
        }
    }

    boolean stronglyConnected(int v, int w){
        return id[v] == id[w];
    }

    int count(){
        return count;
    }

    int id(int v){
        return id[v];
    }

    public static void main(String[] args){
        try {
            Digraph d = new Digraph(new Scanner(new FileReader(new File("src/graph/data/data1"))));
            System.out.println(d);
            SCC2 cc = new SCC2(d);

            Bag<Integer>[] components = (Bag<Integer>[]) new Bag[cc.count()];
            for (int i=0; i < cc.count(); ++i){
                components[i] = new Bag<>();
            }
            for (int v=0; v < d.V(); ++v){
                components[cc.id(v)-1].add(v);
            }
            for (int i=0; i < cc.count(); ++i){
                System.out.print(i + ": ");
                components[i].forEach(System.out::print);
                System.out.println();
            }
            System.out.println("components:" + cc.count());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

}