關鍵路徑,關鍵活動

1. 事件的最早發生時間ve
   ve(源點) = 0；
   ve(k) = max(ve[j] + weight[j,k]),

2. 事件的最遲發生時間vl
   vl（終點） = ve(終點)
   vl(j) =min(vl(k) - weght[k,j])

3. 活動的最早開始時間e
   表示活動的起點所表示的事件最早發生時間。

4. 活動的最遲開始時間l
   表示活動的終點所表示的事件最遲發生時間與該活動所需時間之差。

5. 找到所有活動的差額d(),找出d()=0的活動構成關鍵路徑
   指活動完成的事件餘量，d(i) = l(i) - e(i)

關鍵路徑的注意
* 關鍵路徑上的所有活動都是關鍵活動，它是決定整個工程的關鍵因素
* 關鍵路徑並不唯一。對於有幾條關鍵路徑的網，只提高一條關鍵路徑上的關鍵活動並不能縮短整個工程的工期，只有加快那些包括所有關鍵路徑上的關鍵活動才能達到縮短工期的目的

例子

08-圖9 關鍵活動

題目地址

題目描述

假定一個工程專案由一組子任務構成，子任務之間有的可以並行執行，有的必須在完成了其它一些子任務後才能執行。“任務排程”包括一組子任務、以及每個子任務可以執行所依賴的子任務集。

比如完成一個專業的所有課程學習和畢業設計可以看成一個本科生要完成的一項工程，各門課程可以看成是子任務。有些課程可以同時開設，比如英語和C程式設計，它們沒有必須先修哪門的約束；有些課程則不可以同時開設，因為它們有先後的依賴關係，比如C程式設計和資料結構兩門課，必須先學習前者。

但是需要注意的是，對一組子任務，並不是任意的任務排程都是一個可行的方案。比如方案中存在“子任務A依賴於子任務B，子任務B依賴於子任務C，子任務C又依賴於子任務A”，那麼這三個任務哪個都不能先執行，這就是一個不可行的方案。
任務排程問題中，如果還給出了完成每個子任務需要的時間，則我們可以算出完成整個工程需要的最短時間。在這些子任務中，有些任務即使推遲幾天完成，也不會影響全域性的工期；但是有些任務必須準時完成，否則整個專案的工期就要因此延誤，這種任務就叫“關鍵活動”。

請編寫程式判定一個給定的工程專案的任務排程是否可行；如果該排程方案可行，則計算完成整個工程專案需要的最短時間，並輸出所有的關鍵活動。

輸入格式:

輸入第1行給出兩個正整數NN(\le 100≤100)和MM，其中NN是任務交接點（即銜接相互依賴的兩個子任務的節點，例如：若任務2要在任務1完成後才開始，則兩任務之間必有一個交接點）的數量。交接點按1~NN編號，MM是子任務的數量，依次編號為1~MM。隨後MM行，每行給出了3個正整數，分別是該任務開始和完成涉及的交接點編號以及該任務所需的時間，整數間用空格分隔。

輸出格式:

如果任務排程不可行，則輸出0；否則第1行輸出完成整個工程專案需要的時間，第2行開始輸出所有關鍵活動，每個關鍵活動佔一行，按格式“V->W”輸出，其中V和W為該任務開始和完成涉及的交接點編號。關鍵活動輸出的順序規則是：任務開始的交接點編號小者優先，起點編號相同時，與輸入時任務的順序相反。

輸入樣例 1

7 8
1 2 4
1 3 3
2 4 5
3 4 3
4 5 1
4 6 6
5 7 5
6 7 2

輸出樣例 1

17
1->2
2->4
4->6
6->7

輸入樣例 2

7 6
1 2 4
1 3 3
2 4 5
3 4 3
5 7 5
6 7 2

輸出樣例 2

9
1->2
2->4

ac程式碼

比較複雜的ac程式碼
使用了鄰接表，按照關鍵路徑的思路來求解

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <algorithm>
#include <sstream>

using namespace std;

const int N = 105;
const int INF = 0x7fffffff;

struct activity{
    int sta;
    int end;
    int cost;
    bool flag; // sta是否是活動的起點
};

vector<vector<activity>> vedge; // 某個事件的鄰接事件

vector<int> in_degree; // 入度
vector<int> out_degree; // 出度
vector<int> ve; // 事件的最早發生時間
vector<int> vl; // 事件的最遲發生時間

vector<activity> vact; // 所有的活動
vector<int> l; // 活動的最早開始時間
vector<int> e; // 活動的最遲開始時間

