【贪心算法+拓扑排序】求解AOV、AOE关键路径问题（附C++代码实现）

爱吃橘子的图书管理员

已于 2023-12-14 12:27:38 修改

阅读量1k

点赞数 22

文章标签： c++ 算法开发语言图论

于 2023-12-13 20:58:41 首次发布

本文链接：https://blog.csdn.net/m0_71981342/article/details/134980281

版权

AOV网和AOE网

AOV网：在一个表示工程的有向图中，用顶点表示活动，用弧表示活动之间的优先关系，这样的有向图为顶点表示活动的网，我们称为AOV网（Activity On Vertex Network）。

AOE网：在一个表示工程的带权有向图中，用顶点表示事件（如V0），用有向边表示活动（如<v0,v1> = a1），边上的权值表示活动的持续时间，称这样的有向图为边表示的活动的网，简称AOE网（activity on edge network）。

一句话概括：AOV用点表示活动，AOE用边表示活动

AOE网关键路径求解

AOE网的关键路径求解是一个很经典的算法，网上和各种教材上的代码和讲解极为详细，这里不再赘述。

附上自己的实现：

#include<iostream>
#include<stack>
#include<queue>
#define MaxSize 100
#define INF 999
using namespace std;

struct ArcNode {
	int adjvex;
	int weight;
	ArcNode* nextArc;
	ArcNode() :adjvex(-1), weight(-1), nextArc(NULL) {}
	ArcNode(int a, int w) :adjvex(a), weight(w), nextArc(NULL) {}
};

struct VexNode {
	int data;
	ArcNode* firstArc;
	VexNode() :data(-1), firstArc(NULL) {}
};

class AMGraph {
public:
	int vex_num;
	int arc_num;
	VexNode vertics[MaxSize];
	AMGraph() {
		vex_num = 0;
		arc_num = 0;
	}
	void Init() {
		cin >> vex_num >> arc_num;
		for (int i = 1; i <= vex_num; i++) {
			vertics[i].data = i;
		}
		for (int i = 0; i < arc_num; i++) {
			int u = 0, v = 0, w = 0;
			cin >> u >> v >> w;
			ArcNode* p = new ArcNode(v, w);
			p->nextArc = vertics[u].firstArc;
			vertics[u].firstArc = p;
		}
	}
	void show() {
		for (int i = 1; i <= vex_num; i++) {
			cout << vertics[i].data;
			ArcNode* p = vertics[i].firstArc;
			while (p) {
				cout << "->" << p->adjvex;
				p = p->nextArc;
			}
			cout << endl;
		}
	}
};

void TopologicalOrder(AMGraph& G, int* ve, int* vl, stack<int>& s) {
	int n = G.vex_num;
	queue<int>Q;
	int* indegree = new int[n + 1];
	//初始化度数列
	for (int i = 0; i <= n; i++) {
		indegree[i] = 0;
	}
	for (int i = 1; i <= n; i++) {
		ArcNode* p = G.vertics[i].firstArc;
		while (p) {
			indegree[p->adjvex]++;
			p = p->nextArc;
		}
	}
	for (int i = 1; i <= n; i++) {
		ve[i] = 0;
	}
	//拓扑排序
	while (s.size() != G.vex_num) {
		int index = 0;
		for (int i = 1; i <= n; i++) {
			if (indegree[i] == 0) {
				//cout << i;
				index = i;
				Q.push(i);
				s.push(i);
				indegree[i] = -1;
				break;
			}
		}
		ArcNode* p = G.vertics[index].firstArc;
		while (p) {
			indegree[p->adjvex]--;
			if (ve[p->adjvex] < ve[index] + p->weight) {//更新ve
				ve[p->adjvex] = ve[index] + p->weight;
			}
			p = p->nextArc;
		}
	}

	//初始化vl
	for (int i = 1; i <= n; i++) {
		vl[i] = ve[s.top()];
	}
	//逆拓扑排序
	while (!s.empty()) {
		int index = s.top();
		ArcNode* p = G.vertics[index].firstArc;
		while (p) {
			if (vl[index] > vl[p->adjvex] - p->weight) {
				vl[index] = vl[p->adjvex] - p->weight;
			}
			p = p->nextArc;
		}
		s.pop();
	}
}
void CriticalPath(AMGraph& G) {
	int* ve = new int[G.vex_num + 1];
	int* vl = new int[G.vex_num + 1];
	stack<int> s;
	TopologicalOrder(G, ve, vl, s);
	for (int i = 1; i <= G.vex_num; i++) {
		cout << ve[i] << " " << vl[i] << endl;
	}
	for (int i = 1; i <= G.vex_num; i++) {
		ArcNode* p = G.vertics[i].firstArc;
		while (p) {
			//如果e == l
			if (ve[i] == vl[p->adjvex] - p->weight) {
				cout << i << "->" << p->adjvex << endl;
			}
			p = p->nextArc;
		}
	}
}

