拓扑排序和关键路径

文章出自：http://dsqiu.iteye.com/blog/1689199

拓扑排序和关键路径

 

拓扑排序

拓扑排序最大的用途就是判断一个有向图是否有环，当然判断还有一种方法就是Floyd算法。如果用邻接表的话拓扑排序的时间复杂度是O(N*E)，邻接矩阵是O（N^2），N表示顶点数，E表示边数，Floyd时间复杂度是O(N^3)。

 

拓扑排序方法可分为无前趋的顶点优先的拓扑排序方法和无后继的顶点优先的拓扑排序方法。

基本拓扑排序算法步骤

1.在有向图中任选一个没有前驱的顶点输出

2.从图中删除该顶点和所有以它为起点的边

3.重复1和2，直到全部顶点都以输出

 

拓扑排序的实现(无前趋的顶点优先的拓扑排序方法)

邻接表实现（使用stack存储）

C代码  

1. /********************************** 
2.          title:   拓扑排序（邻接表实现） 
3.          author:  jay chang 
4.          date:    2009/07/16 
5. **********************************/  
6. #include<iostream>  
7.   
8. #define MAXSIZE 99  
9. #define TRUE 1  
10. #define FALSE 0  
11. using namespace std;  
12. typedef char VertexData;  
13.    
14. typedef int AdjType;  
15.   
16. typedef struct Stack          //定义栈  
17. {  
18.   int data[MAXSIZE+1];  
19.   int top;  
20. }Stack;  
21.   
22. typedef struct ArcNode       //定义弧结点  
23. {  
24.   AdjType adj;  
25.   ArcNode *nextArc;  
26. }ArcNode;  
27.   
28. typedef struct VertexNode    //定义顶点  
29. {  
30.   VertexData vertexData;  
31.   ArcNode *firstArc;  
32. }VertexNode;  
33.   
34.   
35. typedef struct AdjMatrix     //定义图  
36. {  
37.   VertexNode vertexNodes[MAXSIZE+1];  
38.   int verNum,arcNum;  
39. }AdjMatrix;  
40.   
41. //全局变量  
42. int indegree[MAXSIZE+1]={0};  
43.   
44. int LocateGraph(AdjMatrix *g, VertexData vertexData)  
45. {  
46.   int iIndex;  
47.   for(iIndex=1;iIndex<=g->verNum;iIndex++)  
48.   {  
49.     if(vertexData==g->vertexNodes[iIndex].vertexData)  
50.       return iIndex;  
51.   }  
52.   return FALSE;  
53. }  
54.   
55. void  CreateGraph(AdjMatrix *g)  
56. {     
57.   int iCount,arcStart,arcEnd;char start,end;  
58.   cout<<"*****************************************"<<endl;  
59.   cout<<"***       拓扑排序\n";  
60.   cout<<"***       Author: Jay Chang\n";  
61.   cout<<"*****************************************"<<endl;  
62.   cout<<"输入有向无环图的顶点,及弧数\n";  
63.   cin>>g->verNum>>g->arcNum;  
64.   cout<<"输入有向无环图的顶点信息\n";  
65.   ArcNode *q=NULL;  
66.   
67.   for(iCount=1;iCount<=g->verNum;iCount++)  
68.   {      
69.        cout<<"输入第"<<iCount<<"个顶点的信息"<<endl;  
70.        cin>>g->vertexNodes[iCount].vertexData;  
71.        g->vertexNodes[iCount].firstArc=NULL;  
72.   }  
73.   
74.   for(iCount=1;iCount<=g->arcNum;iCount++)  
75.   {  
76.       cout<<"输入第"<<iCount<<"条弧的起始与结束的信息"<<endl;  
77.       cin>>start>>end;  
78.   
79.       arcStart=LocateGraph(g,start);  
80.       arcEnd  =LocateGraph(g,end);  
81.       
82.       //添加弧结点  
83.       q=(ArcNode*)malloc(sizeof(ArcNode));  
84.       q->adj=arcEnd;  
85.       q->nextArc=g->vertexNodes[arcStart].firstArc;  
86.       g->vertexNodes[arcStart].firstArc=q;  
87.       //对于第arcEnd个顶点的入度值加1  
88.       indegree[arcEnd]++;  
89.   }  
90. }  
91.   
92. //判栈空  
93. int IsEmpty(Stack *stack)  
94. {  
95.   return stack->top==-1?TRUE:FALSE;  
96. }  
97.   
98. //初始化栈  
99. void InitStack(Stack *stack)  
100. {  
101.   stack->top=-1;  
102. }  
103.   
104. //出栈  
105. void Pop(Stack *stack,int *iIndex)  
106. {  
107.   *iIndex=stack->data[stack->top--];  
108. }  
109.   
110. //进栈  
111. void Push(Stack *stack,int value)  
112. {  
113.   stack->data[++stack->top]=value;  
114. }  
115.   
116. //拓扑排序  
117. int Topological(AdjMatrix *g)  
118. {  
119.   int iCount,count=0;  
120.   Stack *stack=(Stack*)malloc(sizeof(Stack));  
121.   InitStack(stack);  
122.   ArcNode *p=NULL;  
123.   
124.   //对于入度为0的顶点入栈  
125.   for(iCount=1;iCount<=g->verNum;iCount++)  
126.   {  
127.     if(indegree[iCount]==0){  
128.       Push(stack,iCount);  
129.     }  
130.   }  
131.   
132.   cout<<"输出拓扑序列\n";  
133.     
134.   //输出顶点后，将与该顶点相连的顶点的边删除，将与相连顶点的入度减1，如减后为0，入栈，栈空结束  
135.   while(!IsEmpty(stack))  
136.   {  
137.     Pop(stack,&iCount);  
138.     cout<<g->vertexNodes[iCount].vertexData<<" ";  
139.     count++;  
140.     p=g->vertexNodes[iCount].firstArc;  
141.     while(p!=NULL)  
142.     {     
143.         if(--indegree[p->adj]==0)  
144.             Push(stack,p->adj);  
145.         p=p->nextArc;  
146.     }  
147.   }//end while  
148.   
149.   if(count<g->verNum){  
150.     cout<<"有回路"<<endl;  
151.     return FALSE;  
152.   }  
153.   cout<<endl;  
154. }  
155.      
156. int main()  
157. {  
158.     AdjMatrix *g=(AdjMatrix*)malloc(sizeof(AdjMatrix));  
159.     CreateGraph(g);  
160.     Tuopu(g);  
161.     return 0;  
162. }  

 转自http://jaychang.iteye.com/blog/702073

 

