实例图解关键路径及实现（C++）

---

2019/1/15 即将0点

---

关键路径求解步骤

1， 先正向拓扑排序求出点的最早开始时间：ve（取最大ve(j)=Max{ve(i)+dut(<i,j>)}）
2， 再逆向拓扑排序求出点的最迟开始时间：vl（取最小vl(i)=Min{vl(j)-dut(<i,j>)}）
3， 利用ve，vl求出边的最早开始时间e，最迟开始时间l
4， e=l表示此边为关键路径中的边
计算公式：假设ak=<i,j>
e=ve(i)
vl=vl(j)-dut(<i,j>)

图解演示

以下用实例演示算法执行过程

1、正向拓扑排序

2、逆序拓扑排序

3、边处理

具体实现

采用邻接表存储图，先正序拓扑排序（可参考邻接表拓扑排序）过程中用栈记录每个访问到的点，接着从栈中弹出元素实现逆序拓扑排序，最后处理一下边最早开始和最迟开始时间即可

数据结构

typedef struct ArcNode//边 
{
	int adjvex;//相邻顶点下标 
	int weight;//权重 
	struct ArcNode *nextarc; 
}ArcNode;
typedef struct//点 
{
	int data;//顶点信息 
	ArcNode *firstarc;//作为头节点
}VNode,*AdjList; 
typedef struct 
{
	int vexnum,arcnum;
	AdjList arcs;//邻接表，动态申请空间
}ALGraph;

正序拓扑排序

借用入度数组indegree,队列实现；邻接表从1开始存储
1，初始化，indegree=0;计算每个顶点的入度
2，将第一批入度为0的点入队，入队后将相应入度置为-1，以免重复入队（先访问，后入队）
3，队非空，出队，更新入度表，将入度为0点入队

void TopologicalOrder(ALGraph G, int *ve, int *vl, stack<int> &S)
{
	int indegree[G.vexnum + 1];//入度表 
	for(int i = 0; i <= G.vexnum; i++)//初始化 
	{
		indegree[i] = 0;
		*(ve + i) = *(vl + i) = 0;//初始化 
	}
	for(int i = 0; i <= G.vexnum; i++)//计算相应点入度 
	{
		ArcNode *pcur = (G.arcs + i)->firstarc;
		while(pcur)
		{
			indegree[pcur->adjvex] ++;
			pcur = pcur->nextarc;
			//*(ve + pcur->adjvex)  = 0;
		} 
	}
	queue<int> Q;
	for(int i = 1; i <= G.vexnum; i++)//初次入队 
	{
		if(indegree[i] == 0)
		{
			Q.push(i);
			indegree[i] = -1;//标记已入队 
		//	S.push(i);//为逆序拓扑排序准备 
		}
	}
//	cout<<"正序拓扑序列：";
	//借用队实现，类似层次遍历 
	while(!Q.empty())
	{
		int index = Q.front();
//		cout << index <<"  ";
		Q.pop();//出队 
		S.push(index);//入栈，为逆序拓扑排序准备
		ArcNode *pcur = (G.arcs + index)->firstarc;
		while(pcur)//删除一个点，并更新入度队列 
		{
			indegree[pcur->adjvex]--;
			if(*(ve + pcur->adjvex) < *(ve + index) + pcur->weight)
			{
				*(ve + pcur->adjvex) = *(ve + index) + pcur->weight;
			} 
			pcur = pcur->nextarc;
		}
		for(int i = 1; i <= G.vexnum; i++)//将入度为0点入队 
		{
			if(indegree[i] == 0)
			{
				Q.push(i);
				indegree[i] = -1;//标记已入队 
			}
		}
	}	
	cout<<endl;
}

逆序拓扑排序及边处理

