数据结构_图的拓扑排序和关键路径

最新推荐文章于 2022-12-07 21:33:06 发布
最新推荐文章于 2022-12-07 21:33:06 发布
阅读量324 收藏 4
点赞数 1
分类专栏： 数据结构（c语言版）严蔚敏 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44068234/article/details/119673316
版权
本文详细介绍了数据结构中的有向无环图（DAG图）及其在项目管理中的应用，包括拓扑排序和关键路径算法。拓扑排序用于判断有向图是否存在环并生成排序序列，关键路径算法则用于确定工程项目的最短完成时间及关键活动。文中提供了完整的算法思想和代码实现，包括使用邻接矩阵存储图、链式栈辅助操作，以及事件的最早和最迟发生时间计算。
摘要由CSDN通过智能技术生成

数据结构_图的拓扑排序和关键路径

思考在一些项目和工程中，完成一些任务之前需具备一些先决条件；或者是已经完成了某些活动才能开始另一项活动。引入数据结构中的一种特殊图来表示

一个无环的有向图被称为有向无环图（DAG图）。在图中用顶点表示活动，用弧表示活动的优先关系的DAG图被称为顶点表示活动的网，简称AOV-网（activity on vertex）。

本文的图存储结构使用的是图的邻接矩阵，在算法的实现大同小异，读者可自行修改。也可以参考本专栏的对应知识点—数据结构_图

另外会借助的数据结构有栈，也可参考—— 数据结构_栈和队列

拓扑排序

算法思想

前述AOV-网必须满足是DAG图，所以需要对于一个有向图进行判断它是否有环，方式是拓扑排序。拓扑排序就是将AOV-网中的所有顶点排成一个线性序列，该序列需要满足：如果在AOV-网中存在顶点Vi 到 Vj 的路径，则在该序列中Vi 必在Vj 前。

对于有向图有无环的检验，重点在对顶点入度的检验。
①如果是图的起点，那么它的入度必定为0
②如果图中不存在环，那么消去一个入度为 0 的顶点和以它作为弧尾的所有弧，则必然会存在或产生一个入度为 0 的顶点
③反复②操作，消去入度为 0 的顶点时将它输出，那么如果是有向无环图最后一定会产生一个关于图中所有顶点的序列；反之，如果存在有顶点未输出，那么图中含有环。

代码实现

①调用一个数组来存储顶点的入度，首次用图来初始化顶点的入度，然后通过消除一个入度为0的顶点和将它所在弧的弧头的顶点的入度-1（也就是消除顶点和以该顶点作为弧尾所在的弧）
②因为需要对入度为0的顶点进行①的操作，所以借助一些数据结构将入度为0的结点存储，不然得不断遍历存储顶点入度得数组，时间复杂度增加。辅助的数据结构可以选择栈，队列甚至链表都可以。我们需要保证的是最后经过①操作的反复实现后，遍历入度为0的顶点数是等于图的顶点数目的，这就保证没有回路。

/ ========================================================
/ 拓扑排序实现
/ ========================================================

int indegree[MAX];              //记录各个顶点的入度
int Ts[MAX];                    //记录排序后的顶点序号序列

void Tsort(G_Amatreix g) {
	int m;                                       
	for (int i = 0; i < g.n; ++i) {     //初始化入度数组           
		m = 0;
		for (int j = 0; j < g.n; ++j) {
			if (g.E[j][i] != Maxint)
				++m;
		}
		indegree[i] = m;
	}

	Lkstack s;
	Lkstackinit(s);
	int m1 = 0;                         //记录输出的顶点数目
	for (int i = 0; i < g.n; ++i) {     //将入度为0的入栈
		if (indegree[i] == 0)
			Push(s, i);
	}

	while (s) {  //栈不为空时,顶点出栈输出并将以它作为弧尾的弧的弧头顶点入度-1
		int i;
		Pop(s, i);
		Ts[m1] = i;
		++m1;

		for (int j = 0; j < g.n; ++j) {     // 弧头顶点入度-1
			if (g.E[i][j] != Maxint) {
				if (--indegree[j] == 0)
					Push(s, j);
			}	
		}
	}

	if (m1 < g.n)
		printf("含有回路");
	else {
		for (int i = 0; i < g.n; ++i)
			printf("%c\t", g.V[Ts[i]]);
	}

	printf("\n");
	Lkstackfree(s);               //链式栈的释放
}

关键路径

