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值的确定，因为题目的要求是找到最早的那个搜索号，在这里会采用深度优先的方式一层层的寻找，如果找到的小的，就进行替换，如果最后找到的还是他自己的时候，说明这中间其实是一个环。然后把栈中当前节点的上方把节点全部移出。