利用AOE网求解关键路径问题

已于 2024-01-05 21:59:58 修改
阅读量4.6k 收藏 9
点赞数 1
分类专栏： c++ 文章标签： c++ AOE网 关键路径问题
于 2017-05-08 19:20:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Journing/article/details/71429692
版权

1、关键路径问题的简要介绍

关键路径是从工程领域抽象出来的一类问题，这类问题的求解常用于工程完成所需时间的估算，包括完成整个工程至少需要多少时间？其中哪些子工程是影响工程进度的关键？

为求解此类问题，采用如下形式的图结构来表示工程：用弧（有向边）表示活动（子工程）；用弧的权值表示活动的持续时间；用弧两端的顶点分别表示活动的开始和结束，叫做事件（即工程中的瞬间行）。这样的有向图称为AOE网（Activity On Edge）。显然，一个能正常进行的工程所对应的AOE网是一个有向无环图。由于整个工程通常有一个唯一的开始时间和结束时间，因此，相应地，在AOE网中分别对应一个顶点，称开始点（即入度为0的点）和结束点（即出度为0的点）。

由于有些活动只能依次进行，有些活动却可以并行进行，所以整个工程所需要的最少时间不是所有活动所需时间的累积，而是从开始点到结束点之间工期最长的一条路径，这条最长的路径即关键路径（Critical Path）。最长路径可能不止一条，在最长路径上的活动即关键活动（Critical Activity）。

2、程序框架设计

2.1、有向图的存储

构建一个graph类，使用邻接链表和逆邻接链表用来存储工程有向图。

graph类框架表

graph

public

function

graph(int x,int y)

构造函数

~graph()

析构函数

void creategraph(group test[])

存储有向图

void getindegrees(int ind[])

获取顶点入度

void getoutdegrees(int outd[])

获取顶点出度

void deletegraph()

删除有向图

data

int vernum

顶点数

int arcnum

弧数

group test[100]

group类型结构体

vnode verlist[100]

vnode类型结构体

graph类使用的结构体框架表

struct

group

存储每一条弧的起点、终点、事件、时间。

int start

起点

int end

终点

int thing

事件编号

int time

时间

enode

用于邻接链表，存储每一顶点邻接点、对应弧时间、邻接点指针

int adjver

邻接点编号

int data

时间

struct enode *enext

邻接点指针

cenode

用于逆邻接链表，存储每一顶点前邻接点、对应弧时间、前邻接点指针

int adjver

逆邻接点编号

int data

时间

struct cenode *cenext

逆邻接点指针

vnode

存储每一顶点的编号、对应邻接链表头指针、对应逆邻接链表头指针

int data

顶点编号

enode *ehead

邻接链表头指针

cenode *cehead

逆邻接链表头指针

2.2、数据结构链栈

构建一个lstack链栈类，用于主程序使用。

lstack类框架表

lstack

public

function

lstack()

构造函数

~lstack()

析构函数

void pushstack(int x)

入栈函数

int popstack()

出栈函数

data

snode *top

snode类型结构体指针

lstack类使用的结构体框架表

struct

snode

链栈数据、指针

int data

压栈数据

struct snode *next

链栈指针

2.3、主程序框架

主程序用来求出AOE网中的所有关键活动，由以下几个子程序组成。

邻接链表拓扑排序topo：使用邻接链表来判断AOE网是否有环，以判断是否能够继续求出关键活动，同时求出每个顶点的最早发生时间。

‚逆邻接链表拓扑排序ctopo：使用逆邻接链表求出每个顶点的最迟发生时间。

ƒ关键活动aoe：通过判断每一个顶点的最早发生时间是否等于最迟发生时间求出关键路径上的顶点即事件以及关键活动。

主程序框架表

main program

function

bool topo(int x,lstack s,int ind[],int e[],graph g)

邻接链表拓扑排序

void ctopo(int x,lstack s,int outd[],int e[],int l[],graph g)

逆邻接链表拓扑排序

void aoe(int x,int y,int cv[],int ca[],lstack s,int outd[],int e[],int l[],graph g)

求关键活动子程序

int main()

主函数，见流程图

data

int count

全局变量，统计关键活动个数

int x

有向图顶点数

int y

有向图弧数

int ind[100]

顶点入度数组

int outd[100]

顶点出度数组

int e[100]

顶点最早发生时间数组

int l[100]

顶点最迟发生时间数组

int cv[100]

关键路径上的事件

int ca[100]

关键路径上的活动

lstack s

lstack类型变量s

graph g(x,y)

graph类型变量g

程序具体运行过程中有教导用户如何使用的交互语句，但是为了用户更好的使用，还是特地将步骤以及注意事项介绍如下：

