拓扑排序

最新推荐文章于 2024-06-04 13:22:04 发布

原创最新推荐文章于 2024-06-04 13:22:04 发布 · 176 阅读

0 ·

CC 4.0 BY-SA版权

图论专栏收录该内容

7 篇文章

订阅专栏

本文深入探讨了拓扑排序算法，包括其定义、实现原理及应用案例。从有向无环图的基本概念出发，介绍了拓扑排序的具体步骤，并通过示例代码展示了如何在实际中运用这一算法解决差分约束问题和求解有向图中各节点可达点数量的问题。

拓扑图即为有向无环图

拓扑序满足对于任何有子节点的节点来说，该节点的子节点在该节点的后面

拓扑排序

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

const int N = 110, M = N * N;

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

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

void topdfs(){
    int hh = 0, tt = -1;
    
    for(int i = 1;i <= n;i ++)
        if(!d[i])
            q[ ++ tt] = i;
    
    while(hh <= tt){
        int u = q[hh ++];
        
        for(int i = h[u] ; ~i ; i = ne[i]){
            int j = e[i];
            
            if( (-- d[j]) == 0 ){
                q[ ++ tt] = j;
            }
        }
    }
}

int main(){
    scanf("%d",&n);
    
    memset(h, -1, sizeof h);
    
    for(int i = 1;i <= n;i ++){
        int t;
        while(scanf("%d",&t), t){
            add(i, t);
            d[t] ++;
        }
    }
    
    topdfs();
    
    for(int i = 0;i < n;i ++) printf("%d ",q[i]);
    
    return 0;
}

差分约束

这是一个差分约束的题，题目要求每个人的初始化为100，然后输入m条边
b 到 a 权值为 1 的边，求最小值，那么就是最长路

每条边的权值都为 1 直接用拓扑排序就行了

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

const int N = 10010, M = 20020;

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

int 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 u = q[hh ++];
        for(int i = h[u]; ~i ; i = ne[i]){
            int j = e[i];
            if(( -- d[j]) == 0)
                q[ ++ tt] = j;
        }
    }
    
    if(tt == n - 1)
        return true;
    return false;
}

int main(){
    memset(h, -1, sizeof h);
    scanf("%d%d", &n, &m);
    for(int i = 0;i < m;i ++){
        int a, b;
        scanf("%d%d", &a, &b);
        add(b, a);
        d[a] ++;
    }
    
    if(topsort()){
        int all = 0;
        for(int i = 1;i <= n;i ++)
            dist[i] = 100;
            
        for(int i = 0;i < n;i ++){
            int j = q[i];
            for(int k = h[j];~k;k = ne[k]){
                dist[e[k]] = max(dist[e[k]], dist[j] + 1);
            }
        }
        for(int i = 1;i <= n;i ++) all += dist[i];
        printf("%d\n",all);
    }
    else
        puts("Poor Xed");
    return 0;
}

bitset + topsort

该题给出一个有向无环图，然后求所有点可以到达的点的个数

在这里插入图片描述
比如对于任意一个节点u来说
u节点直接可以到达的点为1，2，3，4
然后1，2，3，4，还连着其他的边

并查集可以合并，但是无法求出一个树内的节点个位

如果对于每一个节点来说，都进行一边搜索的话，复杂度太高了

N M 都是30000，N*M的话就是9e8的数量级，基本要做到线性的遍历完所有的边和点就完成了操作

就得想一种可以压缩的方法，把u节点连接的点是u本身并上1并上2并上3并上4，而且还得是线性的

那就是用二进制去存储，二进制的每一位的01值为对应位置的节点是否被该节点连通，

那么u = u | 1 | 2 | 3 | 4 了，这几个值并在一起就行了

bitset有点像二维数组，

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <bitset>
using namespace std;

const int N = 30030, M = 30030;

int n, m;
int h[N], ne[M], e[M], idx;
int d[N], q[N];
bitset <N> f[N];

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

void topsort(){
    int hh = 0, tt = -1;
    for(int i = 1;i <= n;i ++)
        if(!d[i])
            q[++ tt] = i;
    
    while(hh <= tt){
        int u = q[hh ++];
        for(int i = h[u]; ~i; i = ne[i]){
            int j = e[i];
            if(-- d[j] == 0)
                q[ ++ tt] = j;
        }
    }
    return ;
}

int main(){
    memset(h, -1, sizeof h);
    scanf("%d%d", &n, &m);
    while(m --){
        int a, b;
        scanf("%d%d", &a, &b);
        add(a, b);
        d[b] ++;
    }
    
    topsort();

    for(int i = n - 1 ; i >= 0;i --){
        int j = q[i];
        f[j][j] = 1;
        for(int k = h[j];~k;k = ne[k]){
            f[j] |= f[e[k]];
        }
    }
    for(int i = 1;i <=n ;i ++)
        printf("%d\n",f[i].count());
}