关键路径

Date：2019-06-17 17:47:15

算法思想

//Vi ---- ar ---> Vj

int e[r];   //活动ar的最早开始时间
int l[r];   //活动ar的最晚开始时间
int ve[i];  //事件vi的最早发生时间
int vl[i];  //事件vi的最晚发生时间

e[r] = ve[i];   //活动ar的最早开始时间 = 事件vi的最早发生时间
l[r] = vl[r]-w[r]; //活动ar的最晚开始时间 = 时间vj的最晚发生时间 - ar的边权


ve[j] = max{ve[ik] + w[rk]};  //Vj结点的最早发生时间 = Max{前驱结点Vik的最早发生时间+活动aik的边权}
//若解决Vj，必先解决Vi --> 拓扑排序求解ve
vl[i] = min(vl[jk] - w[rk]);  //Vi结点的最晚发生时间 = Min{后继结点Vjk的最晚发生时间 - 活动aik的边权}
//若解决Vi，必先解决Vj --> 逆拓扑排序求解vl

算法实现

stack<int> topOrder;
int TopologicalSort()
{
    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);   //u加入拓扑排序
        for(int i=0; i<adj[u].size(); i++)
        {
            int v = adj[u][i].v;
            inDegree[v]--;
            if(inDegree[v]==0)
                q.push(v);
            if(ve[u]+adj[u][i].w > ve[v])
                ve[v] = ve[u] + adj[u][i].w;    //求解ve
        }
    }
    if(topOrder.size() != n)    return false;
    else    return true;
}

vector<int> path[M];    //多条关键路径
int CriticalPath()
{
    fill(ve, ve+n, 0);
    if(topologicalSort() == false)
        return -1;  //有环

    int s,t,maxLength=0;
    for(int i=0; i<n; i++)
        if(ve[i]==0){
            s=i;break;  //源点，最早发生的事件
        }

    for(int i=0; i<n; i++)
        if(ve[i] > maxLength){
            maxLength = ve[i];
            t=i;        //汇点，最晚发生的事件
        }
    fill(vl, vl+n, maxLength);

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

    for(int u=0; u<n; u++)
    {
        for(int i=0; i<adj[u].size(); i++)
        {
            int v = adj[u][i].v;
            int w = adj[u][i].w;
            int e = ve[u];      //活动的最早开始时间
            int l = vl[v]-w;    //活动的最晚开始时间
            if(e==l)
                path[u].push_back(v);
        }
    }

    printf("%d", s);
    s=path[s][0];
    while(s != t)
    {
        printf("->%d",s);   //输出一条关键路径
        s=path[s][0];
    }

    return ve[t];    //返回关键路径长度
}

 

相关练习

• 更新后的大纲把动态规划都删除了，但关键路径还留着，虽然一直没考过，说不准哪天就考了呢。

Source:

Codeup 23132: 关键路径

题目描述

描述：

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

上图可描述为顶点集为（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->c->d->e，其权值之和为关键路径的长度为15。

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

输入

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

第二行输入x(1<=x<=15)代表顶点个数，y(1<=y<=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

Code:

#include<cstdio>
#include<map>
#include<stack>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;
const int M=1e2;
struct node
{
    int v,w;
};
map<char,int> mp;
stack<int> topOrder;
vector<node> adj[M];
vector<int> path[M];
int k,n,m,inDegree[M],ve[M],vl[M];
char str[M];

void TopologicalSort()
{
    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<adj[u].size(); i++)
        {
            int v = adj[u][i].v;
            inDegree[v]--;
            if(inDegree[v]==0)
                q.push(v);
            if(ve[u]+adj[u][i].w > ve[v])
                ve[v] = ve[u] + adj[u][i].w;
        }
    }
}

int CriticalPath()
{
    fill(ve,ve+n,0);
    TopologicalSort();

    int s,t,maxLength=0;
    for(int i=0; i<n; i++)
        if(ve[i]==0){
            s=i;break;
        }
    for(int i=0; i<n; i++)
        if(ve[i]>maxLength){
            maxLength=ve[i];
            t=i;
        }
    fill(vl,vl+n,maxLength);

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

    for(int u=0; u<n; u++)
    {
        for(int i=0; i<adj[u].size(); i++)
        {
            int v=adj[u][i].v;
            int w=adj[u][i].w;
            int e=ve[u];
            int l=vl[v]-w;
            if(e==l)
                path[u].push_back(v);
        }
    }

    while(s != t)
    {
        printf("(%c,%c) ", str[s],str[path[s][0]]);
        s=path[s][0];
    }
    printf("%d\n", ve[t]);
}

int main()
{
#ifdef ONLINE_JUDGE
#else
    freopen("Test.txt", "r", stdin);
#endif // ONLINE_JUDGE

    scanf("%d", &k);
    while(k--)
    {
        scanf("%d%d\n", &n,&m);
        scanf("%s\n", str);

        mp.clear();
        fill(inDegree,inDegree+M,0);
        for(int i=0; i<n; i++)
        {
            adj[i].clear();
            path[i].clear();
        }

        for(int i=0; i<n; i++)
            mp[str[i]]=i;
        for(int i=0; i<m; i++)
        {
            int c1,c2,w;
            scanf("%c %c %d\n", &c1,&c2,&w);
            int v1=mp[c1], v2=mp[c2];
            adj[v1].push_back(node{v2,w});
            inDegree[v2]++;
        }
        CriticalPath();
    }

    return 0;
}