关键路径（AOE网）

拓扑排序主要解决一个工程如何顺序解决的问题，但拓扑排序的结果往往不是唯一的，所以有时还会遇到解决工程完成最短时间的问题。
对于从一个源点到另一个汇点的所有路径中，路径长度（路径上每个活动持续时间）最长的成为关键路径，即使改变其它路径的上活动的时间也不会影响整个工程的时间。
关键路径算法的关键在于求得
事件的的最早发生时间etv：顶点v的最早发生时间。
事件的最晚发生时间ltv：顶点v的最早发生时间，如果超过就会影响整个工程的时间。
活动的最早发生时间ete：弧<v1,v2>的最早发生时间。
活动的最晚发生时间lte：弧<v1,v2>的最晚发生时间。
ete和lte可由etv与ltv求得，如果活动的最晚和最早发生时间相等则说明该路径为一个关键路径。
dut(i,j)为i到j活动所持续的时间及有向边i到j的权值
etv[j] = max(etv[j], etv[i] + dut(i, j));
ltv[i] = min(ltv[i], ltv[j] - dut(i, j));
ete[i] = etv[i];
lte[i] = ltv[j] - dut(i,j);
代码如下

#include <iostream>
#include <vector>
#include <stack>

using namespace std;

struct Node
{
	int weight;
	int index;
	Node(int in, int we):index(in), weight(we){
	}
};

vector<vector<Node>> edges;
vector<int> indeg, etv, ltv;
stack<int> res;
bool invalid = 0;
int N, M;
//拓扑排序求得etv
void topol_sort()
{
	etv.resize(N);
	stack<int> s;
	for (int i = 0; i < N; ++i)
	{
		if (!indeg[i]) s.push(i);
	}
	
	while (!s.empty())
	{
		int front = s.top();
		res.push(front);
		s.pop();
		for (int i = 0; i < edges[front].size(); ++i)
		{
			int cur = edges[front][i].index;
			if (--indeg[cur] == 0)
			{
				s.push(cur);
			}
	     	etv[cur] = max(etv[cur], etv[front] + edges[front][i].weight);
		}
	}
	
	if (res.size() != N) invalid = 1;
}

void CirticalPath()
{
	topol_sort();
	if (invalid) return;
	ltv.resize(N);
	int maxTime = -1;//整个工程所需的时间
	for (auto u : etv) maxTime = max(maxTime, u);
	fill(ltv.begin(), ltv.end(), maxTime);
	//逆拓扑排序求得ltv
	while (!res.empty())
	{
		int gettop = res.top();
		res.pop();
		for (int i = 0; i < edges[gettop].size(); ++i)
		{
			int cur = edges[gettop][i].index;
			ltv[gettop] = min(ltv[gettop], ltv[cur] - edges[gettop][i].weight);
		}
	}
	cout<<maxTime<<endl;
	for (int i = 0; i < N; ++i)
	{
		for (int j = edges[i].size() - 1; j >= 0; --j)
		{
			int cur = edges[i][j].index;
			int ete = etv[i];
			int lte = ltv[cur] - edges[i][j].weight;
			if (ete == lte)
			{
				cout<<i<<"->"<<cur<<endl;
			}
		}
	}
} 

时间复杂度和拓扑排序相同为O(n+e)。
例题
7-11 关键活动 (30分)
假定一个工程项目由一组子任务构成，子任务之间有的可以并行执行，有的必须在完成了其它一些子任务后才能执行。“任务调度”包括一组子任务、以及每个子任务可以执行所依赖的子任务集。

比如完成一个专业的所有课程学习和毕业设计可以看成一个本科生要完成的一项工程，各门课程可以看成是子任务。有些课程可以同时开设，比如英语和C程序设计，它们没有必须先修哪门的约束；有些课程则不可以同时开设，因为它们有先后的依赖关系，比如C程序设计和数据结构两门课，必须先学习前者。

但是需要注意的是，对一组子任务，并不是任意的任务调度都是一个可行的方案。比如方案中存在“子任务A依赖于子任务B，子任务B依赖于子任务C，子任务C又依赖于子任务A”，那么这三个任务哪个都不能先执行，这就是一个不可行的方案。

