图论--拓扑排序及其应用

在工程实践中,一个工程项目往往由若干个子项⽬目组成。这些子项目间往往有两种关系:

1  先后关系,即必须在某个项 ⽬完成后才能开始实施另一个子项目;

2  子项⽬目间无关系,即两个子项目可以同时进行,互不影响。

工厂里产品的生 产线上,一个产品由若干个零部件组成。零部件生产时,也存在这两种关系:先后关系,即一个部件必须在完成后才能生 产另一个部件;部件间无先后关系,即这两个部件可以同时生产。

大学里某个专业的课程学习,有些课程是基础课,它们 可独立于其他课程,即无前导课程;有些课程必须在某些基础看成是一个个顶点,课程的学习分别构成一个有向图,现在 要从这些有向图上分别找出的实施,产品的生产,课程的学习分别构成一个有向图,现在要从这些有向图上分别找出一个 施工流程图、产品生产流程图、课程学习流程图,以便顺利进行施工、产品生产和课程学习,解决这个问题可以采用拓扑 排序的方法。 设G=(V,E)是一个具有n个顶点的有向图,V中顶点的序列V1,V2,Vn称为⼀拓扑序列,当且仅当该顶点序列 满⾜足下列条件:若在有向图G中,从顶点Vi到是j有一条路径,则在序列中顶点必须排在顶点V之前找一个有向图的一个拓扑序列的过程称为拓扑排序。

假定计算机软件专业的课程之间存在下述关系: 

课程代号              课程名称                    前导课程

C1                       ⾼高等数学                  无

C2                       程序设计语⾔言           无

C3                       数据结构                     C2


C4                       编译原理                     C2,C3


C5                       操作系统                     C3,C6


C6                       计算机组成原理           C7


C7                       普通物理                     C1

课程之间的先后关系可⽤用有向图表⽰示,如图所示。


对这个有向图进⾏行拓扑排序可得到⼀一个拓扑序列:C1,C2,C7,C6,C3,C4,C5。也可得到另⼀一个拓扑序列C1, C7,C2,C3,C6,C4,C5。学⽣生按照任何⼀一个拓扑序列都可以顺利地进⾏行课程学习。下⾯面给出有向图拓扑排序算法的基本步骤:

1 从图中选择⼀一个⼊入度为0的顶点,输出该顶点;

2 从图中删除该顶点及其相关联的弧;

3 重复执⾏行1、2直到所有顶点均被输出,拓扑排序完成或者图中再也没有⼊入度为0的顶点(此种情况说明原有向图含有环)。 可以证明,任何一个无环有向图,其全部顶点都可以排成一个拓扑序列。而且其拓扑序列不一定是唯一的。 下⾯以下图为例说明拓扑排序过程。

  

                      

  (a)邻接表                                                                                                   (b)有向图  


首先C1、C4的入度都为0,选C1,删除C1及其边e1、e2,调整C2的⼊入度为0,C3的⼊入度为1,此时C2、C4的⼊入度为0 ,选C4,删除C4及边e3、e4,调整C3、C5的⼊入度为0,从C2、C5、C3中选C2,删除C2及边e,调整C6的⼊入度为2,从C3 、C5中选择C3,删除C3及边e6,调整C6的⼊入度为1,删除C5及边e7,调整C6的⼊入度为0,输出C6,⾄至此拓扑排完成,拓 扑序列为C1,C4,C2,C3,C5,C6。

这里拓扑排序给出两种方法:

1: 以邻接表作存储结构,给出拓扑排序的实现。算法设置一个队列(方便使用优先队列,输出相同条件下结点编号小的在前(后)的序列),将所有⼊入度为0的顶点入该队。找入度为0的 顶点,只要从依次出队即可。删除边的操作转化为将为该顶点为弧尾,所有相应弧头的入度减1。

2:类似于dfs   用一个栈来存排序后的顺序,从一个顶点开始访问,依次访问它的邻接顶点,回溯的时候将当前结点压入栈(度为0的顶点一定是最后压入栈的)