int main() {
	AMGraph G;
	G.Init();
	G.show();
	CriticalPath(G);
	system("pause");
	return 0;
}

/*
测试样例：
6 8
1 2 3
2 4 2
3 4 4
4 6 2
5 6 1
1 3 2
2 5 3
3 6 3
*/

AOV网关键路径求解：

重点说一下这个问题，网上关于这部分的求解几乎没有，反正我没找到，本人也是在做学校的练习时遇到的

附上练习：

问题求解思路：

第一种思路：将AOV关键路径问题转化为AOE关键路径问题求解，大致过程为将AOV中的点变成一条边，边的权即为点的权，大致为下面这个意思：
在这个过程中需要注意为了方便转化问题的求解，我们最好在给所有的零入度节点和零出度节点分别设置一个公共起点和公共终点
我们会发现新生成AOE网包含原来的AOV网，原来AOV网的边上的权全为0，新生成的边上的权全部为AOV网上顶点的权
推荐一篇博客：C++ 数据结构提高 - 图算法专题（二十九） - 知乎 (zhihu.com)

第二种思路：我们会发现，关键路径实际就是AOV网上，从零入度节点到零出度节点的一条“最长“路径，这里的最长指的是路径上所有节点的权之和最大
为什么？原因在于关键路径要求所有的活动全部完成所需的最小事件，注意是全部完成，我们以下图举例，假设每个节点的权都是1，显然这个AOV网的关键路径为V1->V4->V5->V6->V3，也就是从零入度节点到零出度节点的一条“最长“路径

转化为最长路径问题

最长路径问题，这和我们前面的最短路径很像，联想到贪心算法，用result数组辅助求解，我们初始化result[i]为每个节点的权，按逆拓扑排序（在求正拓扑排序时用栈存储，出栈顺序即为逆拓扑排序）从后往前进行贪心，遇到每一个节点根据他的后继进行松弛，如果result[top] < vexdata + result[p->adjVex]（p指向当前节点，p->adjVex为后继），进行松弛操作：result[top] = vexdata + result[p->adjVex]

根据后继进行松弛

笨人使用的是第二种思路：附上代码和样例图

#include<iostream>
#include<string>
#include<vector>
#include<stack>
using namespace std;
#define MaxSize 25

struct ArcNode{
	int weight;
	ArcNode* nextArc;
	int adjVex;
	ArcNode() :weight(0), adjVex(0), nextArc(NULL) {}
	ArcNode(int w,int a) :weight(w), adjVex(a), nextArc(NULL) {}

};
struct VexNode{
	int data;
	ArcNode* firstArc;
	VexNode() :data(-1),firstArc(NULL){}
};

struct AdGraph{
	VexNode vertics[MaxSize];
	int vex_num;
	int arc_num;
	AdGraph():vex_num(0),arc_num(0) {}
};