任务调度问题中，如果还给出了完成每个子任务需要的时间，则我们可以算出完成整个工程需要的最短时间。在这些子任务中，有些任务即使推迟几天完成，也不会影响全局的工期；但是有些任务必须准时完成，否则整个项目的工期就要因此延误，这种任务就叫“关键活动”。

请编写程序判定一个给定的工程项目的任务调度是否可行；如果该调度方案可行，则计算完成整个工程项目需要的最短时间，并输出所有的关键活动。

输入格式:
输入第1行给出两个正整数N(≤100)和M，其中N是任务交接点（即衔接相互依赖的两个子任务的节点，例如：若任务2要在任务1完成后才开始，则两任务之间必有一个交接点）的数量。交接点按1_{N编号，M是子任务的数量，依次编号为1}M。随后M行，每行给出了3个正整数，分别是该任务开始和完成涉及的交接点编号以及该任务所需的时间，整数间用空格分隔。

输出格式:
如果任务调度不可行，则输出0；否则第1行输出完成整个工程项目需要的时间，第2行开始输出所有关键活动，每个关键活动占一行，按格式“V->W”输出，其中V和W为该任务开始和完成涉及的交接点编号。关键活动输出的顺序规则是：任务开始的交接点编号小者优先，起点编号相同时，与输入时任务的顺序相反。

输入样例:
7 8
1 2 4
1 3 3
2 4 5
3 4 3
4 5 1
4 6 6
5 7 5
6 7 2
输出样例:
17
1->2
2->4
4->6
6->7

AC代码

# include <bits/stdc++.h>

using namespace std;

struct Node
{
	int weight;
	int index;
	Node(int in, int we):index(in), weight(we){
	}
};

vector<vector<Node>> edges;
vector<int> indeg, etv, ltv;
stack<int> res;
bool invalid = 0;
int N, M;

void topol_sort()
{
	etv.resize(N+1);
    fill(etv.begin(), etv.end(), 0);
	stack<int> s;
	for (int i = 1; i <= N; ++i)
	{
		if (!indeg[i]) s.push(i);
	}
	
	while (!s.empty())
	{
		int front = s.top();
		res.push(front);
		s.pop();
		for (int i = 0; i < edges[front].size(); ++i)
		{
			int cur = edges[front][i].index;
			if (--indeg[cur] == 0)
			{
				s.push(cur);
			}
	     	etv[cur] = max(etv[cur], etv[front] + edges[front][i].weight);
		}
	}
	
	if (res.size() != N) invalid = 1;
}

void CirticalPath()
{
	topol_sort();
	if (invalid) return;
	ltv.resize(N+1);
    int maxTime = -1;
    for(auto u : etv) maxTime = max(maxTime, u);
	fill(ltv.begin(), ltv.end(), maxTime);
	while (!res.empty())
	{
		int gettop = res.top();
		res.pop();
		for (int i = 0; i < edges[gettop].size(); ++i)
		{
			int cur = edges[gettop][i].index;
			ltv[gettop] = min(ltv[gettop], ltv[cur] - edges[gettop][i].weight);
		}
	}
	
}

int main()
{
	cin>>N>>M;
	edges.resize(N+1);
	indeg.resize(N+1);
	for (int i = 1; i <= M; ++i)
	{
		int u, v ,w;
		cin>>u>>v>>w;
		edges[u].push_back(Node(v, w));
		++indeg[v];
	}
	CirticalPath();
	int max=-1,u=-1;
	if (!invalid)
	{
		cout<<ltv.back()<<endl;
		for (int i = 1; i <= N; ++i)
		{
			for (int j = edges[i].size() - 1; j >= 0; --j)
			{
				int cur = edges[i][j].index;
				int ete = etv[i];
				int lte = ltv[cur] - edges[i][j].weight;
				if (ete == lte)
				{
					cout<<i<<"->"<<cur<<endl;
				}
			}
		}
	}
	else
	{
		cout<<0;
	}
	return 0;
}