关键路径的实现C++ 代码

最新推荐文章于 2021-06-07 14:33:12 发布
最新推荐文章于 2021-06-07 14:33:12 发布
阅读量2.6k 收藏 8
点赞数
分类专栏： 算法分析

http://blog.csdn.net/hackerain/article/details/6054188

01.#include <iostream>  
02.using namespace std;  
03.#define MAX 10000000  
04.#define MAX_VERTEX_NUM 20  
05.int ve[MAX_VERTEX_NUM];  
06./*顺序栈的定义*/  
07.#define Stack_Size 100  
08.typedef struct sqStack  
09.{  
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.}


 

 

求关键路径的关键如下：

1、每个顶点所代表的事件的最早和最迟发生时间

2、每条弧所代表的活动的最早和最迟开始时间

事件的最早发生时间：ve[源点]=0，ve[k]=MAX{ve[j]+dut(<j,k>)}，即在k前面的事件的最早发生时间加上那些事件到k所需要的时间所得的值中取最大值。

事件的最迟发生时间：vl[汇点]=ve[汇点]，vl[j]=MIN{vl[k]-dut(<j,k>)}，即在j后面的事件的最迟发生时间减去j到那些事件所需的时间所得的值中取最小值。

活动的最早开始时间：ee[i]=ve[j]，即该项活动最早开始时间与该项活动的开始事件的最早时间相同

活动的最迟开始时间：el[i]=vl[k]-dut(<j,k>)，即活动的最迟开始时间等于该项活动的结束事件的最迟发生时间减去该项活动持续的时间。

 

 

代码如下：

#include <stack>
using namespace std;
#define MAX 1000000
#define MAX_VERTEX_NUM 20
int ve[MAX_VERTEX_NUM];

typedef struct EdgeNode
{
	int adjvex;
	struct EdgeNode* nextedge;
	int weight;
}EdgeNode;
typedef struct VexNode
{
	char vex;
	EdgeNode* firstedge;
	int indegree;
}VexNode;
typedef struct
{
	VexNode vexs[MAX_VERTEX_NUM];
	int vexnum,edgenum;
}LGraph;
void CreateDG_AL(LGraph &G,int n,int e)
{
	int i,j,k,w;
	G.vexnum=n;
	G.edgenum=e;
	for(i=0;i<n;i++)
	{
		cin>>G.vexs[i].vex;
		G.vexs[i].firstedge=NULL;
	}
	for(k=0;k<e;k++)
	{
		EdgeNode* p;
		cin>>i>>j>>w;
		p=new EdgeNode;
		p->adjvex=j;
		p->weight=w;
		p->nextedge=G.vexs[i].firstedge;
		G.vexs[i].firstedge=p;
	}
}
//拓扑排序并求出各个顶点事件的最早发生时间以及逆拓扑排序
void TopoSort(LGraph &G,std::stack<int>& T)
{
	std::stack<int> S;
	EdgeNode* p;
	int count=0;
	int i;
	for(i=0;i<G.vexnum;i++)
		G.vexs[i].indegree=0;//初始化为0
	for(i=0;i<G.vexnum;i++)
	{//计算各个顶点的入度
		p=G.vexs[i].firstedge;
		while(p)
		{
			G.vexs[p->adjvex].indegree++;
			p=p->nextedge;
		}
	}
	for(i=0;i<G.vexnum;i++)
		if(G.vexs[i].indegree==0)
			S.push(i);
	for(i=0;i<G.vexnum;i++)
		ve[i]=0;//初始化顶点事件的最早发生时间为0
	while(!S.empty())
	{
		i=S.top();
		S.pop();
		cout<<G.vexs[i].vex<<" ";
		T.push(i);
		count++;
		p=G.vexs[i].firstedge;
		while(p)
		{
			int k;
			int dut;
			dut=p->weight;
			k=p->adjvex;
			G.vexs[k].indegree--;
			if(G.vexs[k].indegree==0)
				S.push(k);
			if(ve[i]+dut>ve[k])
				ve[k]=ve[i]+dut;
			p=p->nextedge;
		}
	}
	cout<<endl;
	if(count<G.vexnum)
		cout<<"Network G has citcuits!"<<endl;
}
//求关键路径和关键活动
void CriticalPath(LGraph &G)
{
	int i,j,k,dut;
	int ee,el;
	int vl[MAX_VERTEX_NUM];
	EdgeNode* p;
	std::stack<int> T;
	TopoSort(G,T);
	for(i=0;i<G.vexnum;i++)
		vl[i]=ve[G.vexnum-1];
	while(!T.empty())
	{
		j=T.top();
		T.pop();
		for(p=G.vexs[j].firstedge;p;p=p->nextedge)
		{
			k=p->adjvex;
			dut=p->weight;
			if(vl[k]-dut<vl[j])
				vl[j]=vl[k]-dut;
		}
	}
	for(i=0;i<G.vexnum;i++)
	{
		for(p=G.vexs[i].firstedge;p;p=p->nextedge)
		{
			k=p->adjvex;
			dut=p->weight;
			ee=ve[i];
			el=vl[k]-dut;
			if(ee==el)
			{
				cout<<"("<<G.vexs[i].vex<<","<<G.vexs[k].vex<<")"<<dut<<" ";
				cout<<"ee="<<ee<<","<<"el="<<el<<endl;
			}
		}
	}
}
int main()
{
	LGraph G;
	CreateDG_AL(G,9,11);
	CriticalPath(G);
	return 0;
}


 

