Tarjan算法--有向图强连通分量算法

参考链接：https://www.byvoid.com/blog/scc-tarjan/
我的算法库：https://github.com/linyiqun/lyq-algorithms-lib

算法介绍

正如标题所介绍的那样，Tarjan算法的目标就是找出图中的连通图的，其实前提条件是这样的，在一个有向图中，有时必然会出现节点成环的情况，而在图内部的这些形成环的节点所构成的图就是我们所要找的，这个在实际生活中非常的有用，可以帮助我们解决最短距离之类的问题。

算法原理

概念

在介绍算法原理的之前，必须先明白一些概念：

1、强连通。在有向图G中，如果2个点之间存在至少一条路径，我们称这2个点为强连通。

2、强连通图。在图G中，如果其中任意的2个点都是强连通，则称图G为强连通图。

3、强连通分量。并不是所有的图中的任意2点之间都存在路径的，有些是部分节点连通，我们称这样的图为非强连通图，其中的部分强连通子图，就称为强连通分量。

强连通分量就是本次算法要找的东西。下面给出一个图示：

在上面这个图中，{1， 2， 3， 4}是强连通分量，因为5,6是达不到的对于1， 2， 3， 4,来说，这里也将5,6单独作为强连通分量，可以理解为自己到自己是可达的(这样解释感觉比较勉强，但是定义也是允许这样的情况的)。

算法的过程

算法为每个节点定义了2个变量DFN[i]和LOW[i]，DFN[i]代表的意思是i节点的搜索次序号，LOW[i]代表的是i节点或i的子节点能够追溯到的最早的节点的次序号，如果这么说没有理解的话，没有关系，可以看下面的伪代码：

tarjan(u)
{
    DFN[u]=Low[u]=++Index                      // 为节点u设定次序编号和Low初值
    Stack.push(u)                              // 将节点u压入栈中
    for each (u, v) in E                       // 枚举每一条边
        if (v is not visted)               // 如果节点v未被访问过
            tarjan(v)                  // 继续向下找
            Low[u] = min(Low[u], Low[v])
        else if (v in S)                   // 如果节点v还在栈内
            Low[u] = min(Low[u], DFN[v])
    if (DFN[u] == Low[u])                      // 如果节点u是强连通分量的根
        repeat
            v = S.pop                  // 将v退栈，为该强连通分量中一个顶点
            print v
        until (u== v)
}

算法的实现

算法的实现采用的例子还是上面这个例子，输入数据graphData.txt:

 1 2
 1 3
 2 4
 3 4
 3 5
 4 1
 4 6
 5 6

输入格式为标号1 标号2，代表的意思是存在标号1指向标号2节点的边。

有向图类Graph.java:

 package Tarjan;

 import java.util.ArrayList;

 /**
  * 有向图类
  *
  * @author lyq
  *
  */
 public class Graph {
     // 图包含的点的标号
     ArrayList<Integer> vertices;
     // 图包含的有向边的分布，edges[i][j]中，i，j代表的是图的标号
     int[][] edges;
     // 图数据
     ArrayList<String[]> graphDatas;

     public Graph(ArrayList<String[]> graphDatas) {
         this.graphDatas = graphDatas;
         vertices = new ArrayList<>();
     }

     /**
      * 利用图数据构造有向图
      */
     public void constructGraph() {
         int v1 = 0;
         int v2 = 0;
         int verticNum = 0;

         for (String[] array : graphDatas) {
             v1 = Integer.parseInt(array[0]);
             v2 = Integer.parseInt(array[1]);

             if (!vertices.contains(v1)) {
                 vertices.add(v1);
             }

             if (!vertices.contains(v2)) {
                 vertices.add(v2);
             }
         }

         verticNum = vertices.size();
         // 多申请1个空间，是标号和下标一致
         edges = new int[verticNum + 1][verticNum + 1];

         // 做边的初始化操作，-1 代表的是此方向没有连通的边
         for (int i = 1; i < verticNum + 1; i++) {
             for (int j = 1; j < verticNum + 1; j++) {
                 edges[i][j] = -1;
             }
         }

         for (String[] array : graphDatas) {
             v1 = Integer.parseInt(array[0]);
             v2 = Integer.parseInt(array[1]);

             edges[v1][v2] = 1;
         }
     }
 }