void CriticalPath(ALGraph G)
{
	int *ve, *vl;
	stack<int> S;
	ve = (int*)malloc((G.vexnum + 1)*sizeof(int));
	vl = (int*)malloc((G.vexnum + 1)*sizeof(int));
	TopologicalOrder(G,ve,vl,S);//顺序拓扑
	//逆序拓扑，借用栈S
	for(int i = 1; i <=G.vexnum; i++)
	{
		*(vl + i) = *(ve + S.top());//初始化最迟开始时间数组 
		//cout <<*(vl + i)<<" ";
	} 
	while(!S.empty())
	{
		int index = S.top();
		S.pop();
		ArcNode *pcur = (G.arcs + index)->firstarc;
		while(pcur)//判断出度是否为0 
		{
			if(*(vl + pcur->adjvex) < *(vl + index) + pcur->weight)
			{
				*(vl + index) =  *(vl + pcur->adjvex) - pcur->weight;
			}
			pcur = pcur->nextarc;
		}
    } 
	cout<<endl; 
	//输出关键路径的边 
	for(int i = 0; i < G.vexnum; i++)
	{
		ArcNode *p = (G.arcs + i)->firstarc;
		while(p)
		{
			if(*(ve + i) == *(vl + p->adjvex) - p->weight)
			{
				cout << "起点： "<<i<<"  终点： "<<p->adjvex<<"  权值： "<<p->weight<<endl; 
			}
			p = p->nextarc;
		} 
	} 
} 

测试

测试一

9 11
1 2 6 1 3 4 1 4 5
2 5 1
3 5 1
4 6 2
5 7 9 5 8 7
6 8 4
7 9 2
8 9 4

测试二

6 8
1 2 3 1 3 2
2 4 2 2 5 3
3 4 4 3 6 3
4 6 2
5 6 1

完整Code

#include<iostream>
using namespace std;
#include<stdlib.h>
#include<queue>
#include<stack> 

typedef struct ArcNode//边 
{
	int adjvex;//相邻顶点下标 
	int weight;//权重 
	struct ArcNode *nextarc; 
}ArcNode;
typedef struct//点 
{
	int data;//顶点信息 
	ArcNode *firstarc;//作为头节点
}VNode,*AdjList; 
typedef struct 
{
	int vexnum,arcnum;
	AdjList arcs;//邻接表，动态申请空间
}ALGraph;
//以邻接链表存储有向图
void CreateALGraph(ALGraph &G)
{
	cin >> G.vexnum >> G.arcnum;
	G.arcs = (AdjList)malloc((G.vexnum + 1) * sizeof(VNode));//从1开始存 
	//初始化 
	for(int i = 0; i < G.vexnum + 1; i++)
	{
		(G.arcs + i)->firstarc = NULL;
	}
	for(int i = 0; i < G.arcnum; i++)//控制次数 
	{
		int v0, v1, w;
		ArcNode* p, *pcur;
		cin >> v0 >> v1 >> w;
//		v0++;v1++; 
		p = (ArcNode*)malloc(sizeof(ArcNode));
		p->adjvex = v1; 
		p->weight = w; 
		p->nextarc = NULL;
		//尾插法，头插法简单 
		if((G.arcs + v0)->firstarc != NULL)
		{
			pcur = (G.arcs + v0)->firstarc;
			while(pcur->nextarc)
			{
				pcur = pcur->nextarc;
			}
			pcur->nextarc = p;
		}
		else
		{
			(G.arcs + v0)->firstarc = p;
		}
	} 
} 
//验证建图正确否？ 
void Test(ALGraph G)
{
	for(int i = 0; i < G.vexnum + 1; i++)
	{
		ArcNode* pcur;
		pcur = (G.arcs + i)->firstarc;
		while(pcur)
		{
			cout << " 起点： "<<i <<"  终点： "<<pcur->adjvex<<"  权值： "<<pcur->weight<<"     "; 
			pcur = pcur->nextarc;
		}
		cout<<endl;
	}
}
 