下面以poj 2376为例

输入n 表示n个结点;

从第一个结点开始依次输入该结点的邻接结点,输入0表示改结点的邻接结点结束,开始输入下一个结点的邻接结点。

#include <iostream>
#include <stdio.h>
#include <queue>
#include <stack>
#include <string.h>
using namespace std;
struct node
{
    int v;
    int next;
}e[505];
int head[505];  //邻接表头
int indegree[505],n,m; //顶点入度统计数组
bool vis[505];
stack<int>s;
void topologicalSort1()
{
    queue<int>q;
    for (int i=1; i<=n; i++)
    {
        if(indegree[i]==0)
        {
            q.push(i);
        }
    }
    bool flag=false;
    while (!q.empty())
    {
        int t;
        t=q.front();
        q.pop();
        if(flag)
        {
            printf(" %d",t);
        }
        else
            
        {
            printf("%d",t);
            flag=true;
        }
        
        for (int i=head[t]; i!=-1; i=e[i].next)
        {
            indegree[e[i].v]--;
            if(indegree[e[i].v]==0)
            {
                q.push(e[i].v);
            }
        }
    }
    printf("\n");

}
void dfs(int u)
{
    vis[u]=true;
    for (int i=head[u]; i!=-1; i=e[i].next)  //尝试访问结点u的邻接结点
    {
        if(!vis[e[i].v])
        {
            dfs(e[i].v);
        }
    }
    s.push(u);  //在递归出口加入此结点
}
void topologicalSort2()
{
    memset(vis, false, sizeof(vis));
    while (!s.empty())
    {
        s.pop();
    }
    for (int i=1; i<=n; i++)  //尝试访问每一个结点
    {
        if(!vis[i])
        {
            dfs(i);
        }
    }
    int ans=1;
    while (!s.empty())  //输出序列
    {
        if(ans<n)
        {
            printf("%d ",s.top());
        }
        else
        {
            printf("%d\n",s.top());
        }
        s.pop();
    }
}
int main()
{
    while (scanf("%d",&n)!=EOF)
    {
        
        memset(indegree, 0, sizeof(indegree));
        memset(head, -1, sizeof(head));
        int v;
        int cnt=0;

        for (int i=1; i<=n; i++)
        {
            while (scanf("%d",&v) && v)
            {
                //创建邻接表
                e[cnt].v=v;
                e[cnt].next=head[i];
                head[i]=cnt++;
                indegree[v]++;
            }
        }
        topologicalSort2();
    }
    return 0;
}

如果只是判断环是否存在那就更简单了,用dfs或者并查集都可以

//拓扑排序判环
#include <iostream>
#include <queue>
#include <string.h>
using namespace std;
#define MAX 100001
int head[MAX];  // 表示头指针,初始化为-1
int p[5*MAX];   // 表示指向的节点
int Next[5*MAX]; // 模拟指针,初始化为0
int n,m,u,v;
int vis[MAX];   //记录遍历的状态
bool flag;
bool dfs(int u)
{
    vis[u]=-1;  //正在访问,在递归栈中
    for (int i=head[u]; i!=-1 && !flag; i=Next[i])
    {
        v=p[i];
        if (vis[v]==-1)
        {
            flag=true;
            return flag;
        }
        if (vis[v]==0) //没有访问过
        {
            vis[v]=-1;
            dfs(v);
        }
        vis[v]=1; //访问结束
    }
    vis[u]=1;
    return flag;
}
int main()
{
    int t,cnt;
    scanf("%d",&t);
    while (t--)
    {
        cnt=0;
        memset(head, -1, sizeof(head));
        memset(vis, 0, sizeof(vis));
        flag=false;
        scanf("%d%d",&n,&m);
        for (int i=0; i<m; i++)
        {
            scanf("%d%d",&u,&v);
            p[cnt]=v;
            Next[cnt]=head[u];
            head[u]=cnt++;
        }
        
        for (int i=1; i<=n && !flag; i++) //遍历所有的点
        {
            if (vis[i]==0)
            {
                dfs(i);
            }
        }
        if (!flag)
            printf("Correct\n");
        else
            printf("Wrong\n");
    }
    return 0;
}

