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

  • 相关阅读:
    自动支持图片webp格式压缩,图片服务器升级webserver
    长江商学院介绍及名人校友名单
    恒大许家印靠斗着地主,当上首富
    用GitLab搭建自己的私有GitHub
    vim快速定位到某一行的几种方法和显示行号,定位匹配字符串,显示当前行信息的命令
    mysql数据库表上百万记录优化思路杂谈
    Java打印输出数组的三种方式:传统的for循环方式,for each循环,利用Arrays类中的toString方法
    个人快速成长之系统方法,最小化成长系统
    程序员应该了解的常见软件开发定律
    用python修改文件内容修改txt内容的3种方法
  • 原文地址:https://www.cnblogs.com/bianqi/p/12183977.html
Copyright © 2011-2022 走看看