算法工具类TarjanTool.java:

 package Tarjan;

 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileReader;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Stack;

 /**
  * Tarjan算法-有向图强连通分量算法
  *
  * @author lyq
  *
  */
 public class TarjanTool {
     // 当前节点的遍历号
     public static int currentSeq = 1;

     // 图构造数据文件地址
     private String graphFile;
     // 节点u搜索的次序编号
     private int DFN[];
     // u或u的子树能回溯到的最早的节点的次序编号
     private int LOW[];
     // 由图数据构造的有向图
     private Graph graph;
     // 图遍历节点栈
     private Stack<Integer> verticStack;
     // 强连通分量结果
     private ArrayList<ArrayList<Integer>> resultGraph;
     // 图的未遍历的点的标号列表
     private ArrayList<Integer> remainVertices;
     // 图未遍历的边的列表
     private ArrayList<int[]> remainEdges;

     public TarjanTool(String graphFile) {
         this.graphFile = graphFile;
         readDataFile();
     }

     /**
      * 从文件中读取数据
      *
      */
     private void readDataFile() {
         File file = new File(graphFile);
         ArrayList<String[]> dataArray = new ArrayList<String[]>();

         try {
             BufferedReader in = new BufferedReader(new FileReader(file));
             String str;
             String[] tempArray;
             while ((str = in.readLine()) != null) {
                 tempArray = str.split(" ");
                 dataArray.add(tempArray);
             }
             in.close();
         } catch (IOException e) {
             e.getStackTrace();
         }

         // 根据数据构造有向图
         graph = new Graph(dataArray);
         graph.constructGraph();
     }

     /**
      * 初始化2个标量数组
      */
     private void initDfnAndLow(){
         int verticNum = 0;
         verticStack = new Stack<>();
         remainVertices = (ArrayList<Integer>) graph.vertices.clone();
         remainEdges = new ArrayList<>();
         resultGraph = new ArrayList<>();

         for (int i = 0; i < graph.edges.length; i++) {
             remainEdges.add(graph.edges[i]);
         }

         verticNum = graph.vertices.size();
         DFN = new int[verticNum + 1];
         LOW = new int[verticNum + 1];

         // 初始化数组操作
         for (int i = 1; i <= verticNum; i++) {
             DFN[i] = Integer.MAX_VALUE;
             LOW[i] = -1;
         }
     }

     /**
      * 搜索强连通分量
      */
     public void searchStrongConnectedGraph() {
         int label = 0;
         int verticNum = graph.vertices.size();
         initDfnAndLow();

         // 设置第一个的DFN[1]=1;
         DFN[1] = 1;
         // 移除首个节点
         label = remainVertices.get(0);

         verticStack.add(label);
         remainVertices.remove((Integer) 1);
         while (remainVertices.size() > 0) {
             for (int i = 1; i <= verticNum; i++) {
                 if (graph.edges[label][i] == 1) {
                     // 把与此边相连的节点也加入栈中
                     verticStack.add(i);
                     remainVertices.remove((Integer) i);

                     dfsSearch(verticStack);
                 }
             }

             LOW[label] = searchEarliestDFN(label);
             // 重新回溯到第一个点进行DFN和LOW值的判断
             if (LOW[label] == DFN[label]) {
                 popStackGraph(label);
             }
         }

         printSCG();
     }

     /**
      * 深度优先遍历的方式寻找强连通分量
      *
      * @param stack
      *            存放的节点的当前栈
      * @param seqNum
      *            当前遍历的次序号
      */
     private void dfsSearch(Stack<Integer> stack) {
         int currentLabel = stack.peek();
         // 设置搜索次序号，在原先的基础上增加1
         currentSeq++;
         DFN[currentLabel] = currentSeq;
         LOW[currentLabel] = searchEarliestDFN(currentLabel);

         int[] edgeVertic;
         edgeVertic = remainEdges.get(currentLabel);
         for (int i = 1; i < edgeVertic.length; i++) {
             if (edgeVertic[i] == 1) {
                 // 如果剩余可选节点中包含此节点吗，则此节点添加
                 if (remainVertices.contains(i)) {
                     stack.add(i);
                 } else {
                     // 不包含，则跳过
                     continue;
                 }

                 // 将与此边相连的点加入栈中
                 remainVertices.remove((Integer) i);
                 remainEdges.set(currentLabel, null);

                 // 继续深度优先遍历
                 dfsSearch(stack);
             }
         }

         if (LOW[currentLabel] == DFN[currentLabel]) {
             popStackGraph(currentLabel);
         }

     }

     /**
      * 从栈中弹出局部结果
      *
      * @param label
      *            弹出的临界标号
      */
     private void popStackGraph(int label) {
         // 如果2个值相等，则将此节点以及此节点后的点移出栈中
         int value = 0;

         ArrayList<Integer> scg = new ArrayList<>();
         while (label != verticStack.peek()) {
             value = verticStack.pop();
             scg.add(0, value);
         }
         scg.add(0, verticStack.pop());

         resultGraph.add(scg);
     }

     /**
      * 当前的节点可能搜索到的最早的次序号
      *
      * @param label
      *            当前的节点标号
      * @return
      */
     private int searchEarliestDFN(int label) {
         // 判断此节点是否有子边
         boolean hasSubEdge = false;
         int minDFN = DFN[label];

         // 如果搜索到的次序号已经是最小的次序号，则返回
         if (DFN[label] == 1) {
             return DFN[label];
         }

         int tempDFN = 0;
         for (int i = 1; i <= graph.vertices.size(); i++) {
             if (graph.edges[label][i] == 1) {
                 hasSubEdge = true;

                 // 如果在堆栈中和剩余节点中都未包含此节点说明已经被退栈了，不允许再次遍历
                 if (!remainVertices.contains(i) && !verticStack.contains(i)) {
                     continue;
                 }
                 tempDFN = searchEarliestDFN(i);

                 if (tempDFN < minDFN) {
                     minDFN = tempDFN;
                 }
             }
         }

         // 如果没有子边，则搜索到的次序号就是它自身
         if (!hasSubEdge && DFN[label] != -1) {
             minDFN = DFN[label];
         }

         return minDFN;
     }

     /**
      * 标准搜索强连通分量算法
      */
     public void standardSearchSCG(){
         initDfnAndLow();

         verticStack.add(1);
         remainVertices.remove((Integer)1);
         //从标号为1的第一个节点开始搜索
         dfsSearchSCG(1);

         //输出结果中的强连通分量
         printSCG();
     }

     /**
      * 深度优先搜索强连通分量
      *
      * @param u
      *            当前搜索的节点标号
      */
     private void dfsSearchSCG(int u) {
         DFN[u] = currentSeq;
         LOW[u] = currentSeq;
         currentSeq++;

         for (int i = 1; i <graph.edges[u].length; i++) {
             // 判断u,i两节点是否相连
             if (graph.edges[u][i] == 1) {
                 // 相连的情况下，当i未被访问过的时候，加入栈中
                 if (remainVertices.contains(i)) {
                     verticStack.add(i);
                     remainVertices.remove((Integer) i);
                     // 递归搜索
                     dfsSearchSCG(i);
                     LOW[u] = (LOW[u] < LOW[i] ? LOW[u] : LOW[i]);
                 } else if(verticStack.contains(i)){
                     // 如果已经访问过，并且还未出栈过的
                     LOW[u] = (LOW[u] < DFN[i] ? LOW[u] : DFN[i]);
                     //LOW[u] = (LOW[u] < LOW[i] ? LOW[u] : LOW[i]); 如果都用LOW做判断，也可以通过测试
                 }
             }
         }

         // 最后判断DFN和LOW是否相等
         if (DFN[u] == LOW[u]) {
             popStackGraph(u);
         }
     }

     /**
      * 输出有向图中的强连通分量
      */
     private void printSCG() {
         int i = 1;
         String resultStr = "";
         System.out.println("所有强连通分量子图:");
         for (ArrayList<Integer> graph : resultGraph) {
             resultStr = "";
             resultStr += "强连通分量" + i + "：{";
             for (Integer v : graph) {
                 resultStr += (v + ", ");
             }
             resultStr = (String) resultStr.subSequence(0,
                     resultStr.length() - 2);
             resultStr += "}";

             System.out.println(resultStr);
             i++;
         }
     }
 }