应用:

描述

小Hi和小Ho所在学校的校园网被黑客入侵并投放了病毒。这事在校内BBS上立刻引起了大家的讨论,当然小Hi和小Ho也参与到了其中。从大家各自了解的情况中,小Hi和小Ho整理得到了以下的信息:

  • 校园网主干是由N个节点(编号1..N)组成,这些节点之间有一些单向的网路连接。若存在一条网路连接(u,v)链接了节点u和节点v,则节点u可以向节点v发送信息,但是节点v不能通过该链接向节点u发送信息。
  • 在刚感染病毒时,校园网立刻切断了一些网络链接,恰好使得剩下网络连接不存在环,避免了节点被反复感染。也就是说从节点i扩散出的病毒,一定不会再回到节点i。
  • 当1个病毒感染了节点后,它并不会检查这个节点是否被感染,而是直接将自身的拷贝向所有邻居节点发送,它自身则会留在当前节点。所以一个节点有可能存在多个病毒。
  • 现在已经知道黑客在一开始在K个节点上分别投放了一个病毒。

举个例子,假设切断部分网络连接后学校网络如下图所示,由4个节点和4条链接构成。最开始只有节点1上有病毒。

最开始节点1向节点2和节点3传送了病毒,自身留有1个病毒:

其中一个病毒到达节点2后,向节点3传送了一个病毒。另一个到达节点3的病毒向节点4发送自己的拷贝:

当从节点2传送到节点3的病毒到达之后,该病毒又发送了一份自己的拷贝向节点4。此时节点3上留有2个病毒:

最后每个节点上的病毒为:

小Hi和小Ho根据目前的情况发现一段时间之后,所有的节点病毒数量一定不会再发生变化。那么对于整个网络来说,最后会有多少个病毒呢?

输入

第1行:3个整数N,M,K,1≤K≤N≤100,000,1≤M≤500,000

第2行:K个整数A[i],A[i]表示黑客在节点A[i]上放了1个病毒。1≤A[i]≤N

第3..M+2行:每行2个整数 u,v,表示存在一条从节点u到节点v的网络链接。数据保证为无环图。1≤u,v≤N

输出

第1行:1个整数,表示最后整个网络的病毒数量 MOD 142857

样例输入
4 4 1
1
1 2
1 3
2 3
3 4
样例输出
6


小Hi:对于这个问题小Ho你有什么想法么?

小Ho:有,对于一个病毒来说它总会传递到一个没有邻居的节点,那我直接使用dfs模拟整个过程不就能够得到结果了吗?

小Hi:小Ho你真聪明,立刻就看穿了这个问题的本质。

小Ho:那当然啦。<得意>

小Hi:那么小Ho,我这里有这样一个网络:

这里一共有n个节点,对于节点i,它总是连接着节点i+1和节点i+2。一开始只有节点1被感染,你算算最后n个节点一共有多少个病毒?

小Ho:很显然,节点1最后只有1个病毒;节点2也只有1个病毒;节点3会接受从节点1和节点2过来的病毒,所以有2个病毒;后面依次是节点4有3个病毒,节点5有5个病毒…它们好像刚好是费波拉契数列?

小Hi:你说的没错。对于这个网络,编号为i的节点最后感染的病毒数量就是斐波拉契数列的第i项。而斐波拉契数列的增长是很惊人的,当i到达一定值时,其电脑感染的病毒数量就会很大了。

小Ho:那这又有什么关系呢?反正能得到解不是么?

小Hi:能得到解那是当然了,但是你有想过需要花费多少时间么?在你的dfs算法中,每一次进入函数就等于模拟一个病毒进入电脑。如果最后结果有10亿个病毒,那么你就需要执行10亿次函数,假设电脑每秒钟可以执行1亿次函数,那么你的dfs就需要运行10秒。如果结果有100亿,1000亿呢?

小Ho:运行时间上好像是有问题,那我应该如何解决时间的问题呢?

