图的拓扑排序及其应用

逃离我推掉我的手 2022-06-04 05:47 190阅读 0赞

### 拓扑排序的定义 ###

对一个有向无环图G进行拓扑排序，是将G中所有顶点排成一个线性序列，使得**图中任意一对顶点u和v，若边(u,v)∈E(G)，则u在线性序列中出现在v之前。**通常，这样的线性序列称为满足拓扑次序(Topological Order)的序列，简称拓扑序列。简单的说，由某个集合上的一个偏序得到该集合上的一个全序，这个操作称之为拓扑排序。

### 拓扑排序的应用 ###

参考一道ACM题目[确定比赛名次][Link 1]  
问题描述：

有N个比赛队（1<=N<=500），编号依次为1，2，3，。。。。，N进行比赛，比赛结束后，裁判委员会要将所有参赛队伍从前往后依次排名，但现在裁判委员会不能直接获得每个队的比赛成绩，只知道每场比赛的结果，即P1赢P2，用P1，P2表示，排名时P1在P2之前。现在请你编程序确定排名。
    
    现已知有4个队伍参加比赛，而每两队的比赛成绩如下:
    1 2
    2 3
    4 3
    
    1，2表示即P1队赢了P2队。先让你排序出整个比赛的排名

**该问题的求解过程如下：**  
完全可将P1～P4的比赛排名按题目要求构建出一个有向图：

P1 —> P2 —> P3 <— P4

由图自然非常清楚的看出排名为P1，P2，P4, P3或P1，P4，P2, P3

如果我们考虑图的相关性质在里面，会发现：  
入度为 0 的顶点 P1 是排序中的第一名(因为没有任何人战胜它)，而确定好第一名之后，将第一名从排序中踢出，剩下的图： P2–> P3 <– P4 中，依然存在入度为0的节点，依次类推，便得到了一个求拓扑排序的算法。

### 拓扑排序存在的条件 ###

并不是所有图都存在拓扑排序，拓扑排序在图中也不是唯一的(例如上例中将存在两个拓扑排序)。

**不含环路的有向图必包含入度为零的顶点—因此一定存在拓扑排序**

#### 拓扑排序的算法实现 ####

入度为 0 的顶点 m（及其关联边）从图 G 中取出，则剩余的 G’依然是有向无环图，故其拓扑排序也必然存在。从递归的角度看，一旦得到了 G’ 的拓扑排序，只需将 m 作为最大顶点插入，即可得到 G 的拓扑排序。如此，我们已经得到了一个拓扑排序的算法。

![这里写图片描述][SouthEast]

上图给出了拓扑排序的一种实现思路(不同的递归入度为0的节点)，现在从另一角度—图的[DFS搜索][DFS]入手，来实现一个效率更高的拓扑排序

回顾笔者的上一篇博文[图的深度优先搜索算法并生成DFS树  
][DFS]。

对于节点包含如下几个类型：

private int status = 0;  //状态 0 undiscovered "未发现"  1 discovered "已发现"  2 visited "已完成"

对于弧有如下类型：

private int type;
        //弧类型：0 CROSS 跨边  1 TREE（支撑树） 
        //2 BACKWARD(该弧的起点和终点在支撑树中存在终点到起点的路径) 
        //3 FORWARD (该弧的起点和终点在支撑树中存在其他路径依然可以从起点到终点)

你会发现，**在对有向无环图的DFS搜索中，首先因访问完成而转换至“2 - 已完成“状态的顶点m就是出度为0的节点—-也就是在拓扑排序中最末尾的节点。**

进一步地，根据 DFS 搜索的特性，顶点 m（及其关联边）对此后的搜索过程将不起任何作用。**于是，下一转换至 “2 - 已完成“ 状态的顶点可等效地理解为是，从图中剔除顶点 m（及其关联边）之后的出度为零者 — 在拓扑排序中，该顶点应为顶点 m 的前驱。**由此可见，DFS 搜索过程中各顶点被标记为 “2 -已完成“ 的次序，恰好（按逆序）给出了原图的一个拓扑排序。

此外，基于DFS 可以检测环路的特性，恰好可以用来判别输入是否为有向无环图。在搜索过程中一旦发现后向边(2 - BACKWARD)，即可抛出异常“存在环路，无法拓扑排序“。

基于DFS搜索，求拓扑排序的代码实现

