拓扑排序

1.什么是拓扑排序

在图论中，拓扑排序（Topological Sorting）是一个有向无环图（DAG, Directed Acyclic Graph）的所有顶点的线性序列。且该序列必须满足下面两个条件：

1.每个顶点出现且只出现一次。
2.若存在一条从顶点 A 到顶点 B 的路径，那么在序列中顶点 A 出现在顶点 B 的前面。
有向无环图（DAG）才有拓扑排序，非DAG图没有拓扑排序一说。

例如，下面这个图：

拓扑排序通常用来“排序”具有依赖关系的任务。比如，如果用一个DAG图来表示一个工程，其中每个顶点表示工程中的一个任务，用有向边 表示在做任务 B 之前必须先完成任务 A。故在这个工程中，任意两个任务要么具有确定的先后关系，要么是没有关系，绝对不存在互相矛盾的关系（即环路）。

2.拓扑排序的实现

1.从 DAG 图中选择一个 没有前驱（即入度为0）的顶点并输出。
2.从图中删除该顶点和所有以它为起点的有向边。
3.重复 1 和 2 直到当前的 DAG 图为空或当前图中不存在无前驱的顶点为止。后一种情况说明有向图中必然存在环。

于是，得到拓扑排序后的结果是 { 1, 2, 4, 3, 5 }。

通常，一个有向无环图可以有一个或多个拓扑排序序列。

3.拓扑排序的应用

• 洛谷P1113
  基本思路：开数组记录节点结束与开始时间，用队列维护入度为0的节点，入队列前不断更新节点开始时间，出队列时更新节点结束时间，排序后选数组最大值输出。
  c++参考代码：

#include <bits/stdc++.h>
using namespace std;
const int maxn=1e5+7;
int n,ans,t[maxn],e[maxn],ru[maxn];
vector<int> v[maxn];

void tuopu(){
    queue<int> q;
    for(int i=1;i<=n;i++){
        if(!ru[i]){
            q.push(i);
        }
    }
    while (!q.empty())
    {
        int x=q.front();
        q.pop();
        e[x]+=t[x];
        ans=max(ans,e[x]);
        for(int i=0;i<v[x].size();i++){
            int y=v[x][i];
            ru[y]--;
            e[y]=max(e[y],e[x]);
            if(!ru[y]){
                q.push(y);
            }
        }
    }
    
}

int main(){
    cin>>n;
    for(int i=1;i<=n;i++){
        int x,y,z;
        cin>>x>>y;
        t[x]=y;
        while (cin>>z&&z)
        {
           v[z].push_back(x);
           ru[x]++;
        }
        
    }
    tuopu();
    cout<<ans;
    return 0;
}

• 洛谷P1983
  基本思路：先可以确定某些车站两两之间的大小关系，将这些可以确定大小关系的车站，由等级低的车站向等级高的车站连一条边，然后利用拓扑排序，满足这些关系。在拓扑排序的过程中，做一个简单的递推就可以得出每个车站的等级，从而得出不同等级的数量。
  c++参考代码：

#include <bits/stdc++.h>
using namespace std;
const int maxn=1010;
#define P pair<int,int>
int n,m,ans=1,a[maxn],b[maxn][maxn],v[maxn][maxn],vis[maxn],c[maxn];
vector<int> vec[maxn];

void tuopu(){
    queue<P> q;
    for(int i=1;i<=n;i++){
        if(!c[i]){
            q.push({i,1});
        }
    }
    while(!q.empty()){
        int x=q.front().first,y=q.front().second;
        q.pop();
        for(int i=0;i<vec[x].size();i++){
            int z=vec[x][i];
            c[z]--;
            if(!c[z]){
                q.push({z,y+1});
                ans=max(ans,y+1);
            }
        }
    }
}

int main(){
    cin>>n>>m;
    for(int i=1;i<=m;i++){
        memset(vis,0,sizeof(vis));
        cin>>a[i];
        for(int j=1;j<=a[i];j++){
            int x;
            cin>>x;
            b[i][j]=x;
            vis[x]=1;
        }
        for(int j=b[i][1];j<=b[i][a[i]];j++){
            if(!vis[j]){
                for(int k=1;k<=a[i];k++){
                    if(!v[j][b[i][k]]){
                        vec[j].push_back(b[i][k]);
                        c[b[i][k]]++;
                        v[j][b[i][k]]=1;
                    }
                }
            }
        }
    }
    tuopu();
    cout<<ans;
    return 0;
}

如果想要得到更多知识，请关注我博客：wlis.blog.csdn.net

此博客不定期更新内容！！！感谢大家！！！