思考在一些工程开始后，一些项目同时进行，每个项目需要的时间不同，而且需要某几个项目都结束后才可以开始下一个项目，所有的项目都完成后工程才算结束。那么从整个工程来看，一定存在一条路径上的所有项目完成后，该工程就结束了（也就是该项目的时间花销总和之内，所有的项目都能完成）。将工程起点看出源点（入度为0），将工程的结束点看出汇点（出度为0），上述路径的带权路径长度就是整个工程需要的时间总合，被称为关键路径，路径上的活动被称为关键活动，它们直接影响者工程的总时间。

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

算法思想

  1. 算法思想

关键路径的四个描述
①事件Vi的最早发生时间：进入事件Vi的每一个前需活动都结束，事件才可以发生。所以事件的最早发生时间是源点到Vi的最长路径长度。起点时间的最早发生时间为0。
在这里插入图片描述
如上图：对于图中E事件的发生必须A，C，D事件都发生，而两条路径分别完成的时间为10（a3+a4），8（a2+a5）。所以时间 10 之后这三个事件都完成了。即选择路径长度最长的作为事件Vi的最早发生时间。最后一个顶点的最早发生时间就是整个工程的完成所需的时间总和，选择的路径就是关键路径（上图中为F，关键路径为{A,C,E,F},所需时间为14，关键活动为{a3,a4,a7}）。
②事件Vi的最迟发生时间：事件Vi的完成时间不能耽误后序事件的发生，所以最迟发生时间为所有Vi的后续事件Vj的最迟发生时间减去对应活动<Vi，Vj>的权值时间中的最小值。最迟时间的确认需要在①的基础把所有顶点的最早发生时间求出后，回退求事件的最迟发生时间。
在这里插入图片描述
如上图，由①得到的最后图的关键路径为{A,C,E,F}，所需时间为14，关键活动为{a3,a4,a7}。根据定义得事件的最迟时间E = 10，C = 7, B = 9。而由{A,C,E,F}路径得A = 0，和{A,B,F}路径得A = 3中的最小值A = 0。可以发现，在关键路径上的事件的最迟和最早发生时间是相同的；相对于不是关键路径上的事件其存在的差值为该路径和关键路径上的总差值。
③活动a = <vi，vj>的最早开始时间：因为活动的开始是对应事件的发生才能进行，所以活动的最早开始时间等于事件Vi的最早发生时间。
④活动a = <vi，vj>的最晚开始时间：事件Vj最迟发生时间减去<vi , vj>活动的持续时间。相等于事件Vi的最迟发生时间。
可以说图中活动的最早、最晚开始时间是图中事件的最早、最迟发生时间在活动（弧）上的另一种体现。这样我们就可以实现操作事件（也就是顶点）来代替活动（弧）的过程。通过对于整个图中的事件的的最早、最迟发生时间的求值，然后其中事件的这俩个时间相同的就是关键路径上的事件。

  1. 算法实现

需要借助的数据结构
根据上述实现的描述，对于整个工程的顶点，是按照一定顺序对它的事件的最早、迟发生时间进行求值的。而且这个求值顺序是按照前需事件完成后才能开始的，而且整个工程只有一个源点和汇点不能有回路，这就涉及前面的拓扑排序的排序思想。所以这个求值顺序就是拓扑排序求得的顺序。
①一维数组Ve[ i ] ： 事件Vi的最早发生时间
ve(0) = 0
ve(i) = Max{ ve(k)+wk,i } <vk，vi>∈T，1≤i≤n−1，wk为<vk，vi>上活动的时间消耗
②一维数组VL[ i ] ： 事件Vi的最迟发生时间
vL( n−1 ) = ve( n−1 )
vL(i) = Min{ vL(k)−wi,k } <vi，vk>∈S，0≤i≤n−2
③一维数组TS[ i ] : 记录拓扑序列的顶点序号。
求出来的两个数组后，就可以根据事件最早、迟发生时间和活动的最早、晚开始时间之间关系求出关键活动、关键路径。

代码实现

/ ========================================================
/ 关键路径实现
/ ========================================================

int Ve[MAX];           //记录事件的最早发生时间
int VL[MAX];            //记录事件的最迟发生时间

