拓扑排序

于 2016-07-11 20:50:25 发布
阅读量253 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： ###### 图与流 ######
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_32944513/article/details/51883899
本文介绍了一个工程项目中子任务调度合理性的判断方法。通过三种不同的算法实现：数组存储法、链表存储法及改进的深度优先搜索算法。这些方法用于检测是否存在任务间的循环依赖，从而确定给定的任务调度方案是否可行。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

5-34 任务调度的合理性   (25分)
假定一个工程项目由一组子任务构成，子 任务之间有的可以并行执行，有的必须在完成了其它一些子任务后才能执行。“任务调度”包括一组子任务、以及每个子任务可以执行所依赖的子任务集。

比如完成一个专业的所有课程学习和毕业设计可以看成一个本科生要完成的一项工程，各门课程可以看成是子任务。有些课程可以同时开设，比如英语和C程序设计，它们没有必须先修哪门的约束；有些课程则不可以同时开设，因为它们有先后的依赖关系，比如C程序设计和数据结构两门课，必须先学习前者。

但是需要注意的是，对一组子任务，并不是任意的任务调度都是一个可行的方案。比如方案中存在“子任务A依赖于子任务B，子任务B依赖于子任务C，子任务C又依赖于子任务A”，那么这三个任务哪个都不能先执行，这就是一个不可行的方案。你现在的工作是写程序判定任何一个给定的任务调度是否可行。

输入格式:

输入说明：输入第一行给出子任务数NNN（≤100\le 100≤100），子任务按1~NNN编号。随后NNN行，每行给出一个子任务的依赖集合：首先给出依赖集合中的子任务数KKK，随后给出KKK个子任务编号，整数之间都用空格分隔。

输出格式:

如果方案可行，则输出1，否则输出0。

输入样例1:

12
0
0
2 1 2
0
1 4
1 5
2 3 6
1 3
2 7 8
1 7
1 10
1 7
输出样例1:

1
输入样例2:

5
1 4
2 1 4
2 2 5
1 3
0
输出样例2:

0
************/


 方法一：效率低，耗时。
     1）数组存法：
#include <iostream>
#include<string.h>
using namespace std;
int R_store[105][105],C_store[105][105],N,K;
int main()
{
    int Mark[105];
    memset(C_store,0,sizeof(C_store));
    memset(Mark,0,sizeof(Mark));
    cin>>N;
    for(int i=1;i<=N;i++)
    {
        int M;
        cin>>K;
        R_store[i][0]=K;
        for(int r=1;r<=K;r++)
        {
            cin>>M;
            R_store[i][r]=M;
            int J=C_store[M][0]+1;
            C_store[M][0]=C_store[M][0]+1;
            C_store[M][J]=i;
        }
    }
    int t;
    for( t=1;t<=N;t++)
    {
        int V=-1;
        for(int r=1;r<=N;r++)
        {
            if (!Mark[r]&&R_store[r][0]==0)//标记可以不用Mark，可以把stor[r][0]=-1;
            {
               // cout<<r<<"  r"<<endl;
                V=r;
                Mark[r]=1;
                break;
            }
        }
        if(V==-1)
            break;
        for(int r=1;r<=C_store[V][0];r++)
        {
            int U=C_store[V][r];
            R_store[U][0]=R_store[U][0]-1;
        }
    }
    if(t<N)
        cout<<"0"<<endl;
    else
        cout<<"1"<<endl;
    return 0;
}

  2）链表法：
#include <iostream>
#include<stdio.h>
#include<stdlib.h>
#include<queue>
#include<string.h>
using namespace std;
struct C_vexstruct
{
    int data;
    C_vexstruct *next;
};
struct Vexstruct
{
    int data;
    C_vexstruct *head;
};
Vexstruct Vex[105];
int N,A[105],top[105];
void insert_C(int I,int M)
{
    C_vexstruct *D=(C_vexstruct*)malloc(sizeof(C_vexstruct));
    D->data=M;
    D->next=NULL;
    if(Vex[I].head)
    {
        C_vexstruct *last;
        last=Vex[I].head;
        while(last->next)
        {
            last=last->next;
        }
        last->next=D;
    }
    else
    {
        Vex[I].head=D;
    }
}
int main()
{
    while(cin>>N)
    {
        int K,M;
        C_vexstruct *last;
        for(int i=1; i<=N; i++)
        {
            cin>>K;
            A[i]=K;///--------入度
            for(int r=1; r<=K; r++)
            {
                cin>>M;
                insert_C(M,i);
            }
        }
        ///-------topsort
        int tim=1;
        int Mark[105];
        memset(Mark,0,sizeof(Mark));
        for( tim=1; tim<=N; tim++)
        {
            int V=-1;
            for(int r=1; r<=N; r++)
            {
                if(!Mark[r]&&A[r]==0)
                {
                    Mark[r]=1;
                    V=r;
                    break;
                }
            }
            //cout<<V<<endl;
            if(V==-1)
                break;
            last=Vex[V].head;
            while(last)
            {
                int D;
                D=last->data;
                A[D]=A[D]-1;
                last=last->next;
            }
        }
       // cout<<tim<<"*"<<endl;
        if(tim>=N)
            cout<<"1"<<endl;
        else
            cout<<"0"<<endl;
    }
    return 0;
}