1、用户需要在运行程序之前在该程序所在文件夹目录下，创建一个txt文档，并按照xxx.txt的格式命名该文档。用户需要在该文档中输入所要求解的AOE网的数据，输入的要求见下方“输入数据格式”。

之所以选择将数据输入txt文档，是居于以下几个原因：

考虑到用户所要求的AOE网数据较多，相比于在程序运行过程中输入数据，将数据输入txt文档再由程序读取更为方便。

‚在程序运行过程中输入数据，极有可能由于疏忽输入了错误的数据，于是只能关闭程序，从头再来，浪费时间浪费精力。

ƒ程序运行的结果，在运行界面显示的同时，也会输入到同一txt文档中，便于用户后期查看运行结果。

输入数据格式：

start       end         activity        time

   活动起点  活动终点  AOE网中的某一活动  活动时间

附注：每一活动占一行，每个数据之间用空格隔开。

         ‚所有数据均为数字，即活动、事件的标号均为数字。

         ƒ从开始点标号为1开始，按从左到右从上到下的顺序给每个顶点标 号，一直到结束点。

2、运行程序。按照程序运行界面的汉字提示，一步一步运行程序。当程序运行结束了，用户可以查看txt文档来查看运行结果。

3、程序运行的结果，是给出所有的关键活动以及对应数据。

输出数据格式：

activity   start    end     s_earliest_time   e_latest_time

关键活动 活动起点 活动终点 起点最早发生时间 终点最迟发生时间

附注：每一活动占一行，每个数据之间用空格隔开。

  ‚由于关键活动的最早、最迟发生时间相同，故而选择输出关键活动起点最早发生时间，终点最迟发生时间，以用来互相比较。