bool Cpath(G_Amatreix g) {
	if (!Tsort(g))                     //拓扑排序检查是否有回路，并生成排序序列
		return false;

	int n = g.n;   
	//因为要更新比较的是最大值，所以每个顶点先赋初值为这图中能存在的最小值。
	for (int i = 0; i < n; ++i)       //初始化每个事件的最早发生时间为 0
		Ve[i] = 0;

	int m = 0;
	int i = 0;
	for (; i < n; ++i) {              //从拓扑排序序列的第一项开始对顶点更新事件的最早发生时间
		m = Ts[i];
		for (int j = 0; j < n; ++j) {
			if (g.E[m][j] != Maxint) {                   //存在活动时更新事件用活动的时间消耗的最大值
				if (Ve[m] + g.E[m][j] > Ve[j])
					Ve[j] = Ve[m] + g.E[m][j];
			}
		}
	}

//因为要更新比较的是最小值，所以每个顶点先赋初值为这图中能存在的最大值。
	for (i = 0; i < n; ++i)           //初始化每个事件的最迟发生时间为 最后的总消耗时间
		VL[i] = Ve[n - 1];

	for (i = n - 1; i >= 0; --i) {     //从拓扑排序序列的最后一项逆序对顶点更新事件的最迟发生时间
		m = Ts[i];
		for (int j = 0; j < n; ++j) {      
			if (g.E[m][j] != Maxint) {
				if (VL[j] - g.E[m][j] < VL[m])          //存在活动时更新事件用活动的时间消耗的最小值
					VL[m] = VL[j] - g.E[m][j];
			}
		}
	}

	for (i = 0; i < n; ++i)               //找出活动中最早开始时间和最迟开始时间相同的,就是关键活动
		for (int j = 0; j < n; ++j) 
			if (g.E[i][j] != Maxint) {
				int e = Ve[i];
				int L = VL[j] - g.E[i][j];
				if (e == L)
					printf("<%c,%c>\t", g.V[i], g.V[j]);
			}
	
	printf("\n");

}

完整代码

  1. 所需头文件
    ①GAmatrix.h 图的邻接矩阵头文件
///GAmatrix.h
#pragma once
#include<stdio.h>
#define Maxint 32767
#ifndef MAX
#define MAX 20
#endif // MAX

typedef char VertexType;
typedef int Edgetype;

typedef struct {
	VertexType V[MAX];
	Edgetype E[MAX][MAX];
	int n, e;
}G_Amatreix;

//创建图
void CreateG(G_Amatreix& g);

//找到顶点在顶点集中的标号
int LocateV(G_Amatreix g, VertexType v);

②Lkstack.h 链式栈的头文件

///Lkstack.h
#pragma once

#include<stdbool.h>
#include<stdio.h>

#ifndef Item
typedef struct item {
	//数据项
	int data;

	bool operator==(const item& a) {
		return data == a.data;
	}
}Item;

#endif // !Item

//栈数据元素（更改数据元素，修改基本元素结构体和接口的实现即可）

typedef struct Stack{
	Item e;
	struct Stack* next;
}Stack, *Lkstack;

//栈初始化
bool Lkstackinit(Lkstack& L);

//入栈
bool Push(Lkstack& L, Item e);

//出栈
bool Pop(Lkstack& L, Item& e);

//栈取值
bool GetItem(const Lkstack L, Item& e);
  1. 主函数测试c文件
#include<stdio.h>
#include<stdlib.h>
#define Item int 
#include"Lkstack.h"
#include"GAmatrix.h"

/ ========================================================
/ 链式栈接口实现
/ ========================================================
//栈初始化
bool Lkstackinit(Lkstack& L) {
	L = NULL;
	return true;
}

//入栈
bool Push(Lkstack& L, Item e) {
	Lkstack p = new Stack;
	p->e = e;
	p->next = L;
	L = p;
	return true;
}

//出栈
bool Pop(Lkstack& L, Item& e) {
	if (!L)
		return false;
	e = L->e;
	Lkstack p = L;
	L = L->next;
	delete p;
	return true;
}

//栈取值
bool GetItem(const Lkstack L, Item& e) {
	if (!L)
		return false;
	e = L->e;
	return true;
}

void Lkstackfree(Lkstack& L) {
	Lkstack p = NULL;
	while (L) {
		p = L->next;
		delete L;
		L = p;
	}
	if(!p)
		printf("freed");
}

