【图的应用四：关键路径】- 用 C 语言实现关键路径

最新推荐文章于 2024-01-03 19:51:34 发布
最新推荐文章于 2024-01-03 19:51:34 发布
阅读量1k 收藏 27
点赞数 19
分类专栏： 数据结构 文章标签： c语言 数据结构 图
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/melonyzzZ/article/details/135178823
版权

目录

一、AOE-网

二、算法的实现

2.1 - ALGraph.h

2.2 - ALGraph.c

2.3 - Test.c

 

一、AOE-网

与 AOV-网相对应的是 AOE-网（Activity On Edge），即以边表示活动的网。AOE-网是一个带权的有向无环图，其中，顶点表示事件、弧表示活动，权表示活动持续的时间。通常，AOE-网可用来估算工程的完成时间。

例如，下图所示为一个有 11 项活动的 AOE-网。其中有 9 个事件 v0, v1, ..., v8，每个事件表示在它之前的活动已经完成，在它之后的活动可以开始。例如，v0 表示整个工程开始，v8 表示整个过程结束，v4 表示 a4 和 a5 已经完成，a7 和 a8 可以开始了。与每个活动相联系的数是执行该活动所需的时间，比如，活动 a1 需要 6 天，a2 需要 4 天等。

AOE-网在工程计划和经营管理中有广泛的应用，针对实际的应用问题，通常需要解决以下两个问题：

  1. 估算完成整项工程至少需要多少时间。

  2. 判定哪些活动是影响工程进度的关键。

工程进度控制的关键在于抓住关键活动。在一定范围内，非关键活动的提前完成对于整个工程的进度没有直接的好处，它的稍许拖延也不会影响整个工程的进度。工程的指挥者可以把非关键活动的人力和物力资源暂时调给关键活动，加速其进展，以使整个工程提前完工。

由于整个工程只有一个开始点和一个完成点，故在正常的情况（无环）下，网中只有一个入度为零的点，称作源点，也只有一个出度为零的点，称作汇点。在 AOE-网中，一条路径各弧上的权值之和称为该路径的带权路径长度（后面简称路径长度）。要估算整项工程完成的最短时间，就是要找一条从源点到汇点的带权路径长度最长的路径，称为关键路径。关键路径上的活动叫做关键活动，这些活动是影响工程进度的关键，它们的提前或拖延使整个工程提前或拖延。

例如，在上图中，v0 是源点，v8 是汇点，关键路径有两条：(v0, v1, v4, v6, v8) 和 (v0, v1, v4, v7, v8)，长度均为 18，关键活动为 (a1, a4, a7, a10) 和 (a1, a4, a8, a11)。比如，关键活动 a1 需要 6 天完成，如果 a1 提前 1 天，整个工程也可以提前 1 天完成。所以不论估算工期，还是研究如何加快工程进度，主要问题就在于要找到 AOE-网的关键路径。

如何确定关键路径，首先定义 4 个描述量。

  1. 事件 vi 的最早发生时间 ve(i)：

    进入事件 vi 的每一活动都结束，vi 才可发生，所以 ve(i) 是从源点到 vi 的最长路径长度。

    求 ve(i) 的值，可根据拓扑顺序从源点开始向汇点递推。通常将工程的开始顶点事件 v0 的最早发生时间定义为 0，即：ve(0) = 0 \\ ve(i) = Max\{ ve(k) + w_{k,i} \} <v_k, v_i> \in T, 1 \le i \le n-1

    其中，T 是所有以 vi 为头的弧的集合，w_{k, i} 是弧 <vk, vi> 的权值，即对应活动 <vk, vi> 的持续时间。

  2. 事件 vi 的最迟发生事件 vl(i)：

    事件 vi 的发生不得延误 vi 的每一后继事件的最迟发生事件。为了不拖延工期，vi 的最迟发生时间不得迟于其后继事件 vk 的最迟发生事件减去活动 <vi, vk> 的持续事件。

    求出 ve(i) 后，可根据逆拓扑顺序从汇点开始向源点递推，求出 vl(i)。vl(n-1) = ve(n-1) \\ vl(i) = Min\{ vl(k) - w_{i, k} \} <v_i, v_k> \in S, 0 \le i \le n-2

    其中，S 是所有以 vi 为为的弧，w_{i, k} 是弧 <vi, vk> 的权值。

  3. 活动 ai = <vj, vk> 的最早开始时间 ae(i)：

    只有事件 vj 发生了，活动 ai 才能开始，所以活动 ai 的最早开始时间等于事件 vj 的最早发生时间 ve(j)，即：ae(i) = ve(j)

  4. 活动 ai = <vj, vk> 的最晚开始时间 al(i)：

    活动 ai 的开始时间需保证不延误事件 vk 的最迟发生时间。所以活动 ai 的最晚开始时间 al(i) 等于事件 vk 的最迟发生时间 vl(k) 减去活动 ai 的持续时间 w_{j, k}，即：al(i) = vl(k) - w_{j, k}

