【55. 拓扑排序】

思路

• 拓扑序列是针对有向图来说，无向图没有拓扑序列

前置知识

拓扑排序

• 一个有向图，如果图中有入度为 0 的点，就把这个点删掉，同时也删掉这个点所连的边。
• 一直进行上面出处理，如果所有点都能被删掉，则这个图可以进行拓扑排序。
• 对于每条边起点都在终点的前面，组成的就是拓扑排序（当把一个图按照拓扑排好以后，它所有的边都是从前指向后的）
• 一个有向无环图，一定存在一个入度为0的点

入度和出度

• A的入度为 0，所以删除A和A上所连的边，结果如下图：

• 这时发现B的入度为 0，C的入度为 0，所以删除B和B上所连的边、C和C上所连的边，结果如下图：
  
• 这时发现发现D的入度为 0，所以删除D和D上所连的边(如果有就删)，结果就全没了

环

• 因为突破口是入度为0的点，而环当中没有入度为0的点，所以环上的每个点都不会入队
• 只要是环的话，就没有拓扑序。

求解

1. 将所有入度为0的点入队（所有入度为0的点，都可以作为起点）—> 突破口
2. 宽搜，只要队列不为空，每一次都取出队头
3. 枚举t的所有的出边t->j
4. 删掉t->j（因为此时t是最前面的，所以可以将这个限制删除，而此时删掉这条边，唯一影响的就是j的入度）
5. j的入度减1（d[j] --）
6. d[j] = 0，意味着，j前面的所有点都已经排好序了。
7. j入度（此时j没有任何限制，j就可以放到前面了）
   

queue

• 可以换成其他任意集合，但是一般宽度优先遍历，就是用queue存储的

邻接表

• 使用邻接表来存储图的边。

题目

代码

代码1（手写队列）：

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int N = 100010;
int n, m; 
int h[N], e[N], ne[N], idx;       //用邻接表存储图的边
int q[N],  d[N];               //q表示队列，d表示入度

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}

bool topsort()
{
    //手写队列
    int hh = 0, tt = -1;          //队头和队尾
    for (int i = 1; i <= n; i ++) //将所有入度为0的点插入队列中
    {
        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];          //找到出边
            d[j] --;
            if (d[j] == 0) q[++ tt] = j;
        }
    }
    
    //判断是不是所有点都入队
    return tt == n - 1;             //队列中一共进入n个点
    
}

int main()
{
    scanf("%d%d", &n, &m);
    memset(h, -1, sizeof(h));      //初始化
     
    for (int i = 0; i < m; i ++)   //输入题目的数据
    {
        int a, b;
        scanf("%d%d", &a, &b);
        add(a, b);                 //使用邻接表存储边
        d[b] ++;                   //在插入边时，插入一条a->b的边，则b的入度点＋1
    }
    
    //拓扑排序,存在就输出，不存在输出-1
    if (topsort())
    {
        //存在拓扑序，则队列里面的次序就是拓扑序
        for (int i = 0; i < n; i++) cout << q[i] << " " ;
    }
    else cout << "-1" <<endl;
    
    return 0;
}

代码2（STL库）：

#include <iostream>
#include <algorithm>
#include <cstring>
#include <queue>
using namespace std;

const int N = 100010;
int n, m; 
int h[N], e[N], ne[N], idx;       //用邻接表存储图的边
int d[N];                         //d表示入度

int cnt; int tupo[N];            //tupo代表拓扑序，cnt代表tupo有多少个元素
void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}

bool topsort()
{
   
    queue<int> p; 
    for (int i = 1; i <= n; i ++) //将所有入度为0的点插入队列中
    {
        if(!d[i])
            p.push(i); 
    }
    while (!p.empty())              //队列不为空
    {
        int t = p.front();         //取出队头元素
      
        tupo[cnt] = t;             //加入到拓扑序中
        cnt ++;
        p.pop();
        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];          //找到出边
            d[j] --;
            if (d[j] == 0) p.push(j);
        }
    }
    
    //判断是不是所有点都入队
   if (cnt < n) return 0;
   else return 1;
    
}

int main()
{
    scanf("%d%d", &n, &m);
    memset(h, -1, sizeof(h));      //初始化
     
    for (int i = 0; i < m; i ++)   //输入题目的数据
    {
        int a, b;
        scanf("%d%d", &a, &b);
        add(a, b);                 //使用邻接表存储边
        d[b] ++;                   //在插入边时，插入一条a->b的边，则b的入度点＋1
    }
    
    //拓扑排序,存在就输出，不存在输出-1
    if (topsort())
    {
        //存在拓扑序，则队列里面的次序就是拓扑序
        for (int i = 0; i < n; i++) cout << tupo[i] << " " ;
    }
    else cout << "-1" <<endl;
    
    return 0;
}

区别

• 使用STL和手写队列主要是手写队列，他并没有真正的删除元素，而是靠指针的移动代替删除，所以最后直接输出该数组就是已经排好序的拓扑排序
• 而使用STL是真实把数据删除，因此需要创建一个数组，将队列中删除的元素在放进去，此时遍历该数组，也可以得到拓扑排序