/// ===============================================
/// 图邻接矩阵接口实现
/// ===============================================
//创建图
void CreateG(G_Amatreix& g) {
	printf("input n , e:\n");
	scanf_s("%d,%d", &g.n, &g.e);
	getchar();
	//初始化V
	for (int i = 0; i < g.n; ++i) {
		printf("input V[%d]:", i);
		scanf_s("%c", &g.V[i], 1);
		char ch = getchar();
		while (ch != '\n')
			ch = getchar();
	}
	//初始化E
	for (int i = 0; i < g.n; ++i) {
		for (int j = 0; j < g.n; ++j) {
			g.E[i][j] = Maxint;                   //创立网是为无穷大，图时为0
		}
	}
	//输入边
	char v1 = 0, v2 = 0;
	int m = 0;;
	int j, k;
	for (int i = 0; i < g.e; ++i) {
		printf("input the edge:(v1 v2 w)\n");
		scanf_s("%c %c %d", &v1, 1, &v2, 1, &m);
		char ch = getchar();
		while (ch != '\n')
			ch = getchar();
		j = LocateV(g, v1);
		k = LocateV(g, v2); 
		g.E[j][k] = m;                      //创立网时为权值w,图时为1
		//g.E[k][j]=g.E[j][k];                 //无向时为对称矩阵

	}


	输出边
	//for (int i = 0; i < g.n; ++i) {
	//	printf("顶点%c:\n", g.V[i]);
	//	for (int j = 0; j < g.n; ++j) {
	//		if (g.E[i][j] != Maxint)
	//			printf("边为<%c,%c>,权值为%d:\n", g.V[i], g.V[j], g.E[i][j]);
	//	}
	//}
}

//找到顶点在顶点集中的标号
int LocateV(G_Amatreix g, VertexType v) {
	int j = 0;
	for (; j < g.n; ++j) {
		if (g.V[j] == v)
			return j;
	}
	return j;
}


/ ========================================================
/ 拓扑排序实现
/ ========================================================

int indegree[MAX];              //记录各个顶点的入度
int Ts[MAX];                    //记录排序后的顶点序号序列

bool Tsort(G_Amatreix g) {
	int m;                                       
	for (int i = 0; i < g.n; ++i) {     //初始化入度数组           
		m = 0;
		for (int j = 0; j < g.n; ++j) {
			if (g.E[j][i] != Maxint)
				++m;
		}
		indegree[i] = m;
	}

	Lkstack s;
	Lkstackinit(s);
	int m1 = 0;                         //记录输出的顶点数目
	for (int i = 0; i < g.n; ++i) {     //将入度为0的入栈
		if (indegree[i] == 0)
			Push(s, i);
	}

	while (s) {  //栈不为空时,顶点出栈输出并将以它作为弧尾的弧的弧头顶点入度-1
		int i;
		Pop(s, i);
		Ts[m1] = i;
		++m1;

		for (int j = 0; j < g.n; ++j) {     // 弧头顶点入度-1
			if (g.E[i][j] != Maxint) {
				if (--indegree[j] == 0)
					Push(s, j);
			}	
		}
	}

	if (m1 < g.n)
		return false;
	else {
		for (int i = 0; i < g.n; ++i)
			printf("%c\t", g.V[Ts[i]]);
		return true;
	}

	printf("\n");
	Lkstackfree(s);
}


/ ========================================================
/ 关键路径实现
/ ========================================================

int Ve[MAX];           //记录事件的最早发生时间
int VL[MAX];            //记录事件的最迟发生时间

bool Cpath(G_Amatreix g) {
	if (!Tsort(g))                     //拓扑排序检查是否有回路，并生成排序序列
		return false;

	int n = g.n;   
	for (int i = 0; i < n; ++i)       //初始化每个事件的最早发生时间为 0
		Ve[i] = 0;

	int m = 0;
	int i = 0;
	for (; i < n; ++i) {              //从拓扑排序序列的第一项开始对顶点更新事件的最早发生时间
		m = Ts[i];
		for (int j = 0; j < n; ++j) {
			if (g.E[m][j] != Maxint) {                   //存在活动时更新事件用活动的时间消耗的最大值
				if (Ve[m] + g.E[m][j] > Ve[j])
					Ve[j] = Ve[m] + g.E[m][j];
			}
		}
	}

	for (i = 0; i < n; ++i)           //初始化每个事件的最迟发生时间为 最后的总消耗时间
		VL[i] = Ve[n - 1];

	for (i = n - 1; i >= 0; --i) {     //从拓扑排序序列的最后一项逆序对顶点更新事件的最迟发生时间
		m = Ts[i];
		for (int j = 0; j < n; ++j) {      
			if (g.E[m][j] != Maxint) {
				if (VL[j] - g.E[m][j] < VL[m])          //存在活动时更新事件用活动的时间消耗的最小值
					VL[m] = VL[j] - g.E[m][j];
			}
		}
	}
	
	printf("\n");

	for (i = 0; i < n; ++i)               //找出活动中最早开始时间和最迟开始时间相同的,就是关键活动
		for (int j = 0; j < n; ++j) 
			if (g.E[i][j] != Maxint) {
				int e = Ve[i];
				int L = VL[j] - g.E[i][j];
				if (e == L)
					printf("<%c,%c>\t", g.V[i], g.V[j]);
			}
	
	printf("\n");

}


