关键路径C++实现

AOE网：在一个表示工程的带权有向图中，用顶点表示事件，用有向边表示活动，边上的权值表示活动的持续时间，称这样的有向图叫做边表示活动的网，简称AOE网。AOE网中没有入边的顶点称为始点（或源点），没有出边的顶点称为终点（或汇点）。

AOE网的性质：

⑴ 只有在某顶点所代表的事件发生后，从该顶点出发的各活动才能开始；

⑵ 只有在进入某顶点的各活动都结束，该顶点所代表的事件才能发生。

关键路径：在AOE网中，从始点到终点具有最大路径长度（该路径上的各个活动所持续的时间之和）的路径称为关键路径。

关键活动：关键路径上的活动称为关键活动。关键活动：e[i]=l[i]的活动

　　由于AOE网中的某些活动能够同时进行，故完成整个工程所必须花费的时间应该为始点到终点的最大路径长度。关键路径长度是整个工程所需的最短工期。

与关键活动有关的量：

⑴ 事件的最早发生时间ve[k]

　　ve[k]是指从始点开始到顶点vk的最大路径长度。这个长度决定了所有从顶点vk发出的活动能够开工的最早时间。

　　　　

⑵ 事件的最迟发生时间vl[k]

　　vl[k]是指在不推迟整个工期的前提下,事件vk允许的最晚发生时间。

　　　 

 

⑶ 活动的最早开始时间e[i]

　　若活动ai是由弧<vk , vj>表示，则活动ai的最早开始时间应等于事件vk的最早发生时间。因此，有：e[i]=ve[k]

⑷ 活动的最晚开始时间l[i]

　　活动ai的最晚开始时间是指，在不推迟整个工期的前提下， ai必须开始的最晚时间。若ai由弧<vk，vj>表示，则ai的最晚开始时间要保证事件vj的最迟发生时间不拖后。因此，有：l[i]=vl[j]-len<vk, vj>

 

示例：

　　

所以：

具体的实现代码如下:

#include<cstdio>
#include<vector>
#include<queue>
#include<stack>
#include<algorithm>
using namespace std;
const int maxn = 1000;
int n;
int ve[maxn], vl[maxn];
struct Node
{
	int v, w;
}node;
int inDegree[maxn] = { 0 };
stack<int> topOrder;
vector<Node> G[maxn];
vector<int> pre[maxn];
bool topologicalSort()
{
	queue<int> q;
	int c = 0;
	for (int i = 0; i < n; i++)
	{
		if (inDegree[i] == 0)
			q.push(i);
	}
	while (!q.empty())
	{
		int u = q.front(); c++;
		topOrder.push(u);
		q.pop();
		for (int i = 0; i < G[u].size(); i++)
		{
			int v = G[u][i].v, w = G[u][i].w;
			inDegree[v]--;
			if (inDegree[v] == 0)
				q.push(v);
			if (ve[u] + w > ve[v])ve[v] = ve[u] + w;
		}
	}
	return c == n ? true : false;
}
vector<int> path;
void DFS(int s, int e)
{
	if (s == e)
	{
		path.push_back(s);
		for (int i = path.size() - 1; i >= 0; i--)
		{
			printf("%d", path[i]);
			if (i > 0)printf("->");
			else printf("\n");
		}
		path.pop_back();
		return;
	}
	path.push_back(e);
	for (int i = 0; i < pre[e].size(); i++)
	{
		DFS(s, pre[e][i]);
	}
	path.pop_back();
}
int criticalPath()
{
	fill(ve, ve + n, 0);
	if (!topologicalSort())
	{
		return -1;
	}
	fill(vl, vl + n, ve[n - 1]);
	while (!topOrder.empty())
	{
		int u = topOrder.top();
		topOrder.pop();
		for (int i = 0; i < G[u].size(); i++)
		{
			int v = G[u][i].v, w = G[u][i].w;
			if (vl[v] - w < vl[u])
			{
				vl[u] = vl[v] - w;
			}
		}
	}
	printf("所有的关键活动如下所示：\n");
	for (int u = 0; u < n; u++)
	{
		for (int i = 0; i < G[u].size(); i++)
		{
			int v = G[u][i].v, w = G[u][i].w;
			int e = ve[u], l = vl[v] - w;
			if (e == l)
			{
				printf("%d->%d\n", u + 1, v + 1);//输出时加1以还原输入时做出的改变
				pre[v + 1].push_back(u + 1);
			}
		}
	}
	printf("所有的关键路径如下所示：\n");
	DFS(1, n);
	return ve[n - 1];
}

int main()
{
	freopen("i.txt", "r", stdin);//键盘输入流重定向为i.txt文件输入流
	int m;
	scanf("%d %d", &n,&m);//n为点数，m为边数
	int a, b, w;
	for (int i = 0; i < m; i++)
	{
		scanf("%d%d%d", &a, &b, &w);//a、b为事件，w为ab这条边所表示的活动耗费的时间
		node.v = b-1; node.w = w;
		G[a-1].push_back(node);//实际存储时为了方便a、b都减1
	}
	printf("关键路径长度为：%d\n",criticalPath());
	return 0;
}
/*
输入为（即i.txt内容）：
9 11
1 2 6
1 3 4
1 4 5
2 5 1
3 5 1
4 6 2
5 7 9
5 8 7
6 8 4
7 9 2
8 9 4
*/