拓扑排序以及关键路径模板

拓扑排序

#include <bits/stdc++.h>

using namespace std;

const int maxn = 1010;
int n,m;   //定点数、边数
vector<int> adj[maxn];//图：邻接表
int indegree[maxn] = {0};//各个顶点的入度

bool topSort(){
    int cnt = 0;
    queue<int> q;
    for(int u = 0;u <n;u++){
        if(!indegree[u]) q.push(u);
    }
    while (q.size()){
        int u = q.front();
        q.pop();
        cnt++;
        for(auto v:adj[u]){
            indegree[v]--;
            if(!indegree[v]) q.push(v);
        }
    }
    return cnt == n;
}

int main(){
    scanf("%d%d",&n,&m);
    for(int i = 0;i < m;i++){
        int a,b;
        scanf("%d%d",&a,&b);
        adj[a].push_back(b);
        indegree[b]++;
    }
    if(topSort()) printf("Not ring\n");
    else printf("Have ring\n");
    system("pause");

    return 0;
}

关键路径

关键路径指的是图中的距离最长的路径，由这一点可以在选择题里面直接得出给定的图的关键路径。
路径是两个顶点之间的路，顶点称为事件，边称为活动。
是由顶点即事件的最早发生时间和最晚发生时间来确定活动的最早发生时间和活动的最晚发生时间。而如果一个活动的最早发生时间等于该活动的最晚发生时间，则该活动即为关键路径上的一个关键活动，当然关键路径可以不止一条。

注意点

更新事件的最早发生时间

一个事件可以发生是因为其所有前驱事件均已经发生。
确定事件的最早发生时间，是在拓扑排序的同时进行的，是从源点到汇点的更新。初始时，所有事件的最早发生时间均为0，由顶点u出发，更新其所有后继顶点v。而顶点v可能又不仅仅是顶点u的后继，所以要将事件v的最早发生时间更新为其所有前驱结点的最早发生时间+U->V的最大距离。
而且关键路径的最后一个顶点（事件）的最早发生时间是等于该顶点的最晚发生时间的。
更新事件的最晚发生时间
事件的最晚发生时间是其所有后继事件最晚发生时间减去v—>u的时间的最小值。
这是一个逆拓扑排序过程，是从汇点到原点的更新。

#include <bits/stdc++.h>

using namespace std;

struct node {
    int v, dis;
    node() {}
    node(int _v, int _dis) : v(_v), dis(_dis) {}
};

const int maxn = 1010;
const int INF = 1e9;
int ve[maxn], vl[maxn];    //事件的最早开始时间、最晚开始时间
int indegree[maxn] = {0};  //顶点入度
vector<node> adj[maxn];    //图：邻接表
vector<int> topSe;         // 拓扑序列
stack<int> topOrder;  //存放拓扑序列，可以取出作为逆拓扑序列，来从后往前更新
int n, m;             //顶点数、边数
int id, optval = -1;  //最早发生时间最晚的事件的编号、以及发生时间
vector<int> pre[maxn];  //用来放关键活动的前驱

bool topSort() {
    memset(ve, 0, sizeof(ve));  //将时间最早发生时间数组全部初始化为0
    int cnt = 0;

    queue<int> q;
    for (int u = 0; u < n; u++) {
        if (!indegree[u])
            q.push(u);
    }
    while (q.size()) {
        int u = q.front();
        topSe.push_back(u);  //将u加入拓扑序列
        topOrder.push(u);    //将u加入拓扑序列
        q.pop();
        cnt++;

        for (int i = 0; i < adj[u].size(); i++) {  //以u为前驱，更新数据
            int v = adj[u][i].v;
            int dis = adj[u][i].dis;
            indegree[v]--;  //令其所有后继的入度减一
            if (indegree[v] == 0)
                q.push(v);  //如果某个后继的入度为0，则入队
            if (ve[v] < ve[u] + dis) {  //如果当前后继结点的事件最早发生时间小于ve[u] + dis，则更新ve[v]
                ve[v] = ve[u] + dis;
                if (ve[v] > optval) {  // 更新最早发生时间最大的事件id
                    id = v;
                    optval = ve[v];
                }
            }
        }
    }
    return cnt == n;
}

int criticalPath() {
    if (topSort() == false)
        return -1;  //先进行拓扑排序,如果返回为false，则说明图中存在环，返回-1

    fill(vl, vl + n,optval);  //初始化事件最晚发生时间数组，将每个事件的最晚发生时间设为最大的事件最早发生时间

    while (topOrder.size()) {
        int u = topOrder.top();
        topOrder.pop();
        for (int i = 0; i < adj[u].size();i++) {  //以u的每个后继结点的事件最晚发生时间来更新u的最晚发生时间
            int v = adj[u][i].v;
            int dis = adj[u][i].dis;
            if (vl[u] > vl[v] - dis)
                vl[u] =vl[v] - dis;  //事件u的最晚发生时间为其所有后继的最晚发生时间减去dis的最小值
        }
    }

    for (int u = 0; u < n; u++) {
        for (int i = 0; i < adj[u].size(); i++) {
            //对于活动u->v来说
            int v = adj[u][i].v;
            int dis = adj[u][i].dis;
            int e = ve[u];  //活动的最早发生时间就是事件u的最早发生时间
            int l = vl[v] - dis;  //活动的最晚发生时间是事件v的最晚发生时间减去dis
            if (e == l) {  //如果活动的最早发生时间、最晚发生时间相同，则该活动为关键活动
                pre[v].push_back(u);
            }
        }
    }
    return id;  //返回最早发生时间最大的事件id，如果整个图只有一个汇点的话，返回的就是这个汇点的id
}

vector<int> temp;
void dfs(int u) {
    if (u == 0) {
        temp.push_back(u);
        for (int i = temp.size() - 1; i >= 0; i--) {
            printf("%d", temp[i]);
            if (i)
                printf(" ");
        }
        printf("\n");
        temp.pop_back();
        return;
    }
    temp.push_back(u);
    for (int i = 0; i < pre[u].size(); i++)
        dfs(pre[u][i]);
    temp.pop_back();
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 0; i < m; i++) {
        int a, b, l;
        scanf("%d%d%d", &a, &b, &l);
        indegree[b]++;
        adj[a].push_back(node(b, l));
    }
    int de = criticalPath();
    if (de == -1)
        printf("Error\n");
    else {
        printf("The top sequence :\n");
        for (int i = 0; i < topSe.size(); i++) {
            if (i)
                printf(" ");
            printf("%d", topSe[i]);
        }
        printf("\n");
        printf("The cirtical path:\n");
        dfs(de);
    }
    system("pause");
    return 0;
}

样例
（来自于《算法笔记》P417数据）

6 6
0 1 30
0 3 40
1 2 40
2 4 50
3 4 40
4 5 70

运行结果

The top sequence :
0 1 3 2 4 5
The cirtical path:
0 1 2 4 5