方法二：使用了队列，算法效率提高。
#include <iostream>
#include<stdio.h>
#include<stdlib.h>
#include<queue>
using namespace std;
struct C_vexstruct{
     int data;
     C_vexstruct *next;
};
struct Vexstruct{
    int data;
    C_vexstruct *head;
};
Vexstruct Vex[105];
int N,A[105],top[105];
void insert_C(int I,int M)
{
     C_vexstruct *D=(C_vexstruct*)malloc(sizeof(C_vexstruct));
     D->data=M;
     D->next=NULL;
    if(Vex[I].head)
    {
        C_vexstruct *last;
        last=Vex[I].head;
        while(last->next)
        {
            last=last->next;
        }
        last->next=D;
    }else
    {
        Vex[I].head=D;
    }
}
int main()
{
    while(cin>>N)
    {
        /*
        for(int i=1;i<=N;i++)
        {
            Vex[i].head=NULL;
        }*/
        int K,M;
        C_vexstruct *last;
        for(int i=1;i<=N;i++)
        {
            cin>>K;
            A[i]=K;///--------入度
            for(int r=1;r<=K;r++)
            {
                cin>>M;
                insert_C(M,i);
            }
        }
        ///-------topsort
        queue<int>q;
        for(int i=1;i<=N;i++)
        {
            if(A[i]==0)
            {
                q.push(i);
            }
        }
        int tim=1;
        while(!q.empty())
        {
            int V=q.front();
            q.pop();
            top[tim]=V;
            tim=tim+1;
            last=Vex[V].head;
            while(last)
            {
                int D;
                D=last->data;
                A[D]=A[D]-1;
                if(A[D]==0)
                {
                    q.push(D);
                }
                last=last->next;
            }
        }
        if(tim==N+1)
            cout<<"1"<<endl;
        else
            cout<<"0"<<endl;
    }
    return 0;
}


方法三：自创DFS搜索，利用回溯；
#include <iostream>
#define MAX 1000
#include<string.h>
using namespace std;
int stroe[MAX][MAX];
int stroesum[MAX];
int Mark[MAX];
int N,B;
void DFS(int I)
{
    if(B==0)
    {
        return;
    }
    if(Mark[I]==1)
    {
        return;
    }else
    {
        if(Mark[I]==-1)
        {
            //cout<<I<<" * "<<endl;
            B=0;
            return;
        }
        Mark[I]=-1;
        int M=stroesum[I];
        for(int i=1;i<=M;i++)
        {
            int V;
            V=stroe[I][i];
            DFS(V);
        }
        Mark[I]=1;
    }
}
int main()
{
    while(cin>>N)
    {
        B=1;
        //memset(stroe,0,sizeof(stroe));
        memset(Mark,0,sizeof(Mark));
        for(int i=1;i<=N;i++)
        {
            int M;
            cin>>M;
            if(M==0)
                Mark[i]=1;
            stroesum[i]=M;
            for(int r=1;r<=M;r++)
            {
                cin>>stroe[i][r];
            }
        }
        for(int i=1;i<=N;i++)
        {
            if(Mark[i]==0)
            {
                DFS(i);
            }
        }
        if(B)
            cout<<"1"<<endl;
        else
            cout<<"0"<<endl;

    }
    return 0;
}
 

拓 扑 排 序
bolite的博客
08-09 1336
一.什么是拓扑排序 拓扑排序（Topological Sorting）是一个有向无环图（DAG, Directed Acyclic Graph）的所有顶点的线性序列。 且该序列必须满足下面两个条件： 每个顶点出现且只出现一次。 若存在一条从顶点A 到顶点B 的路径，那么在序列中顶点A 出现在顶点B 的前面。 二.图片描述 该算法解决的问题类似于办事的流程一样 在做一件事情之前必须完成之前的一件或多件相关的事情 三.代码的实现图示 1.先在所有任务中找到没有需要其他任务做铺垫的任务，图片中体现为点1。将1
拓扑排序（Topological Sorting）
最新发布
KARRAS的博客
06-02 657
拓扑排序的本质是将非线性依赖关系转化为线性有序序列理论层面：作为图论的基础算法，连接了图的拓扑性质与实际应用需求。工程层面：成为解决依赖调度问题的 “通用工具”，支撑了编译器、任务调度系统、包管理等关键基础设施。方法论层面：体现了 “建模 - 抽象 - 算法求解” 的问题解决范式，为复杂系统的有序化提供了思维框架。从早期的数学理论到如今的多领域渗透，拓扑排序持续展现着其跨学科的生命力，未来仍将在智能化、大规模系统中扮演关键角色。拓扑排序。
数据结构拓扑排序课程设计.docx
07-11
【拓扑排序】是图论中的一个重要概念，用于对有向无环图（DAG，Directed Acyclic Graph）进行线性排序。在这个过程中，我们尝试按照一定的顺序排列顶点，使得对于图中的每一条有向边 (u, v)，顶点 u 总是出现在顶点 ...
Golang实现拓扑排序(DFS算法版)
09-18
拓扑排序是一种对有向无环图(DAG, Directed Acyclic Graph)的顶点进行排序的方法，使得对于图中的每一条有向边 `(u, v)`，顶点 `u` 的排序位置总在顶点 `v` 之前。在本例中，拓扑排序被用来解决一个数字顺序排列的...
aov网和拓扑排序PPT学习教案.pptx
10-06
"AOV网和拓扑排序" AOV网（Activity On Vertices）是一种特殊的有向图，用于表示工程的活动之间的优先关系。AOV网的定义是，用顶点表示活动，用有向边, Vj>表示活动Vi必须先于活动Vj进行。AOV网的特点是不能出现有...
获取所有拓扑排序 arangements：生成所有拓扑排序 arangements-matlab开发
05-30
在计算机科学领域，拓扑排序是对有向无环图（DAG，Directed Acyclic Graph）进行排序的一种方法，它能够将图中的所有节点排成一个线性的序列，使得对于每一条有向边 (u, v)，节点 u 都在这个序列中位于节点 v 之前。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值