7-13 关键路径

作者 朱允刚

单位 吉林大学

假定一个工程由若干子任务构成，使用一个包含n个顶点、e条边的AOE网表示该工程，顶点编号为1至n，有向边表示该工程的每个子任务，边的权值表示完成该子任务所需的时间，假定网中只含一个源点和一个汇点。请编写程序求出该工程的所有关键活动，并计算完成该工程所需的最短时间。

输入格式:

每个测试点包含多组测试数据。每组数据第一行为2个整数n和e，均不超过200，分别表示AOE网的顶点数和边数。接下来e行表示每条边的信息，每行为3个正整数a、b、c，其中a和b表示该边的端点编号，c表示权值。各边并不一定按端点编号顺序排列，且各顶点并不一定按拓扑序排列。

输出格式:

对每组数据，若工程不可行（AOE网中存在环），输出“unworkable project”；若工程可行，则输出第一行为完成工程所需的最短时间，并从第2行开始输出关键活动，每个关键活动占一行，格式为i->j，其中i和j表示关键活动所在边的端点编号。各关键活动输出顺序为：按i的递增顺序输出，若多个关键活动的i值相同，则按j的递增顺序输出。

输入样例:

4 4
1 2 6
1 3 4
2 4 1
3 4 1

输出样例:

7
1->2
2->4

代码长度限制
16 KB
时间限制
100 ms
内存限制
64 MB

C++代码：

#include <bits/stdc++.h>

using namespace std;

#define MAX_LENGTH 1010

struct Edge {
    int indexA;
    int indexB;
    int length;
};

struct Node {
    int index;
    int length;
};

int n, m,s,t;
vector<Node> G1[MAX_LENGTH];
vector<Node> G2[MAX_LENGTH];
int inDegree1[MAX_LENGTH];
int inDegree2[MAX_LENGTH];
int dis1[MAX_LENGTH];
int dis2[MAX_LENGTH];
bool mark[MAX_LENGTH];

void read() {
    Edge e;
    Node node;
    for (int i = 1; i <= m; i++) {
        scanf("%d %d %d", &e.indexA, &e.indexB, &e.length);
        node.index = e.indexB;
        node.length = e.length;
        G1[e.indexA].push_back(node);
        inDegree1[e.indexB]++;
        node.index = e.indexA;
        G2[e.indexB].push_back(node);
        inDegree2[e.indexA]++;
    }
}

void reset() {
    for (int i = 0; i <= n + 1; i++) G1[i].clear();
    for (int i = 0; i <= n + 1; i++) G2[i].clear();
    memset(inDegree1, 0, sizeof(inDegree1));
    memset(inDegree2, 0, sizeof(inDegree2));
    memset(mark, 0, sizeof(mark));
}

bool ForwardKeyPath() {
    int num = 0;
    queue<int> q;
    memset(dis1, 0, sizeof(dis1));
    for (int i = 1; i <= n; i++) {
        if (inDegree1[i] == 0) {
            s = i;
            q.push(i);
            break;
        }
    }
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (int i = 0; i < G1[u].size(); i++) {
            Node v = G1[u][i];
            inDegree1[v.index]--;
            dis1[v.index] = max(dis1[v.index], v.length + dis1[u]);
            if (inDegree1[v.index] == 0) {
                q.push(v.index);
            }
        }
        num++;
    }
    if (num == n) return true;
    else return false;
}

bool BackKeyPath() {
    int num = 0;
    queue<int> q;
    memset(dis2, 127, sizeof(dis2));
    for (int i = 1; i <= n; i++) {
        if (inDegree2[i] == 0) {
            q.push(i);
            t = i;
            dis2[i] = dis1[i];
            break;
        }
    }
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (int i = 0; i < G2[u].size(); i++) {
            Node v = G2[u][i];
            inDegree2[v.index]--;
            dis2[v.index] = min(dis2[v.index], dis2[u] - v.length);
            if (inDegree2[v.index] == 0) {
                q.push(v.index);
            }
        }
        num++;
    }
    if (num == n) return true;
    else return false;
}

pair<int, int> ans[MAX_LENGTH];

int main() {
    while (~scanf("%d %d", &n, &m)) {
        reset();
        read();
        int cnt = 0;
        if (ForwardKeyPath() && BackKeyPath()) {
            for (int i = 1; i <= n; i++)
                if (dis1[i] == dis2[i])
                    mark[i] = true;
            for (int i = 1; i <= n; i++)
                for (int j = 0; j < G1[i].size(); j++)
                    if (mark[i] && mark[G1[i][j].index]&&dis1[i]+G1[i][j].length==dis1[G1[i][j].index])
                        ans[++cnt] = make_pair(i, G1[i][j].index);
            sort(ans + 1, ans + cnt + 1);
            cout << dis1[t] << endl;
            for (int i = 1; i <= cnt; i++) {
                cout << ans[i].first << "->" << ans[i].second << endl;
            }
        } else {
            cout << "unworkable project" << endl;
        }
    }
    return 0;
}