测试类Client.java:

 package Tarjan;

 /**
  * Tarjan算法--有向图强连通分量算法
  * @author lyq
  *
  */
 public class Client {
     public static void main(String[] args){
         //图构造数据文件地址
         String graphFilePath = "C:\\Users\\lyq\\Desktop\\icon\\graphData.txt";

         TarjanTool tool = new TarjanTool(graphFilePath);
         //下面这个方法为改造的一点方法，还有点问题
         //tool.searchStrongConnectedGraph();
         tool.standardSearchSCG();
     }
 }

算法的执行步骤如图所示（手机拍摄的截图效果不佳，请不要见怪）：

主要展示了随着遍历的顺序DFN和LOW数组的赋值情况，以及栈的内容变化情况

算法的输出结果：

 所有强连通分量子图:
 强连通分量1：{6}
 强连通分量2：{5}
 强连通分量3：{1, 2, 4, 3}

算法的遗漏点

在这个算法中，我写了2个算法，searchStrongConnectGraph是我自己在没有看伪代码写的，后来发现，意思有点曲解了，遇到循环图的时候也会有问题，后来马上看了伪代码，马上代码精简了很多，的确是非常强大的算法，第二点是我觉得在下面这个步骤中，判断是否可以合并在一起，因为我发现结果是一致的，都可以用LOW数组的值来判断。

 // 相连的情况下，当i未被访问过的时候，加入栈中
                 if (remainVertices.contains(i)) {
                     verticStack.add(i);
                     remainVertices.remove((Integer) i);
                     // 递归搜索
                     dfsSearchSCG(i);
                     LOW[u] = (LOW[u] < LOW[i] ? LOW[u] : LOW[i]);
                 } else if(verticStack.contains(i)){
                     // 如果已经访问过，并且还未出栈过的
                     LOW[u] = (LOW[u] < DFN[i] ? LOW[u] : DFN[i]);
                     //LOW[u] = (LOW[u] < LOW[i] ? LOW[u] : LOW[i]); 如果都用LOW做判断，也可以通过测试
                 }

可能是为了让图中的边只允许被遍历一次的原因吧。

算法的突破点

很明显算法的突破口在于比较LOW和DFN的值，因为DFN的值在遍历顺序的就已经确定，所以问题的关键在于LOW值的确定，因为题目的要求是找到最早的那个搜索号，在这里会采用深度优先的方式一层层的寻找，如果找到的小的，就进行替换，如果最后找到的还是他自己的时候，说明这中间其实是一个环。然后把栈中当前节点的上方把节点全部移出。