int main() {
	G_Amatreix g;
	CreateG(g);
	
	Cpath(g);

	return 0;
}
  1. 测试
    在这里插入图片描述在这里插入图片描述
二次异重构
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【数据结构基础 C++】图论03-以存储顶点和边的文件构造图
m0_47902113的博客
12-08 344
将边的信息放在txt中，以文件形式构造图，单独封装成一个类 #pragma once #include <iostream> #include <fstream> #include <cassert> #include <string> #include <sstream> using namespace std; template<typename Graph> class readGraph { public: //从文件f
数据结构实验9：图的相关操作
u25th_engineer的博客
01-05 6044
                                                目录                                                  实验9 8.1 实验目的 8.2 实验任务 8.3 实验说明 1. 数据文件格式设计 2. 从数据文件创建邻接矩阵表示的图 3. 从数据文件创建邻接表表示的图 4. 图的销毁 8...
数据结构创建邻接表图--从txt文件读取顶点信息
weixin_57362532的博客
09-30 1772
一、主函数 #include "graph.h" int main() { Graph().show_graph(); } //创建邻接表的头文件 #ifndef UNTITLED_GRAPH_H #define UNTITLED_GRAPH_H #include <iostream> #include "vector" #include "readtxt.h" #define MAXSIZE 10 using namespace std; typedef struct
C++读图txt文件，并将数据结构 图显示出来
专心扫地
11-18 1630
目录 整个代码展示 下面分别是图的两个txt文件，现在用C++读取这个文件，并将图显示出来 第一行分别表示图的节点数和边数 13 13 0 5 4 3 0 1 9 12 6 4 5 4 0 2 11 12 9 10 0 6 7 8 9 11 5 3 6 8 0 1 0 2 0 5 1 2 1 3 1 4 3 4 3 5 代码中模板Graph，可以是稀疏图或者稠密的实现，参考...
拓扑排序与关键路径
最新发布
夜槿笙歌的博客
12-07 1379
简单来讲，对于下面这张图，要想访问到B点，就必须先访问A点；要想访问E点，就必须先访问B点和C点…拓扑排序就是在保证各节点的优先级顺序不被打乱的前提下，遍历整张图的节点。拓扑排序形成的拓扑序列不一定只有一条。比如下面这张图的拓扑序列可以是：，也可以是。如果图的所有节点都遍历到了，那么这就是一张无环图；但如果有节点没有被遍历到，那么这张图一定存在环。 拓扑排序的算法流程很简单：从图中找到一个入度为0的节点输出，然后删除这个顶点（包括依赖它的边）。重复此步骤，直到图中不存在入度为0的节点为止。以前面的图为例。在
拓扑排序和关键路径课设
02-08
### 拓扑排序与关键路径的实现及...综上所述，拓扑排序和关键路径算法在实际应用中具有重要的意义。通过对这两个算法的学习与实践，可以更好地理解项目管理和任务调度的基本原理，从而提高工作效率和解决问题的能力。
拓扑排序和关键路径的图形化显示.zip
07-03
数据结构课程设计项目，邻接链表、关键路径以及拓扑排序的图形化显示，主要涉及到的技术有：前端、echarts、electron 给定一个有向图，完成： 建立并显示出它的邻接链表； 对该图进行拓扑排序，显示拓扑排序的结果，...
数据结构课程设计——拓扑排序和关键路径
05-20
数据结构课程设计中，拓扑排序和关键路径是两个重要的概念，它们在计算机科学和工程领域，尤其是在项目管理和网络优化中具有广泛的应用。 拓扑排序是对有向无环图（DAG，Directed Acyclic Graph）的一种线性排序，...
拓扑排序关键路径算法C语言完整代码
01-17
在计算机科学中，拓扑排序和关键路径算法是两种重要的图论概念，广泛应用于项目管理、任务调度等领域。本文将详细介绍这两个概念，并提供一个用C语言实现的完整代码示例。 **拓扑排序(Topological Sorting)** 拓扑...
数据结构ch8-2_；拓扑排序_dijkstra_源码
10-02
总之，拓扑排序和Dijkstra算法都是解决图论问题的关键工具。在数据结构和算法的学习过程中，掌握它们的原理和实现是至关重要的。通过深入学习和实践，你可以更好地应对涉及图数据结构的各种复杂问题。
图的最短路径、拓扑排序和关键路径
05-03
图的最短路径、拓扑排序和关键路径相关算法描述，有c++code
数据结构之图的创建
shu_8708的博客
01-21 2万+
1.图的定义 图(Graph):是由顶点的又穷非空集合和定点之间的边集组成，通常表示为G(V,E)，其中G表示一个图，V是其顶点集合，E是其边集合。 有向图(Directed graphs): 任意两个点之间的边都是有向边。 入度(InDegree)：以顶点为v为头的弧的数目称为入度。 出度(OutDegree)：以顶点v为尾的弧的数目成为出度。 2.图的存储结构 常见
数据结构与算法C++之txt中读入图
恰同学少年的博客
11-21 2607
建立一个ReadGraph.h文件读入txt中存储的图 #include &lt;iostream&gt; #include &lt;ctime&gt; #include &lt;cstdlib&gt; #include "SparseGraph.h" #include "DenseGraph.h" #include "ReadGraph.h" using namespace std; int..
超详细讲解实现拓扑排序、关键路径
weixin_61857742的博客
03-26 5928
今天，小编带着大家来学习图中非常重要的一环，拓扑排序和关键路径！ 首先，我们需要知道的是，拓扑排序是关键路径的基础，正因如此，当我们知道了关键路径在生活中的应用，相信大家也就明白这两个算法的重要性了！ ...
数据结构之图的拓扑排序和关键路径
mrslxw的博客
10-07 997
拓扑排序 百度百科上对拓扑排序的解释：对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序，是将G中所有顶点排成一个线性序列，使得图中任意一对顶点u和v，若边<u,v>∈E(G)，则u在线性序列中出现在v之前。通常，这样的线性序列称为满足拓扑次序(Topological Order)的序列，简称拓扑序列。 图的拓扑排序是解决工程能否顺序执行。 ...
数据结构——掌握求解活动的最早（晚）开始时间
vavid的专栏
10-06 1万+
求解最早开始时间，最晚开始时间，浮动时间
数据结构-----图的拓扑排序和关键路径算法
一个程序渣渣的小后院
12-30 1万+
在介绍拓扑排序和关键路径之前，先引入AOE网络的概念： 该图为一个AOE网，顶点表示事件，如v1，v2，v3...。弧表示活动，如a1，a2，a3...，而每一条边表示的值为完成该活动所需的时间。 比如上图中，完成活动a1需要6个单位的时间，完成活动a3需要5个单位的时间。 AOE网络是一个加权有向图，即每一条边都是带方向且带有权值的。对于一个有向边，箭头指向的点为终点，另一个点则是
有向图建立邻接矩阵并实现拓扑排序
weixin_43956284的博客
07-20 1468
拓扑排序 本排序的图的建立参考之前写的邻接矩阵的建立 因为之前的图建的是无向图，所以建图时只需G->side[vi][vj]=1;一步 #include<stdio.h> #include<stdlib.h> #include<string.h> #define Max 100 //假设包含100个顶点 typedef struct{ //包含权的邻接矩阵...
关键路径与最短路径解析
热门推荐
basycai的博客
02-29 3万+
1.最短路径：如果从某顶点出发，这个顶点称为源点，经图的边到达另一顶点，这个顶点称为终点，所经过的路径不止一条，找出一条路径使的沿此路径上各边的权值之和为最小。（从源点到终点走得最短的路线权值之和）（默认为1） 2.关键路径：采用边表示活动(Activity On Edge)网络，简称AOE网络。每个顶点代表一个事件，事件说明某些活动或某一项活动的完成，边表示活动，权表示活动持续的时间（
C语言实现关键路径算法：代码与拓扑排序详解
在这个文档中，主要讨论的是C语言中的关键路径问题及其在工程中的应用，结合了数据结构中的图和拓扑排序。首先，我们来理解什么是关键路径。在项目管理或工程网络图中，关键路径是指从起点到终点的最长路径，它决定...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值