显然，对于关键活动而言，ae(i) = al(i)。对于非关键活动，al(i) - ae(i) 的值是该工程的期限余量，在此范围内的适度延误不会影响整个工程的工期。

二、算法的实现

由于每个事件的最早发生时间 ve(i) 和最迟发生时间 vl(i) 要在拓扑序列的基础上进行计算，所以关键路径算法的实现要基于拓扑排序算法，我们仍采用邻接表做有向图的存储结构。

2.1 - ALGraph.h

#pragma once

#include <stdbool.h>

typedef int ArcType;
typedef char VertexType;

#define DEFAULT_CAPACITY 2

typedef struct ArcNode
{
	int adjVexPos;
	struct ArcNode* nextArc;
	ArcType weight;
}ArcNode;

typedef struct VertexNode
{
	VertexType vertex;
	ArcNode* firstArc;
}VertexNode;

typedef struct ALGraph
{
	VertexNode* vertices;
	int vSize;
	int aSize;
	int capacity;
}ALGraph;

void ALGraphInit(ALGraph* pg);

void ShowAdjList(ALGraph* pg);

int GetVertexPos(ALGraph* pg, VertexType v);

void InsertVertex(ALGraph* pg, VertexType v);
void InsertArc(ALGraph* pg, VertexType v1, VertexType v2, ArcType weight);

void ALGraphDestroy(ALGraph* pg);

// 拓扑排序
bool TopologicalSort(ALGraph* pg, int* topo);

// 关键路径
void CriticalPath(ALGraph* pg);

2.2 - ALGraph.c

#include "ALGraph.h"
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include "Stack.h"

void ALGraphInit(ALGraph* pg)
{
	assert(pg);
	pg->vSize = pg->aSize = 0;
	pg->capacity = DEFAULT_CAPACITY;

	pg->vertices = (VertexNode*)malloc(sizeof(VertexNode) * pg->capacity);
	assert(pg->vertices);
	for (int i = 0; i < pg->capacity; ++i)
	{
		pg->vertices[i].firstArc = NULL;
	}
}

void ShowAdjList(ALGraph* pg)
{
	assert(pg);
	for (int i = 0; i < pg->vSize; ++i)
	{
		printf("%d %c:>", i, pg->vertices[i].vertex);
		ArcNode* cur = pg->vertices[i].firstArc;
		while (cur)
		{
			printf("%d-->", cur->adjVexPos);
			cur = cur->nextArc;
		}
		printf("NULL\n");
	}
}

int GetVertexPos(ALGraph* pg, VertexType v)
{
	assert(pg);
	for (int i = 0; i < pg->vSize; ++i)
	{
		if (pg->vertices[i].vertex == v)
			return i;
	}
	return -1;
}

void InsertVertex(ALGraph* pg, VertexType v)
{
	assert(pg);
	if (pg->vSize == pg->capacity)
	{
		VertexNode* tmp = (VertexNode*)realloc(pg->vertices, sizeof(VertexNode) * 2 * pg->capacity);
		assert(tmp);
		pg->vertices = tmp;
		for (int i = pg->capacity; i < 2 * pg->capacity; ++i)
		{
			pg->vertices[i].firstArc = NULL;
		}
		pg->capacity *= 2;
	}
	pg->vertices[pg->vSize++].vertex = v;
}