基于DFS实现(无后继的顶点优先的拓扑排序方法)

 

Cpp代码  

1. #include<iostream>  
2. using namespace std;  
3. int timef = 0;   
4. int n ;  
5. int a[1000][1000];// 图的邻接矩阵  
6. int f[1000];  //完成时间  
7. int vis[1000];  //1代表 被发现 2代表 已完成  
8. void DFS(int u)  
9. {  
10.        vis[u] = 1;   //记录发现时刻  
11.    
12.        for(int v=1; v<=n; v++) //adj(u)   //O(E)  
13.               if(a[u][v] && vis[v]==0)  
14.                 DFS(v);  
15.        vis[u] = 2;  //记录完成时刻  
16.        timef++;  
17.        f[u] = timef;  
18. }  
19. void DFS_main()   //O(V+E)  
20. {  
21.        timef = 0;  
22.        for(int i=1; i<=n; i++)             /// O(V)  
23.        {  
24.               if(vis[i] == 0)  
25.                      DFS(i);  
26.        }  
27. }  
28. void Topological_sort()      //O(V+E)  
29. {  
30.        int tp[1000];            ////存放拓扑序列1..V  
31.        DFS_main();  
32.    
33.        for(int i=1; i<=n; i++)   //按finish的时间倒序存放在tp序列tp中  
34.         tp[n-f[i]+1] = i;  
35.         
36.        for(int i=1; i<=n; i++)  
37.               cout<<tp[i]<<" ";  
38.        cout<<endl;  
39. }  
40. int main()  
41. {  
42.        memset(vis,0,sizeof(vis));  
43.        cin>>n;  
44.        for(int i=1; i<=n; i++)  
45.               for(int j=1; j<=n; j++)  
46.                      cin>>a[i][j];  
47.         
48.        Topological_sort();  
49.        system("pause");  
50.        return 0;  
51. }  
52.    

 转自http://blog.sina.com.cn/s/blog_6ec5c2d00100szit.html

 

关键路径

 

相关量介绍,设源点v0,汇点vn-1:

ve(i)表示事件vi最早发生的时间，vl(i)表示事件vi最晚发生的时间。

ve(0)=0，按拓扑排序计算ve(i)的值，ve(j)=max{ve(i)+w(i,j)|<i,j>∈E}。