public List toSort() throws Exception{
          List<Integer> result = new LinkedList<Integer>();
    
              int index = 0;
              int s = index;
              Stack<Integer> stack = new Stack<Integer>();
    
              do {
                  if(allNodes[s].getStatus() == 0){
                    sort(s, stack, result);
                  }
              }while(index != (s = (++s%size))); //避免依赖index无法到达的节点
    
              return result;
        }
    
        public void sort(int index, Stack<Integer> stack, List<Integer> result ) throws Exception {
              stack.push(index);
              allNodes[index].setStatus(1);
    
              while(!stack.isEmpty()) {
                  int current = stack.peek();
                  Node node = allNodes[current];
    
                  boolean isVisited = true;
                  //寻找所有子节点(如果是邻接表的实现此处可以优化)
                  for(int i=0;i<size;i++) {
                      if(getEdge(current,i)!=null) {
                          switch(allNodes[i].getStatus()) {
                          case 0:
                          //发现下一个节点和支撑树的边
                              stack.push(i);
                                  allNodes[i].setStatus(1);
                              isVisited = false;
                              break;
                          case 1:
                          //发现后向边，存在环路，抛出异常
                              throw new Exception("存在环路，无法排序");
                          case 2:
                              break;
                          }
                      }
                  }
    
                  //标记为已完成
                  if(isVisited) {
                     node.setStatus(2);
                     result.add(current);
                     stack.removeElement(current);
    
                  }
              }
        }

这端代码基于笔者前两篇文章：  
[图的邻接表的实现][Link 2]  
[图的深度优先搜索算法并生成DFS树  
][DFS]

现在使用上述的代码来完成上图的排序

public static void toSort() throws Exception {
    
           AdjacencyList list = new AdjacencyList();
           int aIndex = list.addNode(new adjacencyList.Node<String>("a"));  //索引为0
           int bIndex = list.addNode(new adjacencyList.Node<String>("b"));  //索引为1
           int cIndex = list.addNode(new adjacencyList.Node<String>("c"));  //索引为2
           int dIndex = list.addNode(new adjacencyList.Node<String>("d"));  //索引为3
           int eIndex = list.addNode(new adjacencyList.Node<String>("e"));  //索引为4
           int fIndex = list.addNode(new adjacencyList.Node<String>("f"));  //索引为5
    
    
           adjacencyList.Edge<String> acEdge = new adjacencyList.Edge<String>(cIndex, "这是边a到c的弧", 1);
           adjacencyList.Edge<String> adEdge = new adjacencyList.Edge<String>(dIndex, "这是边a到d的弧",1);
           adjacencyList.Edge<String> bcEdge = new adjacencyList.Edge<String>(cIndex, "这是边b到c的弧",1);
           adjacencyList.Edge<String> cdEdge = new adjacencyList.Edge<String>(dIndex, "这是边c到d的弧",1);
           adjacencyList.Edge<String> cfEdge = new adjacencyList.Edge<String>(fIndex, "这是边c到f的弧",1);
           adjacencyList.Edge<String> ceEdge = new adjacencyList.Edge<String>(eIndex, "这是边c到e的弧",1);
           adjacencyList.Edge<String> efEdge = new adjacencyList.Edge<String>(fIndex, "这是边c到e的弧",1);
    
    
           list.setEdge(aIndex, acEdge);
           list.setEdge(aIndex, adEdge);
           list.setEdge(bIndex, bcEdge);    
           list.setEdge(cIndex, cdEdge);
           list.setEdge(cIndex, ceEdge); 
           list.setEdge(cIndex, cfEdge);
           list.setEdge(eIndex, efEdge);
    
    
           System.out.println(list.toSort());
           //输出[3, 5, 4, 2, 0, 1]
       }

**当如上图A，B或D，F所示，存在多个入度为0或出度为0(极大，极小元素)会导致拓扑排序结果不唯一**

### 复杂度 ###

这里仅额外引入的栈其规模不超过顶点总数 0 (n）。总体而言，空间复杂度与基本的深度优先搜索算法同样，仍为 O (n + e）。该算法的递归跟踪过程与标准 DFS 搜索完全一致，且各递归实例自身的执行时间依然保持为 0 (1），故总体运行时间仍为 O (n + e）。

[Link 1]: http://acm.hdu.edu.cn/showproblem.php?pid=1285
[SouthEast]: /images/20220604/2c675e95afeb401296f0644eeebd7cf6.png
[DFS]: http://blog.csdn.net/canot/article/details/78705704
[Link 2]: http://blog.csdn.net/canot/article/details/78704828