二十一、搜索与图论——拓扑序列（有向图）

一、基本思路

1、概念定义

• 拓扑序列定义：

• • 若一个由图中所有点构成的序列 A满足：对于图中的每条边 (x,y)，x在 A中都出现在 y之前，则称 A是该图的一个拓扑序列。
• • 人话：始终满足每条边的起点在终点前面，从前指向后。

• 

• 注意：如果在有向图中构成一个环，则必定无法构成拓扑结构，也可以证明有向无环图一定存在拓扑序列，即有向无环图=拓扑图

• 入度：对一个节点而言，有多少条边指向自己。

• 出度：对一个节点而言，有多少条边指向外面。

二、拓扑序列模板

• 1. 因为拓扑序列都是从前指向后面的，因此当前入度为0的点都可以当做是起点。
• 2. 入度为0，意味着没有任何一个点在我面前，可以放在最前面的位置。
• 3. 每次遍历完之后，就可以让 入度-1，表示前面指向他的确定了一个，直到为0 ，就可以加入序列，这就代表着后面再也没有指向这个节点的了。

// 伪代码
queue <--- 所有入度为0的点
while(queue 不空){
	t = 队头；
	枚举t的所有出边（t ---> j）{
		j = e[i];
		删掉t ---> j这条边，即入度 d[j]--;
		if (d[j] == 0){			// 此时 j 的入度为了 0 ，则可以放在最前面去了
			queue <--- j;		// 入队
		}
	}
}

拓扑排序 —— 模板题 AcWing 848. 有向图的拓扑序列
时间复杂度 O(n+m)	n 表示点数，m 表示边数
bool topsort()
{
    int hh = 0, tt = -1;

    // d[i] 存储点i的入度
    for (int i = 1; i <= n; i ++ )
        if (!d[i])
            q[ ++ tt] = i;

    while (hh <= tt)
    {
        int t = q[hh ++ ];

        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (-- d[j] == 0)
                q[ ++ tt] = j;
        }
    }

    // 如果所有点都入队了，说明存在拓扑序列；否则不存在拓扑序列。
    return tt == n - 1;
}

• 若存在环，则找不到一个入度为 0 的点，没有突破口，无法入队。一个无环图，一定存在一个入度为0的点。

三、例题题解

// java题解实现
import java.util.*;

public class Main{
    static int N = 100010;
    static int[] e = new int[N];
    static int[] ne = new int[N];
    static int[] h = new int[N];
    static int idx = 0;
    static int hh = 0;
    static int tt = -1;
    static int[] q = new int[N];
    static int[] d = new int[N];                // 表示入度大小，为了后面进行入度逐渐减小做准备
    static int n,m;
    
    static void add(int a, int b){
        e[idx] = b;
        ne[idx] = h[a];
        h[a] = idx++;
    }
    
    static boolean topsort(){
        
        for(int i = 1; i <= n; i++){        // 首先将入度为0的节点加入队列中
            if(d[i] == 0){
                q[++tt] = i;
            }
        }
        
        while(hh <= tt){
            int temp = q[hh++];             // 此处仅仅是对所控制的队列进行了首节点后移
            
            for(int i = h[temp]; i != -1; i = ne[i]){
                int j = e[i];               // 遍历当前队列节点能到达的节点
                d[j] --;                    // 有点指向，那必然不为0，遍历过去之后，就可以排除这个点指向了

                if(d[j] == 0){              // 如果入度后面为0了，说明没有点指向他了
                    q[++tt] = j;             // 入度为0了，后面的遍历没有指向他的了，所以可以加入队列了
                }
            }
        }
        
        return tt == n - 1;                  // 判断是不是队列已经将n个节点存在q中了，因为q从0开始存储的
    }

    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        
        n = in.nextInt();
        m = in.nextInt();
        
        for(int i = 0; i < N; i++){
            h[i] = -1;
            d[i] = 0;
        }
        
        for(int i = 0; i < m; i++){
            int a = in.nextInt();
            int b = in.nextInt();
            add(a, b);
            d[b]++;                         // 有节点指向 b故此需要进行入度+1
        }
        
        if(topsort()){
            for(int i = 0; i < n; i++){
                System.out.print(q[i] + " ");       // 尽管其中的hh指针已经移到后面，但是队列中始终存储着序列
            }
        }else{
            System.out.println("-1");
        }
        
    }
}