void show(AdGraph&G) {
	for (int i = 1; i <= G.vex_num; i++) {
		cout << i << ":";
		ArcNode* p = G.vertics[i].firstArc;
		while (p) {
			cout << "->" << p->adjVex;
			p = p->nextArc;
		}
		cout << endl;
	}
}

void Init(AdGraph&G) {
	int n = 0;
	cin >> n;
	G.vex_num = n;
	cin.ignore();
	for(int i=1;i<=n;i++){
		//输入节点编号
		int start;
		cin >> start;
		//输入权重
		int weight;
		cin >> weight;
		G.vertics[i].data = weight;
		//输入前驱节点
		string s;
		getline(cin,s);
		for (int i = 0; i < s.length(); i++) {
			if (s[i] == ';') {
				int post=0;
				int j = i-1;
				while (j>0&&s[j] >= '0' && s[j] <= '9') {
					post = post * 10 + s[j] - '0';
					j--;
				}
				ArcNode* p = new ArcNode(0, start); G.arc_num++;
				p->nextArc = G.vertics[post].firstArc;
				G.vertics[post].firstArc = p;
			}
		}
	}
}

stack<int> tp;
int AOV(AdGraph&G) {
	int Flag = 0;
	//初始化
	int *InDegree=new int[G.vex_num+1];
	for (int i = 0; i <= G.vex_num; i++) {
		InDegree[i] = 0;
	}
	int* visit = new int[G.vex_num + 1];
	for (int i = 0; i <= G.vex_num; i++) {
		visit[i] = 0;
	}
	for (int i = 1; i <= G.vex_num; i++) {
		ArcNode* p = G.vertics[i].firstArc;
		while (p) {
			InDegree[p->adjVex]++;
			p = p->nextArc;
		}
	}
	//拓扑排序
	stack<int>s;
	for (int i = 1; i <= G.vex_num; i++) {
		if (InDegree[i] == 0) {
			s.push(i);
			tp.push(i);
			visit[i] = 1;
		}
	}
	while (!s.empty()) {
		int root = s.top();
		s.pop();
		ArcNode* p = G.vertics[root].firstArc;
		while (p) {
			InDegree[p->adjVex]--;
			p = p->nextArc;
		}
		for (int i = 1; i <= G.vex_num; i++) {
			if (visit[i]==0&&InDegree[i] == 0) {
				s.push(i);
				tp.push(i);
				visit[i] = 1;
			}
		}
	}
	for (int i = 1; i <= G.vex_num; i++) {
		if (InDegree[i] != 0) {
			return false;
		}
	}
	
	//初始化
	int* OutDegree = new int[G.vex_num + 1];
	for (int i = 0; i <= G.vex_num; i++) {
		OutDegree[i] = 0;
	}
	int* result = new int[G.vex_num];
	for (int i = 1; i <= G.vex_num; i++) {
		result[i] = G.vertics[i].data;
	}
	for (int i = 1; i <= G.vex_num; i++) {
		ArcNode* p = G.vertics[i].firstArc;
		while (p) {
			OutDegree[i]++;
			p = p->nextArc;
		}
	}
	//贪心算法计算最长路径
	while (!tp.empty()) {
		int top = tp.top();
		tp.pop();
		//cout << top << endl;
		ArcNode* p = G.vertics[top].firstArc;
		int vexdata = result[top];
		while (p) {
			if (result[top] < vexdata + result[p->adjVex]) {
				result[top] = vexdata + result[p->adjVex];
			}
			p = p->nextArc;
		}
	}
	int Max=-1;
	for (int i = 1; i <= G.vex_num; i++) {
		if (Max < result[i])Max = result[i];
	}
	return Max;
}

/*
8
1 5
2 4 1;
3 1 1;
4 9 3;
5 10 4;
6 3 5;
7 7 5;
8 5 6;
*/

int main() {
	AdGraph G;
	Init(G);
	int result = AOV(G);
	if (result) {
		cout << result;
	}
	else {
		cout << "error";
	}
	system("pause");
	return 0;
}