Codeup100000624问题 A: 关键路径

题目描述：

描述：

图的连接边上的数据表示其权值，带权值的图称作网。

上图可描述为顶点集为（a,b,c,d,e)

边集及其权值为(始点，终点 权值）：

a b 3
a c 2 
b d 5
c d 7
c e 4
d e 6         

网的源点是入度为0的顶点，汇点是出度为0的顶点。网的关键路径是指从源点到汇点的所有路径中，具有最大路径长度的路径。上图中的关键路径为$a\to c\to d\to e$，其权值之和为关键路径的长度为15。

本题的要求是根据给出的网的邻接矩阵求该网的关键路径及其长度。

输入：

第一行输入一个正整数n（$1\le n\le 5$)，其代表测试数据数目，即图的数目

第二行输入x($1\le x\le 15$)代表顶点个数，y($1\le y\le 19$)代表边的条数

第三行给出图中的顶点集，共x个小写字母表示顶点

接下来每行给出一条边的始点和终点及其权值，用空格相隔，每行代表一条边。

输出：

第一个输出是图的关键路径（用给出的字母表示顶点， 用括号将边括起来，顶点逗号相隔）

第二个输出是关键路径的长度

每个矩阵对应上面两个输出，两个输出在同一行用空格间隔，每个矩阵的输出占一行。

样例输入：

2
5 6
abcde
a b 3
a c 2
b d 5
c d 7
c e 4
d e 6
4 5
abcd
a b 2
a c 3
a d 4
b d 1
c d 3

样例输出：

(a,c) (c,d) (d,e) 15
(a,c) (c,d) 6

实现代码：

#include<cstdio>
#include<stack>
#include<queue>
#include<cstring>
#include<map>
using namespace std;

const int maxv = 100;

//v表示顶点编号，w表示边权值
struct Node {
    int v;
    int w;
    Node(int _v, int _w): v(_v), w(_w) {}
};

map<int, char> Num2Char;// 数字转字符
map<char, int> Char2Num;// 字符转数字
stack<int> topOrder;// 拓扑排序，用于逆拓扑排序
vector<Node> G[maxv];// 邻接表
vector<int> ans[maxv];// 保存关键路径
int inDegree[maxv];// 保存入度
int ve[maxv];// 保存最早开始时间
int vl[maxv];// 保存最迟开始时间

// 拓扑排序，顺便求ve数组
bool topologicalSort(int n) {
    queue<int> q;
    for(int i = 0; i < n; i++) {
        if(inDegree[i] == 0) {
            q.push(i);
        }
    }
    while(!q.empty()) {
        int u = q.front();
        q. pop();
        topOrder.push(u);
        for(int i = 0; i < G[u].size(); i++) {
            int v = G[u][i].v;
            inDegree[v]--;
            if(inDegree[v] == 0) {
                q.push(v);
            }
            if(ve[u] + G[u][i].w > ve[v]) {
                ve[v] = ve[u] + G[u][i].w;
            }
        }
    }
    if(topOrder.size() == n) {
        return true;
    } else {
        return false;
    }
}

int CriticalPath(int n) {
    memset(ve, 0, sizeof(ve));
    if(topologicalSort(n) == false) {
        return -1;
    }
    int maxLength = 0;
    for(int i = 0; i < n; i++) {
        if(ve[i] > maxLength) {
            maxLength = ve[i];
        }
    }
    fill(vl, vl + n, maxLength);

    while(!topOrder.empty()) {
        int u = topOrder.top();
        topOrder.pop();
        for(int i = 0; i < G[u].size(); i++) {
            int v = G[u][i].v;
            if(vl[v] - G[u][i].w < vl[u]) {
                vl[u] = vl[v] - G[u][i].w;
            }
        }
    }

    // 清空关键路径vector
    for (int i = 0; i < n; ++i) { 
        ans[i].clear();
    }

    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) {
                ans[u].push_back(v);
            }
        }
    }

    int s;
    for (int i = 0; i < n; ++i) { //寻找事件起始点
        if(!ve[i]) {
            s = i;
            break;
        }
    }

    while(ans[s].size()) { //没有后继结点时，退出
        printf("(%c,%c) ", Num2Char[s], Num2Char[ans[s][0]]);
        s = ans[s][0];
    }

    return maxLength;
}

int main() {
    int n;
    int x, y;
    char c1, c2;
    int w;
    char ch;
    while(scanf("%d", &n) != EOF) {
        for(int i = 0; i < n; i++) {
            memset(inDegree, 0, sizeof(inDegree));
            scanf("%d%d", &x, &y);
            getchar();
            for(int i = 0; i < x; i++) {
                scanf("%c", &ch);
                Num2Char[i] = ch;
                Char2Num[ch] = i;
            }
            for(int i = 0; i < y; i++) {
                getchar();
                scanf("%c %c %d", &c1, &c2, &w);
                G[Char2Num[c1]].push_back(Node(Char2Num[c2], w));
                inDegree[Char2Num[c2]]++;
            }
            int ans = CriticalPath(x);
            printf("%d\n", ans);
            for(int i = 0; i < x; i++) {
                G[i].clear();
            }
            Num2Char.clear();
            Char2Num.clear();
        }
    }
    return 0;
}