miao6664659
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[数据结构]图（二）
三月，有人呼唤你的名字
10-07 1640
7.4 (连通网的)最小生成树 问题： 假设要在 n 个城市之间建立通讯联络网，则连通 n 个城市只需要修建 n-1条线路，如何在最节省经费的前提下建立这个通讯网？ 该问题等价于： 构造网的一棵最小生成树，即： 在 e 条带权的边中选取 n-1 条边（不构成回路），使“权值之和”为最小。 算法一：（普里姆算法） 算法二：（克鲁斯卡尔算法）
图的C++关键路径代码
chenjian_0704的专栏
11-22 1403
 #include using namespace std;//*****stack.h以下是栈的实现#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef int Status;templateclass stack{public: void InitStack(); void DestroyStack(); void Clea
关键路径代码
05-01
自己初学数据结构写的，有关关键路径的代码，有什么不对的还望见谅
关键路径介绍（转）
weixin_30822451的博客
10-23 87
AOE网：在一个表示工程的带权有向图中，用顶点表示事件，用有向边表示活动，边上的权值表示活动的持续时间，称这样的有向图叫做边表示活动的网，简称AOE网。AOE网中没有入边的顶点称为始点（或源点），没有出边的顶点称为终点（或汇点）。 AOE网的性质： （1）只有在某顶点所代表的事件发生后，从该顶点出发的各活动才能开始； （2）只有在进入某顶点的各活动都结束，该顶点所代表的事件才能发生。 关...
数据结构C++——关键路径
qq_54162207的博客
06-07 3885
数据结构C++——关键路径 文章目录数据结构C++——关键路径一、前言二、关键路径的概念三、关键路径的实现①关键路径的实现原理②关键路径的代码实现③测试的全部代码四、总结 一、前言 理解关键路径需要掌握拓扑排序和邻接表的相关知识，由于此部分笔者在之前的文章中已经介绍过，此处不再过多赘述，对此部分知识还不熟练的读者，欢迎移步此文章，共同学习！： 数据结构C++——拓扑排序 数据结构C++——图的邻接矩阵和邻接表 二、关键路径的概念 （1）AOE-网:与AOV-网相对应的是AOE-网 , 即以边表示活动的网。A
图的关键路径C/C++代码实现
Ycy的博客
06-22 1778
AOE-网： AOE-网 (Activity On Edge) , 即以边表示活动的网。 AOE-网是一个带权的有向无环图， 其中顶点表示事件， 弧表示活动， 权表示活动持续的时间。 关键路径： 要估算整项工程完成的最短时间， 就是要找一条从源点到 汇点的带权路径长度最长的路径， 称为关键路径 (Critical Path)。关键路径上的 活动叫做关键活动，这些活动是影响工程进度的关键， 它们的提前或拖延将使整个工程提前或拖延。 其关键路径为： 关键路径有两条： (v0, v1,v4,v6, v8)或(
c++关键路径源代码
07-26
在C++编程中实现关键路径可以帮助开发者优化资源分配，确保项目按时完成。以下是对关键路径算法的详细解释，以及如何使用C++来实现它。 关键路径方法（CPM）是通过分析任务之间的依赖关系来确定项目最短可能完成...
关键路径c++代码实现[文].pdf
10-13
关键路径C++代码实现 本文档提供了一个使用C++语言实现关键路径算法的代码实现，用于计算项目网络中的关键路径。该代码实现了一个图形结构，其中每个节点表示一个项目，节点之间的边表示活动之间的依赖关系。代码中...
关键路径代码实现
09-02
用c++实现的关键路径的代码。希望对大家有所帮助！
C++ 设置和获取当前工作路径的实现代码
08-29
总之，C++中设置和获取当前工作路径是解决DLL加载问题的关键步骤，开发者应当注意根据程序的需求正确地设置工作路径，以确保所有相关组件都能正常找到它们所需的文件和资源。同时，掌握Windows API中的路径和文件...
编程C++算法实现代码集.zip
10-18
如Dijkstra最短路径算法、Floyd-Warshall所有对最短路径算法、KMP字符串匹配算法、Topological Sort拓扑排序等，这些都是C++算法实现中不可或缺的部分。 三、数据结构 数据结构是算法的载体，C++提供了多种数据...
关键路径(完整实例及C语言完整代码实现)
热门推荐
记录博主学到的点滴
08-15 1万+
写在前面：博主是一位普普通通的19届二本大学生，平时最大的爱好就是听听歌，逛逛B站。博主很喜欢的一句话花开堪折直须折，莫待无花空折枝：博主的理解是头一次为人，就应该做自己想做的事，做自己不后悔的事，做自己以后不会留有遗憾的事，做自己觉得有意义的事，不浪费这大好的青春年华。博主写博客目的是记录所学到的知识并方便自己复习，在记录知识的同时获得部分浏览量，得到更多人的认可，满足小小的成就感，同时在写博客的途中结交更多志同道合的朋友，让自己在技术的路上并不孤单。 目录: 1. 2. 3.  &n.
有关关键路径的概念和算法
12-23 7939
AOE网：在一个表示工程的带权有向图中，用顶点表示事件，用有向边表示活动，边上的权值表示活动的持续时间，称这样的有向图叫做边表示活动的网，简称AOE网。AOE网中没有入边的顶点称为始点（或源点），没有出边的顶点称为终点（或汇点）。 AOE网的性质： ⑴ 只有在某顶点所代表的事件发生后，从该顶点出发的各活动才能开始； ⑵ 只有在进入某顶点的各活动都结束，该顶点所代表的事件才能发生。 关键路径
拓扑排序
h820911469的专栏
11-16 231
#include #include #define MAX 30 #define STACK_INIT_SIZE 30 #define STACKINCREASE 10 typedef struct { char *base; char *top; int stacksize; }SqStack; typedef struct  { int vexnum,arcnum
14、求关键路径
hopegrace的博客
03-07 1970
1、重要概念 （1）AOE(ActivityOnEdges)网络如果在无有向环的带权有向图中用有向边表示一个工程中的各项活动(Activity)，用边上的权值表示活动的持续时间(Duration)，用顶点表示事件(Event)，则这样的有向图叫做用边表示活动的网络，简称AOE(ActivityOnEdges)网络。AOE网是一个带权的有向无环图。 AOE网络在某些工程估算方面非常有...
关键路径
wizardlun的专栏
02-12 1145
参阅:http://baike.baidu.com/view/288224.htm?fr=ala0_1 关键路径　　关键路径　　1、 AOE网　　用顶点表示事件，弧表示活动，弧上的权值表示活动持续的时间的有向图叫AOE（Activity On Edge Network）网 。AOE网常用于估算工程完成时间。　　2、 AOE网研究的问题　　（1） 完成整个工程至少需要多少时间；　　（2）
工作述职报告PPT模板 (25)
最新发布
07-12
【作品名称】：工作述职报告PPT模板 (25) 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
关键路径算法c++实现
05-19
关键路径算法，又称关键路径分析，是一种用于确定项目中关键任务的方法。关键路径是指在项目完成时间不变的情况下，导致项目完成时间延长的任务序列。 以下是C++实现关键路径算法的代码： ```c++ #include <iostream> #include <vector> #include <queue> using namespace std; struct Edge { int to, weight; }; vector<int> topological_sort(vector<vector<Edge>>& graph) { vector<int> in_degree(graph.size(), 0); for (int i = 0; i < graph.size(); ++i) { for (auto& e : graph[i]) { in_degree[e.to]++; } } queue<int> q; for (int i = 0; i < in_degree.size(); ++i) { if (in_degree[i] == 0) { q.push(i); } } vector<int> result; while (!q.empty()) { int u = q.front(); q.pop(); result.push_back(u); for (auto& e : graph[u]) { in_degree[e.to]--; if (in_degree[e.to] == 0) { q.push(e.to); } } } return result; } void critical_path(vector<vector<Edge>>& graph) { vector<int> topo_order = topological_sort(graph); vector<int> earliest_time(graph.size(), 0); for (int u : topo_order) { for (auto& e : graph[u]) { earliest_time[e.to] = max(earliest_time[e.to], earliest_time[u] + e.weight); } } vector<int> latest_time(graph.size(), earliest_time.back()); for (int i = topo_order.size() - 1; i >= 0; --i) { int u = topo_order[i]; for (auto& e : graph[u]) { latest_time[u] = min(latest_time[u], latest_time[e.to] - e.weight); } } cout << "Critical path:" << endl; for (int u = 0; u < graph.size(); ++u) { for (auto& e : graph[u]) { int task_time = earliest_time[u] + e.weight + latest_time[e.to] - earliest_time.back(); if (task_time == 0) { cout << u << " -> " << e.to << endl; } } } } int main() { // 举例：一个项目的任务时间如下所示 // (0) -> (1) -> (2) -> (3) -> (4) // 2 3 1 4 3 vector<vector<Edge>> graph(5); graph[0].push_back({1, 2}); graph[1].push_back({2, 3}); graph[2].push_back({3, 1}); graph[3].push_back({4, 4}); critical_path(graph); return 0; } ``` 输出： ``` Critical path: 0 -> 1 1 -> 2 2 -> 3 3 -> 4 ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值