//借用入度数组indegree,队列实现；邻接表从1开始存储 
//1，初始化，indegree=0;计算每个顶点的入度
//2，将第一批入度为0的点入队，入队后将相应入度置为-1，以免重复入队
//3，队非空，出队，更新入度表，将入度为0点入队
void TopologicalOrder(ALGraph G, int *ve, int *vl, stack<int> &S)
{
	int indegree[G.vexnum + 1];//入度表 
	for(int i = 0; i <= G.vexnum; i++)//初始化 
	{
		indegree[i] = 0;
		*(ve + i) = *(vl + i) = 0;//初始化 
	}
	for(int i = 0; i <= G.vexnum; i++)//计算相应点入度 
	{
		ArcNode *pcur = (G.arcs + i)->firstarc;
		while(pcur)
		{
			indegree[pcur->adjvex] ++;
			pcur = pcur->nextarc;
			//*(ve + pcur->adjvex)  = 0;
		} 
	}
	queue<int> Q;
	for(int i = 1; i <= G.vexnum; i++)//初次入队 
	{
		if(indegree[i] == 0)
		{
			Q.push(i);
			indegree[i] = -1;//标记已入队 
		//	S.push(i);//为逆序拓扑排序准备 
		}
	}
//	cout<<"正序拓扑序列：";
	//借用队实现，类似层次遍历 
	while(!Q.empty())
	{
		int index = Q.front();
//		cout << index <<"  ";
		Q.pop();//出队 
		S.push(index);//入栈，为逆序拓扑排序准备
		ArcNode *pcur = (G.arcs + index)->firstarc;
		while(pcur)//删除一个点，并更新入度队列 
		{
			indegree[pcur->adjvex]--;
			if(*(ve + pcur->adjvex) < *(ve + index) + pcur->weight)
			{
				*(ve + pcur->adjvex) = *(ve + index) + pcur->weight;
			} 
			pcur = pcur->nextarc;
		}
		for(int i = 1; i <= G.vexnum; i++)//将入度为0点入队 
		{
			if(indegree[i] == 0)
			{
				Q.push(i);
				indegree[i] = -1;//标记已入队 
			}
		}
	}	
	cout<<endl;
/*	for(int i = 1; i <= G.vexnum; i++)
	{
		cout<<*(ve + i)<<" ";
	}*/
}
//关键路径
void CriticalPath(ALGraph G)
{
	int *ve, *vl;
	stack<int> S;
	ve = (int*)malloc((G.vexnum + 1)*sizeof(int));
	vl = (int*)malloc((G.vexnum + 1)*sizeof(int));
	TopologicalOrder(G,ve,vl,S);//顺序拓扑
	//逆序拓扑，借用栈S
	for(int i = 1; i <=G.vexnum; i++)
	{
		*(vl + i) = *(ve + S.top());//初始化最迟开始时间数组 
		//cout <<*(vl + i)<<" ";
	} 
	while(!S.empty())
	{
		int index = S.top();
		S.pop();
		ArcNode *pcur = (G.arcs + index)->firstarc;
		while(pcur)//判断出度是否为0 
		{
			if(*(vl + pcur->adjvex) < *(vl + index) + pcur->weight)
			{
				*(vl + index) =  *(vl + pcur->adjvex) - pcur->weight;
			}
			pcur = pcur->nextarc;
		}
    } 
	cout<<endl; 
	//输出关键路径的边 
	for(int i = 0; i < G.vexnum; i++)
	{
		ArcNode *p = (G.arcs + i)->firstarc;
		while(p)
		{
			if(*(ve + i) == *(vl + p->adjvex) - p->weight)
			{
				cout << "起点： "<<i<<"  终点： "<<p->adjvex<<"  权值： "<<p->weight<<endl; 
			}
			p = p->nextarc;
		} 
	} 
} 

int main()
{
	 ALGraph G;
	 CreateALGraph(G);
//	 Test(G);
	 CriticalPath(G);
	// TopologicalOrder(G);
	return 0;
}