Kosaraju算法解决强连通问题

今天花了一上午时间实现这个算法，一开始一直没有理解，加上好久不动算法，结果效率很低。下面将从中学到的一些东西总结在这里吧。

一、算法的步骤及图解

Kosaraju 算法也许最容易理解的一个算法是Kosaraju 于80 年代提
出的，它执行两次DFS。第一次DFS 得到了关于各个SCC 拓扑顺序的
有关信息，而第二次DFS 按照这个拓扑顺序的逆序进行DFS，从而把
每个SCC 分开。算法步骤如下：
第1 步：对有向图进行DFS，记录下顶点变黑的时间A[i]；遍历结
果构建一个森林W1，我们对森林中的每棵树做②、③步操作；
第2 步：改变图G 的每一条边的方向Gr；
第3 步：按上次DFS 顶点变黑的时间A[i]由大到小的顺序对Gr 进
行DFS，遍历的结果构成森林W2，W2 中每棵树的结点构成了有向图
的一个SCC。
算法的时间复杂度为O(n+m)，下面我们来举例说明为什么经过上
面的操作可以得到连通分支：

第1 步：对于有向图G 一次DFS 遍历得到的森林:

有上面可得到如下结论：
●在每个生成树中，根的时间戳最大；
●根可以到达该树的任何一个结点（其他结点不一定能到达根）；
●每棵子树的根的时间戳都大于其后代结点；他也可以到达它的所有
后代；
第2 步：现在我们对图进行反向，然后按时间戳由大到小进行dfs
得到森林如下：

 

通俗讲，这个原理就是：第一次dfs 的生成树中若存在回边，那么
边反方向后仍然可以相互到达，于是就是一个连通分量。

二、算法的证明

假设在后来转置后的图中从x dfs到了 y处，说明存在路径x->y。因为这是在转置图中，所以说明原图中存在路径y->x。

然后另外一个信息就是x的序号在y之后。这有两种可能：

1、以y为根先DFS出了一棵搜索树(可以认为是整个搜索树的一棵子树)，但是这棵子树里不包含x，并且此时x还未被dfs到。（利用反证法，如果这棵子树里包含了x，那么x的序号会在y之前）

2、y是x扩展出来的搜索树中的一个结点。

综合两个条件，综合两个条件取交。那么上面两种可能中的第一种不成立。因为存在路径y->x，所以如果x未被dfs到，一定会被y为根的搜索树包含的。于是只剩下第二种可能，那么第二种情况表明存在路径x->y。所以x,y可以互相到达。至此证明了该算法求出的都是强连通分量。命题1得证。

三、算法实现

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Vector;

public class Kosaraju {
    public static HashMap<Integer, Node> G = new HashMap<Integer, Node>(),
            GR = new HashMap<Integer, Node>();
    public static int cnt = 0, cntR = 0;
    public static int[] pre = new int[1000000], postR = new int[1000000],
            sc = new int[1000000];

    public static void main(String args[]) {
        initializeGraph();
        for (int i = 1; i < 1000000; i++) {
            pre[i] = -1;
            postR[i] = -1;
            sc[i] = -1;
        }
        System.out.println("Begin DFS 1");
        for (int i = 1; i < 1000000; i++) {
            if (pre[i] == -1) {
                dfsR(i);
            }
        }
        cnt = 0;
        System.out.println("Begin DFS 2");
        for (int i = 900000; i >= 0; i--) {
            if (sc[postR[i]] == -1) {
                if (G.get(i+1) != null){
                    dfsSc(postR[i]);
                    cnt++;
                }
                // System.out.println("DFS2   " + cnt);
            }
        }
        System.out.println(cnt);
    }

    public static void initializeGraph() {
        try {
            FileReader fr = new FileReader(
                    "C:\\Users\\waruzhi\\Desktop\\SCC.txt");
            BufferedReader br = new BufferedReader(fr);
            String tmp;
            int nodeA, nodeB;
            while ((tmp = br.readLine()) != null) {
                nodeA = Integer.parseInt(tmp.substring(0, tmp.indexOf(" ")));
                nodeB = Integer.parseInt(tmp.substring(tmp.indexOf(" ") + 1,
                        tmp.length() - 1));
                Node tA = G.get(nodeA), tB = G.get(nodeB), tAR = GR.get(nodeA), tBR = GR
                        .get(nodeB);
                if (tA == null) {
                    Node newNode = new Node(nodeA);
                    G.put(nodeA, newNode);
                    tA = newNode;
                    newNode = new Node(nodeA);
                    GR.put(nodeA, newNode);
                    tAR = newNode;
                }
                if (tB == null) {
                    Node newNode = new Node(nodeB);
                    G.put(nodeB, newNode);
                    tB = newNode;
                    newNode = new Node(nodeB);
                    GR.put(nodeB, newNode);
                    tBR = newNode;
                }
                if (tA != tB) {
                    tA.out.add(tB);
                    tBR.out.add(tAR);
                }
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static void dfsR(int num) {
        Node tmp = GR.get(num);
        if (tmp != null) {
            pre[num] = cnt++;
            // System.out.println("DFS1:   " + num + ";cnt = " + cnt);
            for (Node aNode : tmp.out) {
                if (pre[aNode.num] == -1) {
                    dfsR(aNode.num);
                }
            }
        }
        postR[cntR++] = num;
    }

    public static void dfsSc(int num) {
        Node tmp = G.get(num);
        if (tmp != null) {
            sc[num] = cnt;
            for (Node aNode : tmp.out) {
                if (sc[aNode.num] == -1) {
                    dfsSc(aNode.num);
                }
            }
        }
    }
}

四、参考代码

// Kosaraju算法邻接矩阵实现
 
static int cnt, cntR, pre[MAXV], postR[MAXV];
int Kosaraju(Graph G) {
  int v;
  // 初始化全局变量
  cnt = cntR = 0;
  for (v = 0; v < G->V; ++v)
    pre[v] = postR[v] = -1;
  // 第一次DFS，计算逆图的后序编号
  for (v = 0; v < G->V; ++v)
    if (pre[v] == -1)
      dfsPostR(G, v);
  cnt = 0;
  for (v = 0; v < G->V; ++v)
    G->sc[v] = -1;  // G->sv[v]表示顶点v的强连通分量编号
  // 第二次DFS，强连通分量编号
  for (v = G->V - 1; v >= 0; --v) {
    // 注意搜索的顶点顺序是逆图后序编号的逆序
    if (G->sc[postR[v]] == -1) {
      dfsSC(G, postR[v]);
      ++cnt;  // 对一棵树编号之后计数器值加1
    }
  }
  return cnt;  // 返回强连通分量的个数
}
 
void dfsPostR(Graph G, int v) {
  // 对逆图后序编号
  int t;
  pre[v] = cnt++;
  for (t = 0; t < G->V; ++t)
    if (G->adj[t][v] == 1)  // 注意!!!邻接矩阵引用逆图,因此是G->adj[t][v]
      if (pre[t] == -1)
        dfsPostR(G, t);
  postR[cntR++] = v;  // 后序编号,注意是计数器做数组下标
}
 
void dfsSC(Graph G, int v) {
  int t;
  G->sc[v] = cnt; // 计数器作为编号
  for (t = 0; t < G->V; ++t)
    if (G->adj[v][t] == 1)
      if (G->sc[t] == -1)
        dfsSC(G, t);
}
 
int GraphSC(Graph G, int s, int t) {
  // 比较顶点的强连通分量编号即可判断是否强连通
  return G->sc[s] == G->sc[t];
}