void InsertArc(ALGraph* pg, VertexType v1, VertexType v2, ArcType weight)
{
	assert(pg);
	int pos1 = GetVertexPos(pg, v1);
	int pos2 = GetVertexPos(pg, v2);
	if (pos1 == -1 || pos2 == -1)
		return;

	// 插入 <v1, v2>
	ArcNode* p = (ArcNode*)malloc(sizeof(ArcNode));
	assert(p);
	p->adjVexPos = pos2;
	p->weight = weight;
	// 头插
	p->nextArc = pg->vertices[pos1].firstArc;
	pg->vertices[pos1].firstArc = p;

	++pg->aSize;
}

void ALGraphDestroy(ALGraph* pg)
{
	assert(pg);
	for (int i = 0; i < pg->vSize; ++i)
	{
		ArcNode* cur = pg->vertices[i].firstArc;
		while (cur)
		{
			// 头删
			pg->vertices[i].firstArc = cur->nextArc;
			free(cur);
			cur = pg->vertices[i].firstArc;
		}
	}
	free(pg->vertices);
	pg->vertices = NULL;

	pg->vSize = pg->aSize = pg->capacity = 0;
}

// 拓扑排序
bool TopologicalSort(ALGraph* pg, int* topo)
{
	assert(pg);
	int* indegree = (int*)malloc(sizeof(int) * pg->vSize);
	assert(indegree);
	for (int i = 0; i < pg->vSize; ++i)
	{
		indegree[i] = 0;
	}
	for (int i = 0; i < pg->vSize; ++i)
	{
		ArcNode* cur = pg->vertices[i].firstArc;
		while (cur)
		{
			++indegree[cur->adjVexPos];
			cur = cur->nextArc;
		}
	}

	Stack st;
	StackInit(&st);
	for (int i = 0; i < pg->vSize; ++i)
	{
		if (indegree[i] == 0)
			StackPush(&st, i);
	}

	int cnt = 0;
	while (!StackEmpty(&st))
	{
		int i = StackTop(&st);
		StackPop(&st);
		topo[cnt++] = i;

		ArcNode* cur = pg->vertices[i].firstArc;
		while (cur)
		{
			if (--indegree[cur->adjVexPos] == 0)
				StackPush(&st, cur->adjVexPos);
			cur = cur->nextArc;
		}
	}
	StackDestroy(&st);

	if (cnt == pg->vSize)
		return true;
	else
		return false;
}

// 关键路径
void CriticalPath(ALGraph* pg)
{
	assert(pg);
	int* topo = (int*)malloc(sizeof(int) * pg->vSize);
	assert(topo);
	if (!TopologicalSort(pg, topo))
	{
		printf("网中存在有向环！\n");
		free(topo);
		return;
	}

	int* ve = (int*)malloc(sizeof(int) * pg->vSize);
	int* vl = (int*)malloc(sizeof(int) * pg->vSize);
	assert(ve && vl);

	for (int i = 0; i < pg->vSize; ++i)
	{
		ve[i] = 0;
	}
	// 按照拓扑顺序求每个事件的最早发生时间
	for (int i = 0; i < pg->vSize - 1; ++i)
	{
		int k = topo[i];
		ArcNode* cur = pg->vertices[k].firstArc;
		while (cur)
		{
			if (ve[k] + cur->weight > ve[cur->adjVexPos])
				ve[cur->adjVexPos] = ve[k] + cur->weight;
			cur = cur->nextArc;
		}
	}

	for (int i = 0; i < pg->vSize; ++i)
	{
		vl[i] = ve[topo[pg->vSize - 1]];
	}
	// 按照逆拓扑顺序求每个事件的最迟发生时间
	for (int i = pg->vSize - 2; i >= 0; --i)
	{
		int k = topo[i];
		ArcNode* cur = pg->vertices[k].firstArc;
		while (cur)
		{
			if (vl[cur->adjVexPos] - cur->weight < vl[k])
				vl[k] = vl[cur->adjVexPos] - cur->weight;
			cur = cur->nextArc;
		}
	}

	// 判定每一活动是否为关键活动
	for (int i = 0; i < pg->vSize; ++i)
	{
		ArcNode* cur = pg->vertices[i].firstArc;
		while (cur)
		{
			int ae = ve[i];
			int al = vl[cur->adjVexPos] - cur->weight;
			if (ae == al)
				printf("<%c, %c> 是关键活动\n", pg->vertices[i].vertex, pg->vertices[cur->adjVexPos].vertex);
			cur = cur->nextArc;
		}
	}

	free(topo);
	free(ve);
	free(vl);
}