int n,m;
vector<int> vSta; // 入度為0的原點
vector<int> vEnd; // 出度為0的終點
int MinTime; // 完成時間

// 拓撲排序是否合理
bool isTop(vector<int> in_degree)
{
    vector<bool> vis(n+1,false);

    int num = 0;
    while(num < n)
    {
        int nowNum = -1;
        for(int i=1;i<=n;i++)
        {
            if(!vis[i] && in_degree[i] == 0)
            {
                nowNum = i;
                break;
            }
        }
        if(nowNum == -1)
            return false;

        vis[nowNum] = true;
        in_degree[nowNum] = -1;

        int len = vedge[nowNum].size();
        for(int i = 0; i< len ; i ++)
        {
            activity tmp =  vedge[nowNum][i];
            if(tmp.flag)
            {
                if(vis[tmp.end] == false)
                    in_degree[tmp.end] --;
            }
        }

        num++;
    }

    if(num == n)
        return true;
    return false;
}

void solve_ve()
{
    vector<int>::iterator it = vSta.begin();
    vector<bool> vis(n+1,false);
    while(it != vSta.end())
    {
        queue<int> que;
        que.push(*it);
        ve[*it] = 0;
        vis[*it] = true;

        while(!que.empty())
        {
            int nowNum = que.front();
            que.pop();

            int len = vedge[nowNum].size();
            for(int i=0;i<len;i++)
            {
                activity tmp = vedge[nowNum][i];
                if(tmp.flag)
                {
                    in_degree[tmp.end] --;
                    ve[tmp.end] = max(ve[tmp.end], ve[nowNum] + tmp.cost);
                    if(in_degree[tmp.end] == 0)
                    {
                        que.push(tmp.end);
                        vis[tmp.end] = true;
                    }
                }
            }
        }
        ++it;
    }
}

// 求事件的最遲發生時間
void solve_vl()
{
    vector<int>::iterator it = vEnd.begin();
    vector<bool> vis(n+1,false);
    while(it != vEnd.end())
    {
        int endP = *it;
        vl[endP] = MinTime; // 所有出度為0時間，其時間最遲發生時間為最大的ve[]
        queue<int> que;
        que.push(endP);

        vis[endP] = true;
        out_degree[endP] = -1;

        while(!que.empty())
        {
            int nowNum = que.front();
            que.pop();

            int len = vedge[nowNum].size();
            for(int i = 0; i< len ; i ++)
            {
                activity tmp =  vedge[nowNum][i];
                if(vis[tmp.sta])
                    continue;

                if(tmp.flag == false)
                {
                    out_degree[tmp.sta] --;
                    vl[tmp.sta] = min(vl[tmp.sta], vl[nowNum] - tmp.cost);
                    if(out_degree[tmp.sta] == 0) // 出度為0 可以確定最遲開始時間了
                    {
                        vis[tmp.sta] = true;
                        que.push(tmp.sta);
                    }
                }
            }
        }

        ++it;
    } // end while
}

bool cmp(activity a1,activity a2)
{
    if(a1.sta < a2.sta)
        return true;
    else if(a1.sta == a2.sta)
    {
        if(a1.end > a2.end)
            return true;
    }
    return false;
}

int main()
{
    //freopen("in.txt","r",stdin);

    scanf("%d%d",&n,&m);
    vedge.resize(n+1);
    in_degree.resize(n+1,0);
    out_degree.resize(n+1,0);
    ve.resize(n+1,0);
    vl.resize(n+1,INF);
    vact.clear();
    l.resize(m + 1);
    e.resize(m + 1);
    activity actTmp;
    for(int i=0;i<m;i++)
    {
        scanf("%d%d%d",&actTmp.sta,&actTmp.end,&actTmp.cost);

        actTmp.flag = true;
        vact.push_back(actTmp);
        in_degree[actTmp.end] ++; // 入度
        out_degree[actTmp.sta] ++ ; // 出度
        vedge[actTmp.sta].push_back(actTmp);
        actTmp.flag = false;
        vedge[actTmp.end].push_back(actTmp);
    }

    if(!isTop(in_degree))
    {
        printf("0\n");
        return 0;
    }

    for(int i = 1;i <= n; i++)
    {
        if(in_degree[i] == 0)
            vSta.push_back(i);
        if(out_degree[i] == 0)
            vEnd.push_back(i);
    }

    // ve求解 
    solve_ve();

    // 完成整個工程專案需要的時間
    MinTime = 0;
    for(int i=1;i<=n;i++)
    {
        if(ve[i] > MinTime)
        {
            MinTime = ve[i];
        }
    }

    // vl 求解
    solve_vl();

    vector<activity> critical;
    int criLen = 0;
    // l, e求解, 並求解關鍵路徑
    for(int i=0;i<m;i++)
    {
        l[i] = ve[vact[i].sta];

        e[i] = vl[vact[i].end] - vact[i].cost;

        if(e[i] == l[i]) // d[] = 0
        {
            critical.push_back(vact[i]);
            criLen ++;
        }
    }

    // 按照輸出順序對結果排序
    sort(critical.begin(),critical.end(),cmp);

    printf("%d\n",MinTime);
    for(int i=0;i<criLen;i++)
    {
        printf("%d->%d\n",critical[i].sta,critical[i].end);
    }

    return 0;
}

