题目描述
假定一个工程项目由一组子任务构成，子任务之间有的可以并行执行，有的必须在完成了其它一些子任务后才能执行。“任务调度”包括一组子任务、以及每个子任务可以执行所依赖的子任务集。
比如完成一个专业的所有课程学习和毕业设计可以看成一个本科生要完成的一项工程，各门课程可以看成是子任务。有些课程可以同时开设，比如英语和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
题解
题意理解：根据所给的 AOE 网络，输出工程完成的最早时间以及关键任务
在 08-图8 How Long Does It Take 的基础上，按照拓扑逆序求 Latest[] ，计算机动时间，遍历输出机动时间为零的关键活动。
多起点多终点样例不通过：
多个终点的最早结束时间不一样，比如一个最少需要10天，另一个需要12天，那么反过来计算最晚时间时，两个终点的 Latest[] 都应该初始化为12天。
输出关键路径的顺序：
外层循环从结点下标从小到大遍历，内从循环根据逆拓扑序的倒序输出。
完整代码：
#include <stdio.h>
#include <stdlib.h>
#define INF 65535
void BuildGraph(int G[][101], int N, int M, int Indgree[], int Outdegree[])
{
int i, j, a, b, c;
for (i = 1; i <= N; i++) {
Indgree[i] = 0;
Outdegree[i] = 0;
for (j = 1; j <= N; j++) {
if (i == j) G[i][j] = 0;
else G[i][j] = G[j][i] = INF;
}
}
for (i = 0; i < M; i++) {
scanf("%d%d%d", &a, &b, &c);
G[a][b] = c;
Indgree[b]++;
Outdegree[a]++;
}
}
int PrintMax(int N, int Outdegree[], int Earliest[])
{
int i, MaxItem = 0;
for (i = 1; i <= N; i++) {
if (Outdegree[i] == 0 && Earliest[i] > MaxItem)
MaxItem = Earliest[i];
}
printf("%d\n", MaxItem);
return MaxItem;
}
int front, rear, queue[101];
void CriticalPath(int G[][101], int N, int Outdegree[],
int Earliest[], int Latest[], int D[][101], int latest)
{
int i, j, V, W;
front = 0, rear = 0;
for (V = 1; V <= N; V++) {
if (Outdegree[V] == 0) {
Latest[V] = latest;
queue[rear++] = V;
}
else Latest[V] = INF;
}
while (front != rear) {
V = queue[front++];
for (W = 1; W <= N; W++) {
if (Outdegree[W] && G[W][V] < INF) {
if (Latest[V] - G[W][V] < Latest[W]) {
Latest[W] = Latest[V] - G[W][V];
}
if (--Outdegree[W] == 0)
queue[rear++] = W;
}
}
}
for (i = 1; i <= N; i++) {
for (j = 1; j <= N; j++) {
if (G[i][j] < INF)
D[i][j] = Latest[j] - Earliest[i] - G[i][j];
}
}
for (V = 1; V <= N; V++) {
front = 0; rear = N - 1;
while (rear >= front) {
W = queue[rear--];
if (V != W && G[V][W] < INF && D[V][W] == 0)
printf("%d->%d\n", V, W);
}
}
}
void TopSort(int G[][101], int N, int Indgree[], int Outdegree[],
int Earliest[], int Latest[], int D[][101])
{
int V, W, cnt;
front = rear = 0;
for (V = 1; V <= N; V++) {
Earliest[V] = 0;
if (Indgree[V] == 0) {
queue[rear++] = V;
}
}
cnt = 0;
while (front != rear) {
V = queue[front++];
cnt++;
for (W = 1; W <= N; W++) {
if (Indgree[W] && G[V][W] < INF) {
if (Earliest[V] + G[V][W] > Earliest[W])
Earliest[W] = Earliest[V] + G[V][W];
if (--Indgree[W] == 0)
queue[rear++] = W;
}
}
}
if (cnt != N) { printf("0"); return; }
int latest;
latest = PrintMax(N, Outdegree, Earliest);
CriticalPath(G, N, Outdegree, Earliest, Latest, D, latest);
}
int main()
{
int N, M;
int Indgree[101], Outdegree[101], Earliest[101], Latest[101];
int G[101][101], D[101][101];
scanf("%d%d", &N, &M);
BuildGraph(G, N, M, Indgree, Outdegree);
TopSort(G, N, Indgree, Outdegree, Earliest, Latest, D);
return 0;
}
代码详解：
存图方式为邻接矩阵存图。
G[i][j]表示 i 到 j 的有向路径长D[i][j]表示 i 到 j 的机动时间Indegree[i]表示结点 i 的入度数Outdegree[i]表示结点 i 的出度数
拓扑顺序求 Earliest ：
- 所有 Earliest[i] 初始化为 0
- 入度数为零的结点全部入队
- 进入循环，逐个出队，遍历出队结点的后继结点
- 如果后继节点的 Earliest 加上路径长后变大，更新，并且入度减一
- 如果入度减一后入度为零，进队
- 循环结束后如果每个结点都出过一次队说明正常，进入下一步
- 否则输出 0 直接退出
逆拓扑顺序求 Latest ：
- 将最早完成工程的时间赋给所有出度为零的 Latest[i] ，而不是对每个出度为零的结点 Latest = Earliest
- 跟拓扑顺序类似的方法动态规划更新 Latest[]
生成完 Latest[] 后遍历 D 生成机动时间
根据从小到大和逆拓扑序的反序输出关键活动：D[V][W] == 0 就是机动时间为 0 ，为关键活动。