vl(n-1)=ve(n-1)，vl(i)按逆拓扑排序进行计算，vl(i)=min{vl(j)-w(i,j)|<i,j>∈E}。

活动<i,j>最早开始时间ee(i)=ve(i)；活动<i,j>最晚开始时间el(i,j)=vl(j)-w(i,j)，如果el(i,j)=ee(i,j)，则活动<i,j>是关键活动。

 

关键路径算法的流程

1.以拓扑排序的次序按ve(j)=max{ve(i)+w(i,j)|<i,j>∈E}计算各个顶点（事件）最早发生的时刻

2.以逆拓扑排序的次序按vl(j)=min{ve(i)+w(i,j)|<i,j>∈E}计算各个顶点（事件）最晚发生的时刻

3.计算每个活动<i,j>发生的最早时间ee(i,j)和最晚时间el(i,j)，如果满足ee(i,j)=el(i,j)则是关键路径并输出。

 

关键路径算法实现

 

 

Cpp代码  

1. #include <iostream>    
2. using namespace std;    
3. #define MAX 10000000    
4. #define MAX_VERTEX_NUM 20    
5. int ve[MAX_VERTEX_NUM];    
6. /*顺序栈的定义*/    
7. #define Stack_Size 100    
8. typedef struct sqStack    
9. {    
10.        int *elem;    
11.        int top;    
12.        int stackSize;//栈数组长度    
13. }sqStack;    
14.      
15.      
16. /*顺序栈的初始化*/    
17. void initStack_Sq(sqStack &S)    
18. {    
19.        S.elem=new int[Stack_Size];    
20.        S.top=-1;    
21.        S.stackSize=Stack_Size;    
22. }    
23. /*入栈*/    
24. void push(sqStack &S,int x)    
25. {    
26.        if(S.top==Stack_Size-1)    
27.               cout<<"Stack Overflow!";    
28.        S.elem[++S.top]=x;    
29. }    
30.      
31. /*出栈*/    
32. int pop(sqStack &S)    
33. {    
34.        int x;    
35.        if(S.top==-1)    
36.               cout<<"Stack Empty!";    
37.        x=S.elem[S.top--];    
38.        return x;    
39. }    
40. typedef struct EdgeNode    
41. {//边表结点的定义    
42.     int adjvex;//存放邻接点在顶点表中的位置    
43.     struct EdgeNode * nextedge;//指向下一个边表结点    
44.     int weight;    
45. }EdgeNode;    
46. typedef struct VexNode    
47. {//顶点表结点的定义    
48.     char vex;//存放顶点信息    
49.     EdgeNode * firstedge;//指向第一个边表结点    
50.     int indegree;    
51. }VexNode;    
52. typedef struct    
53. {//顶点表的定义       
54.     VexNode vexs[MAX_VERTEX_NUM];    
55.     int vexnum,edgenum;    
56. }LGraph;    
57. /*构造有向图的邻接表*/    
58. void CreateDG_AL(LGraph &G,int n,int e)    
59. {    
60.     int i,j,k,w;    
61.     G.vexnum=n;    
62.     G.edgenum=e;    
63.     for(i=0;i<n;i++)    
64.     {    
65.         cin>>G.vexs[i].vex;    
66.         G.vexs[i].firstedge=NULL;//初始化为空    
67.     }    
68.     for(k=0;k<e;k++)    
69.     {    
70.         EdgeNode *p;    
71.         cin>>i>>j>>w;    
72.         p=new EdgeNode;    
73.         p->adjvex=j;    
74.         p->weight=w;    
75.         p->nextedge=G.vexs[i].firstedge;    
76.         G.vexs[i].firstedge=p;//采用头插法    
77.     }    
78. }    
79. //拓扑排序并求各顶点事件的最早发生时间及拓扑逆序列    
80. void TopoSort(LGraph &G,sqStack &T)    
81. {    
82.     sqStack S;    
83.     initStack_Sq(S);    
84.     EdgeNode *p;    
85.         
86.     int count=0;    
87.     int i;    
88.     for(i=0;i<G.vexnum;i++)    
89.         G.vexs[i].indegree=0;//初始化为0    
90.     for(i=0;i<G.vexnum;i++)    
91.     {//计算各个顶点的入度    
92.         p=G.vexs[i].firstedge;    
93.         while(p)    
94.         {    
95.             G.vexs[p->adjvex].indegree++;    
96.             p=p->nextedge;    
97.         }    
98.     }    
99.     for(i=0;i<G.vexnum;i++)    
100.         if(G.vexs[i].indegree==0)    
101.             push(S,i);//将度为0的顶点入栈,这里进栈的是入度为0的顶点在数组中的位置    
102.     for(i=0;i<G.vexnum;i++)    
103.         ve[i]=0;//初始化顶点事件的最早发生时间为0    
104.     while(S.top!=-1)    
105.     {    
106.         i=pop(S);    
107.         cout<<G.vexs[i].vex<<" ";//将栈顶的元素出栈且输出，即将入度为0的顶点输出    
108.         push(T,i);//为了求得拓扑序列的逆序列，将元素依次进栈就得到了逆序列    
109.         count++;//计数器加1    
110.         p=G.vexs[i].firstedge;//让p指向入度为0的顶点的第一个边表结点    
111.         while(p)    
112.         {    
113.             int k;    
114.             int dut;    
115.             dut=p->weight;    
116.             k=p->adjvex;    
117.             G.vexs[k].indegree--;//将入度为0的顶点的邻接点的入度减1    
118.             if(G.vexs[k].indegree==0)    
119.                 push(S,k);//度减1后的顶点如果其入度为0，则将其入栈    
120.             if(ve[i]+dut>ve[k])    
121.                 ve[k]=ve[i]+dut;//经过while循环，将顶点事件的所有邻接点的最早发生时间算出来，    
122.                                 //并且经过外层的while循环，不断地更新为较大的ve[k]值    
123.             p=p->nextedge;    
124.         }    
125.     }    
126.     cout<<endl;    
127.     if(count<G.vexnum)    
128.         cout<<"Network G has citcuits!"<<endl;    
129. }    
130. //求关键路径和关键活动    
131. void CriticalPath(LGraph &G)    
132. {    
133.     int i,j,k,dut;    
134.     int ee,el;    
135.     int vl[MAX_VERTEX_NUM];    
136.     EdgeNode *p;    
137.     sqStack T;    
138.     initStack_Sq(T);    
139.     TopoSort(G,T);    
140.     for(i=0;i<G.vexnum;i++)    
141.         vl[i]=ve[G.vexnum-1];//初始化顶点事件的最迟发生时间为汇点的最早发生时间    
142.                             //因为求最迟发生时间是从汇点向源点开始计算的    
143.     while(T.top!=-1)    
144.     {//经过while循环，按堆栈顺序求出每个顶点的最迟发生时间    
145.         for(j=pop(T),p=G.vexs[j].firstedge; p ;p=p->nextedge)    
146.         {//这里应该注意for循环的机制：每一次循环都要判断一次条件，包括第一次    
147.             k=p->adjvex;    
148.             dut=p->weight;    
149.             if(vl[k]-dut<vl[j])    
150.                 vl[j]=vl[k]-dut;//按堆栈T中事件的顺序，将该顶点事件的最迟发生时间经过for循环算出来，    
151.                                 //注意：经过for循环算出的是一个顶点的最迟发生时间                             
152.         }    
153.     }    
154.     for(i=0;i<G.vexnum;i++)    
155.     {//依次遍历每一个活动    
156.         for(p=G.vexs[i].firstedge;p;p=p->nextedge)    
157.         {    
158.             k=p->adjvex;    
159.             dut=p->weight;    
160.             ee=ve[i];//求活动的最早开始时间    
161.             el=vl[k]-dut;//求活动的最迟开始时间    
162.             if(ee==el)    
163.             {//若两者相等，说明这这个活动为关键活动    
164.                 cout<<"("<<G.vexs[i].vex<<","<<G.vexs[k].vex<<")"<<dut<<" ";    
165.                 cout<<"ee="<<ee<<","<<"el="<<el<<endl;    
166.             }    
167.         }    
168.     }    
169. }    
170. void main()    
171. {    
172.     freopen("in.txt","r",stdin);    
173.     LGraph G;    
174.     CreateDG_AL(G,9,11);    
175.     CriticalPath(G);    
176. }    

转自http://blog.youkuaiyun.com/hackerain/article/details/6054188

  

小结

这篇文章讲了有关有向无环图的两个应用，最要将能熟悉拓扑排序和关键路径的算法的原理就能加以应用。如果你有任何建议或者批评和补充，请留言指出，不胜感激，更多参考请移步互联网。