參考ac程式碼

採用鄰接矩陣，按照求關鍵路徑的步驟，ac程式碼如下

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <algorithm>
#include <sstream> 
using namespace std;

const int INF = 0x7fffffff;
const int N = 102;  

int Graph[N][N];
int in_degree[N];
int out_degree[N];
int vearly[N];
int vlate[N];
int n,m;
int MinTime; // 最少花費時間
vector<int> vSta; // 入度為0的原點
vector<int> vEnd; // 出度為0的終點

// 求出vearly，並能據此判斷是否是合理的排程
bool sol_vearly()
{
    vector<int>::iterator it = vSta.begin();
    vector<bool> vis(n+1,false);
    while(it != vSta.end())
    {
        queue<int> que;
        que.push(*it);
        vearly[*it] = 0;
        vis[*it] = true;

        while(!que.empty())
        {
            int nowNum = que.front();
            que.pop();

            for(int i=1;i<=n;i++)
            {
                if(Graph[nowNum][i] >= 0 && !vis[i])
                {
                    in_degree[i] --;
                    vearly[i] = max(vearly[i], vearly[nowNum] + Graph[nowNum][i]);
                    if(in_degree[i] == 0)
                    {
                        que.push(i);
                        vis[i] = true;
                    }
                }
            }
        }
        ++it;
    }

    for(int i=1;i<=n;i++){
        if(vis[i] == false)
            return false;
        if(vearly[i] > MinTime)
        {
            MinTime = vearly[i];
        }
    }
    return true;
}

// 求事件的最遲發生時間
void solve_vlate()
{
    vector<int>::iterator it = vEnd.begin();
    vector<bool> vis(n+1,false);
    while(it != vEnd.end())
    {
        int endP = *it;
        vlate[endP] = MinTime; // 所有出度為0時間，其時間最遲發生時間為最大的ve[]
        queue<int> que;
        que.push(endP);

        vis[endP] = true;
        out_degree[endP] = -1;

        while(!que.empty())
        {
            int nowNum = que.front();
            que.pop();

            for(int i = 1; i<=n; i ++)
            {
                if(vis[i] || Graph[i][nowNum] < 0)
                    continue;
                out_degree[i] --;
                vlate[i] = min(vlate[i], vlate[nowNum] - Graph[i][nowNum]);
                if(out_degree[i] == 0) // 出度為0 可以確定最遲開始時間了
                {
                    vis[i] = true;
                    que.push(i);
                }

            }
        }

        ++it;
    } // end while
}

int main(int argc, char const *argv[])  
{  
    //freopen("in.txt", "r", stdin);  

    scanf("%d %d", &n, &m);
    // 初始化資料
    for (int i = 1; i <= n; i++)
    {  
        for (int j = 1; j <= n; j++)
            Graph[i][j] = -1;  
        in_degree[i] = 0;  
        out_degree[i] = 0;  
        vearly[i] = 0;  
        vlate[i] = INF;  
    }

    int s, e, c;  
    for (int i = 0; i < m; i++){  
        scanf("%d %d %d", &s, &e, &c);  
        Graph[s][e] = c;  
        out_degree[s]++;  
        in_degree[e]++;  
    }

    for(int i = 1;i <= n; i++)
    {
        if(in_degree[i] == 0)
            vSta.push_back(i);
        if(out_degree[i] == 0)
            vEnd.push_back(i);
    }

    if(!sol_vearly()){
         printf("0\n");
    }else{
        solve_vlate();

        printf("%d\n", MinTime);  
        for (int i = 1; i <= n; i++)
        {  
            for (int j = n; j >= 1; j--)
            {  
                // 活動的最早開始時間 == 活動的最遲開始時間
                if (Graph[i][j] >= 0 && vearly[i] == (vlate[j] - Graph[i][j]))  
                    printf("%d->%d\n", i, j);  
            }  
        }  

    }
    return 0;  
}