小Hi:其实也很简单啦。你再想想,在我们最后得到结果上每各节点病毒数量有什么关系么?

小Ho:嗯<思考>…我发现了!对于节点i来说,它最后的病毒数好像总是等于所有能够达到它的节点病毒数之和。就用你提到的那个斐波拉契数列来说,能够达到节点i的节点是节点i-1和节点i-2,所以节点i的病毒数是节点i-1和节点i-2的病毒数之和。这刚好就是斐波拉契数列的递推公式嘛!

小Hi:对,正是这样。对于一个节点i来说,如果我们能够先计算出它所有前驱节点的病毒数量,就可以直接推算出它最后的病毒数量了。

小Ho:但是怎么来计算所有前驱节点呢?

小Hi:这就要从图的性质入手了。我们现在的网络是没有环的,对于任意一个节点i,当它将自己所有的病毒都传送出去之后,它自身的病毒数量就不会改变了。那么我们不妨从没有前驱节点,也就是入度为0的节点开始考虑。

对于这些节点,它并不会再增加病毒数量。那么我们就根据它所关联的连接将病毒分发出去,然后这个节点就没有作用了。那不妨就删掉好了,它所关联的边也删掉。

这样图中又会产生一些新的没有入度的节点。这样一直删点,直到所有的点都被删掉,将所有点的病毒数量加起来不就是总的病毒数么?

我们不妨来看个例子,这里给定一个网络:

最开始只有节点1是入度为0的点,所以将它的病毒传送,然后删掉节点1:

此时节点2成为了入度为0的点,同样将其删掉:

此时节点3为入度为0的点,同样操作:

最后只剩下节点4,因为它并没有后续节点,所以病毒感染的过程也就结束了。

小Ho:这不就是拓扑排序么!因为拓扑排序可以在O(n+m)的时间解决,整个问题的时间也减少到了O(n+m),那么再多的节点数都不怕了!

小Hi:没错,这样我们就完美地解决了这个问题。你能实现它么?

小Ho:没问题,就交给我吧!<自信>

说得很明白了吧

#include <iostream>
#include <queue>
#include <string.h>
using namespace std;
#define MAX 100001
int head[MAX];  // 表示头指针,初始化为-1
int p[5*MAX];   // 表示指向的节点
int Next[5*MAX];  // 模拟指针,初始化为0
int inDeg[MAX]; //各节点的入度
int ans[MAX];
int n,m,u,v;
void topoSort()
{
    queue<int>q;
    for (int i=1; i<=n; i++)
    {
        if (inDeg[i]==0)
        {
            q.push(i);
        }
    }
    while (!q.empty())
    {
        u=q.front();
        q.pop();
        for (int i=head[u]; i!=-1; i=Next[i])
        {
            v=p[i];
            inDeg[v]--;
            ans[v]+=ans[u];  //这里
            ans[v]%=142857;
            if (inDeg[v]==0)
            {
                q.push(v);
            }
        }
        
    }
}
int main()
{
    int cnt,k;
    
    cnt=0;
        
        
    scanf("%d%d%d",&n,&m,&k);
    for (int i=0;i<=n; i++)  //初始化
    {
        head[i]=-1;
        inDeg[i]=0;
        ans[i]=0;
    }
    int x;
    for (int i=0; i<k; i++)
    {
        scanf("%d",&x);
        ans[x]=1;
    }
    for (int i=0; i<m; i++)
    {
        scanf("%d%d",&u,&v);
        //添加边的信息
        p[cnt]=v;
        Next[cnt]=head[u];
        head[u]=cnt++;
        inDeg[v]++;
    }
    topoSort();
    int ans1=0;
    for (int i=1; i<=n; i++)
    {
        ans1=(ans1+ans[i])%142857;
    }
    printf("%d\n",ans1);
    return 0;
}



  • 2
    点赞
  • 0
    评论
  • 11
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

打赏
文章很值,打赏犒劳作者一下
相关推荐
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页

打赏

zthgreat

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者