//AOE
#include<cstdio>
using namespace std;
//define linkedstack
struct snode
{
	int data;
	struct snode *next;
};
class lstack
{
	public:
		lstack();
		~lstack();
		void pushstack(int x);
		int popstack();
		snode *top;	
};
lstack::lstack()
{
	top=NULL;
}
lstack::~lstack()
{
	
}
void lstack::pushstack(int x)
{
	snode *s;
	s=new snode;
	s->data=x;
	s->next=top;
	top=s;
}
int lstack::popstack()
{
	snode *u;
	int x;
	if(top==NULL)
		return 0;
	else
	{
		x=top->data;
		u=top;
		top=top->next;
		delete u;
		return x;
	} 
}
//define graph
struct group
{
	int start;
	int end;
	int thing;
	int time;
};
struct enode
{
	int adjver;
	int data;
	struct enode *enext;
};
struct cenode
{
	int adjver;
	int data;
	struct cenode *cenext;
};
struct vnode
{
	int data;
	enode *ehead;
	cenode *cehead;
};
class graph
{
	public:
		graph(int x,int y);
		~graph();
		void creategraph(group test[]);
		void getindegrees(int ind[]);
		void getoutdegrees(int outd[]);
		void deletegraph();
		int vernum;
		int arcnum;
		group test[100];
		vnode verlist[100];
};
graph::graph(int x,int y)
{
	vernum=x;
	arcnum=y;
	for(int i=1;i<=vernum;i++)
	{
		verlist[i].data=i;
		verlist[i].ehead=new enode;
		verlist[i].ehead->enext=NULL;
		verlist[i].cehead=new cenode;
		verlist[i].cehead->cenext=NULL;
	}
}
graph::~graph()
{

}
void graph::creategraph(group test[])
{ 
	for(int j=1;j<=vernum;j++)
	{
		for(int i=1;i<=arcnum;i++)
		{
			if(test[i].start==verlist[j].data)
			{
				enode *etemp;
				etemp=new enode;
				etemp->adjver=test[i].end;
				etemp->data=test[i].time;
				etemp->enext=verlist[j].ehead->enext;
				verlist[j].ehead->enext=etemp;
			}
		}
		for(int i=1;i<=arcnum;i++)
		{
			if(test[i].end==verlist[j].data)
			{
				cenode *cetemp;
				cetemp=new cenode;
				cetemp->adjver=test[i].start;
				cetemp->data=test[i].time;
				cetemp->cenext=verlist[j].cehead->cenext;
				verlist[j].cehead->cenext=cetemp;
			}
		}
	}
}
void graph::getindegrees(int ind[])
{
	cenode *cep;
	for(int i=1;i<=vernum;i++)
	{
		ind[i]=0;
		cep=verlist[i].cehead->cenext;
		while(cep!=NULL)
		{
			ind[i]++;
			cep=cep->cenext;
		}
	}
}
void graph::getoutdegrees(int outd[])
{
	enode *ep;
	for(int i=1;i<=vernum;i++)
	{
		outd[i]=0;
		ep=verlist[i].ehead->enext;
		while(ep!=NULL)
		{
			outd[i]++;
			ep=ep->enext;
		}
	}
}
void graph::deletegraph()
{
	for(int i=1;i<=vernum;i++)
	{
		while(verlist[i].ehead->enext!=NULL)
		{
			enode *eu;
			eu=verlist[i].ehead->enext;
			verlist[i].ehead->enext=eu->enext;
			delete eu;
		}
		delete verlist[i].ehead;
		while(verlist[i].cehead->cenext!=NULL)
		{
			cenode *ceu;
			ceu=verlist[i].cehead->cenext;
			verlist[i].cehead->cenext=ceu->cenext;
			delete ceu;
		}
		delete verlist[i].cehead;
	}
}
//main program
#include<iostream>
#include<fstream>
#include<cstdio>
using namespace std;
int count;
bool topo(int x,lstack s,int ind[],int e[],graph g);
void ctopo(int x,lstack s,int outd[],int e[],int l[],graph g);
void aoe(int x,int y,int cv[],int ca[],lstack s,int outd[],int e[],int l[],graph g);
int main()
{
	cout<<"please build a file named as xxx.txt in the program folder"<<endl;
	cout<<"please input data in rules"<<endl;
	cout<<"are you ready?if so,click enter"<<endl;
	system("pause");
	int x,y,ind[100],outd[100],e[100],l[100],cv[100],ca[100];
	lstack s;
	cout<<"please input how many events and activities are"<<endl;
	cin>>x>>y;
	graph g(x,y);
	string filename;
	cout<<"please input the filename you just built"<<endl;
	cin>>filename;
	ifstream infile;
	infile.open(filename.c_str());
	if(!infile.is_open())
	{
		cerr<<"cannot read file,please restart"<<endl;
		return 0;
	}
	else
	{
		for(int i=1;i<=y;i++)
			infile>>g.test[i].start>>g.test[i].end>>g.test[i].thing>>g.test[i].time;
	}
	infile.close();
	cout<<"succeed to read file,please click enter"<<endl;
	system("pause");
	ofstream outfile;
	outfile.open(filename.c_str(),ios::app);
	outfile<<endl;
	g.creategraph(g.test);
	g.getindegrees(ind);
	g.getoutdegrees(outd);
	if(topo(x,s,ind,e,g))
	{
		cout<<"topologicalsort succeed"<<endl;
		outfile<<"topologicalsort succeed"<<endl;
		cout<<"the needed time of AOE is "<<e[x]<<endl;
		outfile<<"the needed time of AOE is "<<e[x]<<endl;
		ctopo(x,s,outd,e,l,g);
		aoe(x,y,cv,ca,s,outd,e,l,g);
		cout<<"there are "<<count<<" critical activities"<<endl;
		outfile<<"there are "<<count<<" critical activities"<<endl;
		cout<<"activity"<<"    "<<"start"<<"    "<<"end"<<"    "<<"s_earliest_time"<<"    "<<"e_latest_time"<<endl;
		outfile<<"activity"<<"    "<<"start"<<"    "<<"end"<<"    "<<"earliest_time"<<"    "<<"latest_time"<<endl;
		for(int i=count;i>=1;i--)
		{
			cout<<g.test[ca[i]].thing<<"            "<<g.test[ca[i]].start<<"        "<<g.test[ca[i]].end<<"            "<<e[g.test[ca[i]].start]<<"            "<<l[g.test[ca[i]].end]<<endl;
			outfile<<g.test[ca[i]].thing<<"            "<<g.test[ca[i]].start<<"        "<<g.test[ca[i]].end<<"            "<<e[g.test[ca[i]].start]<<"            "<<l[g.test[ca[i]].end]<<endl;
		}
		outfile.close();
		g.deletegraph();
		return 0;
	}
	else
	{
		cout<<"topologicalsort fail"<<endl;
		outfile<<"topologicalsort fail"<<endl;
		outfile.close();
		g.deletegraph();
		return 0;
	}
}
bool topo(int x,lstack s,int ind[],int e[],graph g)
{
	for(int i=1;i<=x;i++)
		e[i]=0;
	int v1,v2,vcount=0;
	for(int i=1;i<=x;i++)
	{
		if(ind[i]==0)
			s.pushstack(i);	
	}
	while(s.top!=NULL)
	{
		v1=s.popstack();
		vcount++;
		enode *eq;
		eq=g.verlist[v1].ehead->enext;
		while(eq!=NULL)
		{
			v2=eq->adjver;
			ind[v2]--;
			if(e[v1]+eq->data>e[v2])
				e[v2]=e[v1]+eq->data;
			if(ind[v2]==0)
				s.pushstack(v2);
			eq=eq->enext;
		}
	}
	if(vcount==x)
		return true;
	else
		return false;
}
void ctopo(int x,lstack s,int outd[],int e[],int l[],graph g)
{
	for(int i=x;i>=1;i--)
		l[i]=e[x];
	int v1,v2;
	for(int i=x;i>=1;i--)
	{
		if(outd[i]==0)
			s.pushstack(i);
	}
	while(s.top!=NULL)
	{
		v1=s.popstack();
		cenode *ceq;
		ceq=g.verlist[v1].cehead->cenext;
		while(ceq!=NULL)
		{
			v2=ceq->adjver;
			outd[v2]--;
			if(l[v1]-ceq->data<l[v2])
				l[v2]=l[v1]-ceq->data;
			if(outd[v2]==0)
				s.pushstack(v2);
			ceq=ceq->cenext;
		}
	}
}
void aoe(int x,int y,int cv[],int ca[],lstack s,int outd[],int e[],int l[],graph g)
{
	int num=0;
	for(int i=x;i>=1;i--)
	{
		if(e[i]==l[i])
		{
			num++;
			s.pushstack(i);
		}	
	}
	count=num;
	for(int j=1;j<=num;j++)
		cv[j]=s.popstack();
	for(int i=1;i<=num;i++)
	{
		for(int j=1;j<=y;j++)
		{
			if(g.test[j].start==cv[i])
			{
				for(int k=1;k<=num;k++)
				{
					if(g.test[j].end==cv[k])
						s.pushstack(j);
				}
			}
		}
	}
	for(int i=1;i<=num;i++)
		ca[i]=s.popstack();	
}

