關鍵路徑

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;
}