2.3 - Test.c

#include "ALGraph.h"
#include <stdio.h>

int main()
{
	ALGraph g;
	ALGraphInit(&g);
	InsertVertex(&g, 'A');
	InsertVertex(&g, 'B');
	InsertVertex(&g, 'C');
	InsertVertex(&g, 'D');
	InsertVertex(&g, 'E');
	InsertVertex(&g, 'F');
	InsertVertex(&g, 'G');
	InsertVertex(&g, 'H');
	InsertVertex(&g, 'I');
	InsertArc(&g, 'A', 'B', 6);
	InsertArc(&g, 'A', 'C', 4);
	InsertArc(&g, 'A', 'D', 5);
	InsertArc(&g, 'B', 'E', 1);
	InsertArc(&g, 'C', 'E', 1);
	InsertArc(&g, 'D', 'F', 2);
	InsertArc(&g, 'E', 'G', 9);
	InsertArc(&g, 'E', 'H', 7);
	InsertArc(&g, 'F', 'H', 4);
	InsertArc(&g, 'G', 'I', 2);
	InsertArc(&g, 'H', 'I', 4);
	ShowAdjList(&g);
	printf("\n");

	CriticalPath(&g);

	ALGraphDestroy(&g);
	return 0;
}

melonyzzZ
关注
  • 19
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[图] AOE网-关键路径|关键活动-原理、手算举例、C语言实现
geodoer
08-12 1万+
关键路径 问题 用【有向网】表示一个【施工流图】 1. 【弧上的权值】：表示完成该项目【子工程】所需时间 2. 整个工程【完成的时间】：从【有向图】的【源点】到【汇点】的最长路径 【问】 哪些子工程项是“关键工程” 【解释】 关键工程：这个工作如果推迟完成，它会导致整个工程完成推迟 【定性来谈】该弧上的权值增加，将使有向图上的【最长路径的长度】增加，这个【弧】称之为【关键活动】或...
数据结构_关键路径(C语言)
小黯
06-27 3331
在图结构中，源点到终点的所有路径中，其中具有最大路径长度的路径称为关键路径。
关键路径(完整实例及C语言完整代码实现)
热门推荐
记录博主学到的点滴
08-15 1万+
写在前面：博主是一位普普通通的19届二本大学生，平时最大的爱好就是听听歌，逛逛B站。博主很喜欢的一句话花开堪折直须折，莫待无花空折枝：博主的理解是头一次为人，就应该做自己想做的事，做自己不后悔的事，做自己以后不会留有遗憾的事，做自己觉得有意义的事，不浪费这大好的青春年华。博主写博客目的是记录所学到的知识并方便自己复习，在记录知识的同时获得部分浏览量，得到更多人的认可，满足小小的成就感，同时在写博客的途中结交更多志同道合的朋友，让自己在技术的路上并不孤单。 目录: 1. 2. 3.  &n.
图的关键路径算法 c语言实现
weixin_52787728的博客
10-30 356
main.c #include"Path.h" #include"stack.h" int main() { Hnode *hnode=(Hnode *)malloc(sizeof(Hnode)); InitList(hnode); int Ve[N]; int Vl[N]; Topo(hnode,Ve,Vl); } Path.c #include"Path.h" #include"stack.h" #include<stdio.h> void.
C语言 关键路径（求解过程及算法实现）
m0_73070900的博客
06-07 2823
在项目管理中，关键路径是一个非常重要的概念。通过计算关键路径可以确定项目最短完成时间，并对任务进行优先排序。同时，关键路径也能够帮助项目经理识别风险并采取相应的措施以确保项目能够按时完成。
设计求解AOE网关键路径程序（详细设计，附完整实现代码）
a910247的博客
06-24 778
在进行AOE拓扑排序程序设计开发过程中，我深刻体会到了以下几点：1. 计划和组织能力的重要性：在开始课程设计之前，我充分意识到了计划和组织的重要性。我制定了详细的计划和时间表，明确了每个阶段的任务和时间节点。我将整个课程设计分解为多个小任务，并合理安排了每个任务的时间和资源。这样，我能够更好地掌握整个项目的进度，及时调整和安排，确保项目的顺利进行。2. 需求分析的重要性：在进行课程设计之前，我进行了充分的需求分析。我与用户和相关人员进行了深入的沟通，了解了他们的需求和期望。
zuiduanlujing.rar_C语言 最短路径_最短路径c-c
09-24
C语言是最基础且广泛应用的编程语言之一，适合编写这种算法实现。 在描述中提到，“最短路径 c语言 源程序 可以运行 OK”，这意味着提供的源代码已经过测试，并能够成功执行，找到图中两个节点间的最短路径。这通常...
Dijkstra最短路径算法（C语言实现）
07-09
Dijkstra最短路径算法是一种...总之，Dijkstra最短路径算法是解决图论问题的关键工具之一，而用C语言实现它则能帮助我们更好地理解算法的内部工作原理。通过实际编写和运行代码，可以增强对算法的理解，提升编程能力。
nim-svdpi：SystemVerilog DPI-C标头svdpi.h的小包装
02-04
SystemVerilog是一种广泛使用的硬件描述语言，用于验证和实现复杂的集成电路设计。DPI-C则是SystemVerilog中的一种特性，允许在SystemVerilog代码和C/C++代码之间进行跨域调用，从而实现系统级验证的高效协同。 **...
Linguagem-C:语言C语言
03-31
2. **面向过程**：C语言是一种面向过程的编程语言，强调通过函数来组织代码，实现模块化的程序设计。 3. **类型系统**：C语言支持多种数据类型，包括基本类型（如int、char、float等）和构造类型（如数组、结构体、...
图关键路径(C语言)
09-06
数据结构C语言版里的图关键路径算法实现，代码里有详细注释
关键路径的算法设计与实现(C语言)
05-15
关键路径的算法设计与实现，c语言，可运行.....
关键路径的C实现
01-01
关键路径的C语言实现，文档，代码，通通都在里面，很值得下载的哦
图的关键路径算法
09-18
数据结构中求图的关键路径的c程序，关键路径算法
拓扑排序关键路径算法C语言完整代码
01-17
拓扑排序关键路径算法C语言完整代码,vs2013下编译运行通过
关键路径，你懂的.有向图
03-29
关键路径是一种在项目管理中广泛使用的概念，它用于确定完成项目所需的最短时间。这个概念源于网络图理论，特别是有向图（Directed Acyclic Graph，DAG）的应用。在有向图中，每个节点代表一个任务，每条边表示任务...
C语言实现关键路径
wodemaoheise的博客
12-05 4408
#include #include #define MAX_VALUE 10 #define stackinit 100 #define stackincre 10 #define overflow -2 typedef struct EdgeNode{//边顶点 int index;//该顶点下标 int weight;//权重 struct EdgeNode *nex
关键路径（C语言实现）
最新发布
数据结构和算法教程（C语言版）
01-03 886
实际场景中，对于某项工程中的各个任务以及完成它们的先后次序，我们经常用有向无环网（带权的有向无环图）来表示。图 1 有向无环图图 1 就是一张有向无环网，整张网表示一项工程，顶点 V1~V9 表示工程中的各个任务；弧 a1~a11 表示执行各个任务的先后次序，各个弧的权值表示完成各个任务所需要的时间。类似上面这样，当我们用有向无环网描述某项工程时，数据结构中称这样的网结构为 AOE（Activity On Edge）网，网中的顶点称为“事件”，弧称为“活动”，弧对应的权值代表活动持续的时间。
数据结构C语言版-求关键路径(纯C代码)
caradm的博客
11-05 209
原因是因为拓扑排序可以保证我们活动的依赖关系顺序进行计算,即某个结点的前驱一定位于该结点前。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值