拓扑排序 C++

ranyh524

已于 2022-07-24 11:02:41 修改

阅读量992

点赞数

分类专栏：算法随笔文章标签： c++ 算法图论 leetcode

于 2022-03-10 21:21:42 首次发布

本文链接：https://blog.csdn.net/m0_52824954/article/details/123410964

版权

算法随笔专栏收录该内容

14 篇文章 30 订阅

订阅专栏

题目一：课程表：https://leetcode-cn.com/problems/course-schedule/

题目二：有向图的拓扑排序

拓扑排序可用栈或队列实现，本文使用队列实现

预备知识：

有向无环图

如果一个有向图的任意顶点都无法通过一些有向边回到自身，那么称这个有向图为有向无环图。

aov网：

一个AOV网应该是一个有向无环图，即不应该带有回路，因为若带有回路，则回路上的所有活动都无法进行。

拓扑序列：

在AOV网中，若不存在回路，则所有活动可排列成一个线性序列，使得每个活动的所有前驱活动都排在该活动的前面，我们把此序列叫做拓扑序列（不是唯一的）

拓扑排序：

由AOV网构造拓扑序列的过程叫做拓扑排序

算法定义：

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

举例说明：

一个较大的工程往往被划分成许多子工程，我们把这些子工程称作活动(activity)。在整个工程中，有些子工程(活动)必须在其它有关子工程完成之后才能开始，也就是说，一个子工程的开始是以它的所有前序子工程的结束为先决条件的，但有些子工程没有先决条件，可以安排在任何时间开始。为了形象地反映出整个工程中各个子工程(活动)之间的先后关系，可用一个有向图来表示，图中的顶点代表活动(子工程)，图中的有向边代表活动的先后关系，即有向边的起点的活动是终点活动的前序活动，只有当起点活动完成之后，其终点活动才能进行。通常，我们把这种顶点表示活动、边表示活动间先后关系的有向图称做顶点活动网(Activity On Vertex network)，简称AOV网。

算法步骤：

(1) 选择一个入度为0的顶点并输出之；

(2) 从网中删除此顶点及所有出边。

循环结束后，若输出的顶点数小于网中的顶点数，则输出“有回路”信息，否则输出的顶点序列就是一种拓扑序列。

注意：这里得到的排序并不是唯一的！就好像你早上穿衣服可以先穿上衣也可以先穿裤子，只要里面的衣服在外面的衣服之前穿就行。

拓扑排序一般用于有依赖关系的对象或事物

算法模板一：

void tp_sort(int  num（节点数量）,vector<vector<int>>&arr(邻接矩阵)){
//以下一到三步根据实际题目，但一般实际中会给出邻接矩阵，代码实现时使用邻接表容易实现
    //第一步，建立邻接表
    vector<vector<int> > edge(num);
    //第二步，建立一个结点入度的数组
    vector<int> indeg(num);
    //第三步，将数据存入邻接表，并将所有结点入度存入数组
    for(auto info[]: arr){
        edge[info[1]].push_back(info[0]);//此处0和1根据题目要求决定依赖的先后关系
        indeg[info[0]]++;
    }
    //第四步，将入度为一的点加入队列
    queue<int> qu;
    for(int i=0;i<indeg.size();i++){
        if(indeg[i]==0)
            qu.push(i);

    }
    //第五步，若结点入度为0就出队列
    int count=0;
    while(!qu.empty()){
        count++;
        int v = qu.front();
        qu.pop();
        for(auto v: edge[v]){
            indeg[v]--;
            if(indeg[v]==0) qu.push(v);

        }

    }    
    return count==num;//最后如果输出的节点数==总结点数，说明无环
}

算法模板二（更简洁实用）：

//实用邻接表存储（头插法）
void add(int a,int b)
{
    e[idx]=b;
    ne[idx]=h[a];
    h[a]=idx++;
}
//q是自己维护的队列
bool topsort()
{
    int hh=0,tt=-1;//hh队列头，tt队列尾
    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];
            d[j]--;//d[j]是点j的入度，即由t指向j，删除点t指向点j的边
            if(d[j]==0)//如果点j的入度为零了,就将点j入队
            q[++tt]=j;//入队列操作
        }
    }
    return tt==n-1;
    //表示如果n个点都入队了话,那么该图为拓扑图,返回true,否则返回false
}

题目一：课程表：https://leetcode-cn.com/problems/course-schedule/

在拓扑排序的过程结束后，如果答案中包含了这 n 个节点，那么我们就找到了一种拓扑排序，否则说明图中存在环，也就不存在拓扑排序了。（此题更详细的解看官方解答）

代码如下：

bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        int len = prerequisites.size();
        //第一步，建立一个邻接表
        vector<vector<int> > edge(numCourses);
        //edges.resize(numCourses);
        //第二步，建立一个节点的入度数组
        vector<int> indeg(numCourses);
        //第三步，将所有变的信息存入邻接表，并计算所有节点入度
        for(int i=0;i<len;i++){
            edge[prerequisites[i][1]].push_back(prerequisites[i][0]);
            ++indeg[prerequisites[i][0]];
        }
        // for (const auto& info : prerequisites) {
        //     edges[info[1]].push_back(info[0]);
        //     ++indeg[info[0]];
        // }

        //第四步，找出入度为0的结点并将其加入队列
        queue<int> qu;
        for(int i=0;i<indeg.size();i++){
            if(indeg[i]==0)
                qu.push(i);
        }
        //第五步，将其结点遍历输出最后判断输出的结点数量是否等于节点总数
        int count=0;
        while(!qu.empty()){
            int u = qu.front();
            qu.pop();
            count++;
            //判断无入度的结点u有几个相邻结点，并将其入度减一
            for(int j=0;j<edge[u].size();j++){
                --indeg[edge[u][j]];
                if(indeg[edge[u][j]]==0) qu.push(edge[u][j]);               
            }
            // for (int v : edges[u]) {
            //     --indeg[v];
            //     if (indeg[v] == 0) {
            //         q.push(v);
            //     }
            // }
        }
    return count==numCourses;
    }

题目二：有向图的拓扑排序

https://www.acwing.com/problem/content/850/

代码如下：

#include<bits/stdc++.h>
using namespace std;

const int N = 100010;

int n, m;
int h[N], e[N], ne[N], idx;
int d[N];
int q[N];

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 ++ )
        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;
}

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
    }

    if (!topsort()) puts("-1");
    else
    {
        for (int i = 0; i < n; i ++ ) printf("%d ", q[i]);
        puts("");
    }

    return 0;
}