Journing
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
(数据结构)AOE网求关键路径
oorik的博客
03-29 6682
AOE网是以边表示活动的有向无环网，在AOE网中，具有最大路径长度的路径称为关键路径，关键路径表示完成工程的最短工期。 关键路径是指在AOE网中从源点到汇点路径最长的路径。这里的路径长度是指路径上各个活动持续时间之和。在AOE网中，有些活动是可以并行执行的，关键路径其实就是完成工程的最短时间所经过的路径。关键路径上的活动称为关键活动。(关键路径可能不止一条) 首先我们需要明白以下四个概念属性: Ve[i]：从源点到顶点vi的最长路径长度，称为事件vi的最早发生时间，记作ve(i)。求解ve(i)可以从
AOE-网 关键路径
weixin_52963585的博客
12-28 5477
关键路径：在AOE-网中，从始点到终点具有最大路径长度（该路径上的各个活动所持续的时间之和）的路径称为关键路径。 关键活动：关键路径上的活动称为关键活动。 关键路径可能不只一条，重要的是找到关键活动 事件Vi 的最早可能开始时间Ve(i) 是从源点V0 到顶点Vi 的最长路径长度。 Ve(i) =Max{Ve(k)+wk,i}（k是i的前驱事件） wk,i是弧<Vk,Vi>的权值,即活动持续时间 事件Vi 的最迟允许开始时间Vl(i) Vl(i)不得迟于其后继事件Vj的最迟发生时间减去活动.
选择题快速求解AOE网的关键路径
u014302425的博客
11-28 7733
#引言 求解AOE网关键路径时，书上的方法为先从源点到汇点求解事件最早发生时间ve，再从汇点到源点求解事件最迟发生时间vl，再利用ve和vl求解每个活动的最早开始时间e(i)和最迟开始时间l(i)，e(i)和l(i)相等的活动则为关键活动，他们一起组成的从源点到汇点的路径即为关键路径。 王道的书上在举例子的时候，备注了一小行话：“如果这是一道选择题，根据上述求ve()的过程就已经能知道关键路径。”，但并没有展开讲如何确定。本文就补充说明一下。 #求法 这里直接举例给出求法 如下AOE图，我们从V1
【笔记】AOE网与关键路径
热门推荐
time-space的博客
12-02 4万+
AOE网 关键路径 求关键路径的算法实现
关键路径AOE网（python实现）
sfhzd的博客
07-01 807
python实现关键路径
【数据结构】选择题快速求解AOE网的关键路径
weixin_45827203的博客
06-30 931
数据结构 选择题快速求解关键路径
Python递归解决AOE网络最长路关键路径的问题
jackshenonly的专栏
04-16 3368
Python递归解决AOE网络最长路关键路径的问题 一鼓作气，再来一发 这是某同学在某公式宣讲会中笔试部分的一题，如下图： 如图：每一个项目都有完成时间和若干个前置条件，求总项目（或每一个项目）的最短完成时间。 上代码：class Pro: def __init__(self,pro_id,require_time,previous,pro_list): self.pro_i
AOE网求关键路径（关键活动）
玩转Java
03-22 2937
AOE网求关键路径（关键活动）： AOE网求解关键路径，所需的是有向无环图，注意的是，只有一个源点，有一个汇顶点，然后关键路径不一定只有一条。注意，这里要理解： 顶点：事件 边：活动 还有四个数组下面有介绍： 代码如下： #include <stdio.h> #include <malloc.h> #define inf 330 #define max 50 typedef struct node{ int adjvex; int weight; //权值 struct
C语言AOE网、关键路径
记录学习点滴
05-01 3833
目录 1.AOE网（Activity On Edge Network） 1.1AOE网的概念 1.2AOE网两个顶点 2.关键路径 2.1关键路径的概念 2.2关键路径的几点说明 2.3关键路径的求解步骤 2.4关键路径求解示例 1.AOE网（Activity On Edge Network） 1.1AOE网的概念 若在带权的有向图中，用有向边表示活动（子工程），边上的权值表...
【C++】C++中的find方法介绍
qq_35902025的博客
07-25 383
find 函数是 std::string 类中非常有用的成员函数之一，它提供了灵活的方式来查找子字符串或字符。使用 npos 可以检查查找操作是否成功。
《Cross-Modal Dynamic Transfer Learning for Multimodal Emotion Recognition》
buyaotutou的博客
07-25 1133
例如：第一章 Python 机器学习入门之pandas的使用文章链接Multimodal Emotion Recognition is an important research area for developing human-centric applications, especially in the context of video platforms. Most existing models have attempted to develop sophisticated fusion tech
背单词工具(C++)
zeyeqianli的博客
07-24 3256
【代码】背单词工具(C++)
C++ //练习 15.28 定义一个存放Quote对象的vector，将Bulk_quote对象传入其中。计算vector中所有元素总的net_price。
Made in Code
07-25 611
C++ Primer（第5版） 练习 15.28
C语言100基础拔高题（3）
2303_78660417的博客
07-23 948
解题思路：通过switch语句来判断第一个字母，如果遇到字母相同的，在case语句中继续使用if语句来进行第二个字母的判断。解题思路：首先通过判断得出它是几位数，接着有几位数就输出几次，每次都输出最右边的数字。解题思路：我们这里假设它是按照从小到大的顺序进行排序，首先判断它是否大于最右边的数，如果小于，则考虑插入到中间的情况。解题思路：质数又称素数，有无限个。解题思路：通过设置一个新数组，来接收除了要删除字母以外的其他字母。解题思路：得到输入的5位数的个位，十位，千位，万位上的数字，再对其进行比较。
C++基础（4.内存管理）
最新发布
2301_79903399的博客
07-25 343
对于p2和p3开辟的空间如同，开辟空间后对p3来说返回的位置如图（因为p2没有写析构函数同时也没有动态申请的空间需要析构于是编译器就优化掉了，对于p2的delete也就没有问题）。当时对于p3来说在头部有额外开辟的空间 ，加了方括号才会向前偏移到正确的位置释放，而不加方括号就会在如图位置析构一次，而开辟的空间是不能部分析构的所以会报错。对于new申请的空间如果失败了那么就会抛异常跳过后面的代码。对于写了析构函数的类系统在开空间时候会在头上多开4个字节来记录个数来调用析构函数。
C语言系统调用linux文件系统
C or CPP
07-25 782
在C语言中，openwrite和read函数是系统调用（system calls），它们直接由操作系统提供，用于底层的文件操作。这些函数是UNIX和类UNIX系统（如Linux）中的标准接口，不同于C标准库中的文件操作函数（如fopenfwrite和fread。
UE5 C++跑酷练习（Part2）
m0_64217692的博客
07-23 593
一.首先GameMode里有Actor数组，组装直线路，和左右路。
C++五子棋（未做完，但能玩，而且还不错）
LiXinLong_LXL_13的博客
07-23 3729
代码放下面了，关于步骤介绍的我以后再完善一下。
"AOE网络关键路径问题解决方案及程序设计
因此，对于这个问题，需要对AOE网进行建模和计算，同时需要利用拓扑排序和求解关键路径的方法，最终得出完成整项工程至少需要的时间以及整项工程中的关键活动。 综上所述，关键路径问题是一个复杂的优化问题，涉及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值