算法學習記錄-圖——應用之關鍵路徑（Critical Path）

 

之前我們介紹過，在一個工程中我們關心兩個問題：

（1）工程是否順利進行

（2）整個工程最短時間。

 

之前我們優先關心的是頂點（AOV），同樣我們也可以優先關心邊（同理有AOE）。（Activity On Edge Network）

看看百度百科上解釋：

AOE網：Activity on edge network

若在帶權的有向圖中，以頂點表示事件，以有向邊表示活動，邊上的權值表示活動的開銷（如該活動持續的時間），則此帶權的有向圖稱為AOE網。

如果用AOE網來表示一項工程，那么，僅僅考慮各個子工程之間的優先關系還不夠，更多的是關心整個工程完成的最短時間是多少；

哪些活動的延期將會影響整個工程的進度，而加速這些活動是否會提高整個工程的效率。

因此，通常在AOE網中列出完成預定工程計划所需要進行的活動，每個活動計划完成的時間，要發生哪些事件以及這些事件與活動之間的關系，

從而可以確定該項工程是否可行，估算工程完成的時間以及確定哪些活動是影響工程進度的關鍵。

很顯然，頂點表示事件，邊表示活動，邊的權則表示活動持續時間。

AOE一般用來估算工程的完成時間。

AOE表示工程的流程，把沒有入邊的稱為始點或者源點，沒有出邊的頂點稱為終點或者匯點。一般情況下，工程只有一個開始，一個結束，

所以正常情況下，AOE只有一個源點一個匯點。

 

AOV和AOE的區別：

1.AOV用頂點表示活動的網，描述活動之間的制約關系。

2.AOE用邊表示活動的網，邊上的權值表示活動持續的時間。

AOE 是建立在子過程之間的制約關系沒有矛盾的基礎之上，再來分析整個過程需要的時間。

 

AOE研究：

a.完成整個過程至少需要多長時間。

b.哪些活動影響工程的進度？

---

 

關鍵路徑：從源點到匯點具有最大長度的路徑。這個概念要清楚，一個工程不一定有一條關鍵路徑，可能會有多條。

關鍵活動：關鍵路徑上的活動（邊）。

針對上面AOE所關心的問題，要想縮短工程時間，就縮短關鍵路徑上的過程即可。（縮短后可能出現之前的關鍵路徑變成了非關鍵路徑）

 

由於AOE網上所有的活動是可以並行進行。這里舉一個例子，組裝一個變形金剛，需要頭，左膀右臂，身體，左腿右腿。

我們可以有兩種方法：1.先做好頭，做左手臂，做右手臂，做身體，做左腿，做右腿，然后再組裝。

　　　　　　　　　　2.同時做頭、手臂、身體、腿的部分，每有一個頭、兩個手臂、兩個腿和一個身體的時候，就可以組裝了。

方法1.如我們計算機中的串行運行。這樣時間開銷是累加的。

方法2.如我們計算機中的並行運行。這樣時間開銷可以立體應用。在此方法中，同時做各個部位時間不同，比如做頭時間最長，那么整個一個

變形金剛所用的時間決定與做頭的時間，如果做手臂的時間是做頭時間的一半，那么就是說做手臂的時間點可以在頭做了一半的時候。只要不超過這個

時間點，手臂部分是不會影響整個工程的進度的。

 

這里定義四個定義：前兩個針對頂點，后兩個針對邊

事件最早開始時間：頂點Vi最早發生的時間。

事件最晚開始時間：頂點Vi最晚發生的時間，超出則會延誤整個工期。

活動的最早開始時間：邊Eg最早發生時間。

活動的最晚開始時間：邊Eg最晚發生時間。不推遲工期的最晚開工時間。

 

下面這個例子說明一下：

說明：上圖中J中為49，是最早開始時間。這里可以看到最早開始時間，就是完要成該頂點，前面的所有到該點的路徑都要已經完成。所以取路徑最大那一條。

補充說明：

事件最早開始時間：例子圖中，F點，ACF（9） 和 ADF（19），到達F點時候，保證AC和AD都完成，這樣 F才能開始，所以F點的最早開始時間取最大值，即19.

　　　　　　　可以看出，要求出到某一點的最早開始時間，則需要將匯於該點的所有路徑的時間求出來，取最大值。

事件最遲開始時間：這里是反着推，比如H點最遲開始時間，H到J 與 H到I到J兩條路徑，39 和 44，所謂最遲開始時間，就是超過這個時間就會影響整個工程進度，

　　　　　　   而這個時間是時間點，是從源點工程開始計時的，所以對於H點，39和44是相對於源點，如果取44，則H-J這條路徑就會拖延，最遲開始時間選擇最小值。

 

關鍵路徑的特點：我們尋找關鍵路徑——關鍵路徑就是關鍵活動（頂點與頂點之間的邊組成），就是我們怎么判斷該頂點是否為關鍵活動（邊）的頂點，即判斷邊是否為關鍵活動。

　　　　　　　　前面定義過，關鍵路徑就是圖中從源點到匯點最長（權值最大）的路徑。

　　　　　　　　這條路徑就決定了整個工程的工期，這說明一個什么問題？

　　　　　　　　關鍵路徑上的頂點與頂點之間的活動的應該最早開始和最遲開始時間是相等的，

　　　　　　　　如果不等那么說明活動還有余額時間（在最早開始時間和最遲開始時間之間可以任選一個時間點開始），這說明還有其他活動是決定這個工程時間的，那就不是關鍵路徑了。

---

 

算法思想：

要准備兩個數組，a：最早開始時間數組etv，b：最遲開始時間數組。（針對頂點即事件而言）

1.從源點V0出發，令etv[0]（源點）=0，按拓撲有序求其余各頂點的最早發生時間etv[i]（1 ≤ i ≤ n-1）。同時按照上一章

拓撲排序的方法檢測是否有環存在。

2.從匯點Vn出發，令ltv[n-1] = etv[n-1]，按拓撲排序求各個其余各頂點的最遲發生時間ltv[i]（n-2 ≥ i ≥ 2）;

3.根據各頂點的etv和ltv數組的值，求出弧（活動）的最早開工時間和最遲開工時間，求每條弧的最早開工時間和最遲開工時間是否相等，若相等，則是關鍵活動。

注意：1，2 完成點（事件）的最早和最遲。3根據事件來計算活動最早和最遲，從而求的該弧（活動）是否為關鍵活動。

 

 

---

 

關鍵代碼：

1.對圖進行拓撲排序，存儲了拓撲排序的順序，作為關鍵路徑的計算最遲開始時間的依據。

 

int TopplogicalSort(GraphAdjList *g)
{
    int count=0;
    eNode *e=NULL;

    StackType *stack=NULL;
    StackType top=0;
    stack = (StackType *)malloc((*g).numVextexs*sizeof(StackType));
    
    int i;
    
    //初始化拓撲序列棧
    g_topOfStk = 0;
    //開辟拓撲序列棧對應的最早開始時間數組
    g_etv = (int *)malloc((*g).numVextexs*sizeof(int));
    //初始化數組
    for (i=0;i<(*g).numVextexs;i++)
    {
        g_etv[i]=0;
    }
    //開辟拓撲序列的頂點數組棧
    g_StkAfterTop = (int *)malloc(sizeof(int)*(*g).numVextexs);
    
    
    

    for (i=0;i<(*g).numVextexs;i++)
    {
        if (!(*g).adjList[i].numIn)
        {
            stack[++top] = i;
    //        printf("init no In is %c\n",g_init_vexs[i]);
        }
    }
    

    while(top)
    {
        int geter = stack[top];
        top--;

        //把拓撲序列保存到拓撲序列棧，為后面做准備
        g_StkAfterTop[g_topOfStk++] = geter;
        
        printf("%c -> ",g_init_vexs[(*g).adjList[geter].idx]);
        count++;

        //獲取當前點出度的點，對出度的點的入度減一（當前點要出圖）。
        //獲取當前頂點的出度點表
        e = (*g).adjList[geter].fitstedge;
        while(e)
        {
            int eIdx = e->idx;
            //選取的出度點的入度減一
            int crntIN = --(*g).adjList[eIdx].numIn;
            if (crntIN == 0)
            {
                //如果為0，則說明該頂點沒有入度了，是下一輪的輸出點。
                stack[++top] = eIdx;
        //        printf("running the vex is %c\n",g_init_vexs[e->idx]);
            }

            //求出關鍵路徑
            if ((g_etv[geter] + e->weigh) > g_etv[eIdx])
            {
                g_etv[eIdx] = g_etv[geter] + e->weigh;
            }

            e = e->next;
        }
    }
    if (count < (*g).numVextexs)//如果圖本身就是一個大環，或者圖中含有環，這樣有環的頂點不會進棧而被打印出來。
    {
        return false;
    }
    else
    {
        printf("finish\n");
        return true;
    }
    
}

 

 2.關鍵路徑代碼：

void CriticalPath(GraphAdjList g)
{
    int i;
    int geter;
    eNode *e = NULL;
    g_topOfStk--;
    //1.初始化最遲開始時間數組(匯點的最早開始時間（初值）)
    g_ltv = (int *)malloc(sizeof(int)*g.numVextexs);
    for (i=0;i<g.numVextexs;i++)
    {
        g_ltv[i] = g_etv[g.numVextexs-1];
    }

    //2.求每個點的最遲開始時間，從匯點到源點推。
    while (g_topOfStk)
    {
        //獲取當前出棧（反序）的序號
        geter = g_StkAfterTop[g_topOfStk--];
        //對每個出度點
        if (g.adjList[geter].fitstedge != NULL)
        {
            e = g.adjList[geter].fitstedge;
            while(e != NULL)
            {
                int eIdx = e->idx;
                if (g_ltv[eIdx] - e->weigh < g_ltv[geter])
                {
                    g_ltv[geter] = g_ltv[eIdx] - e->weigh;
                }
                e = e->next;
            }
        }
    }

    int ete,lte;//活動最早開始和最遲開始時間

    

    printf("start:->");
    //3.求關鍵活動，即ltv和etv相等的
    for (i=0;i<g.numVextexs;i++)
    {
        if (g.adjList[i].fitstedge)
        {
            e = g.adjList[i].fitstedge;
            while(e)
            {
                int eIdx = e->idx;
                //活動（i->eIdx）最早開始時間：事件（頂點） i最早開始時間
                ete = g_etv[i];
                //活動（i->eIdx）最遲開始時間：事件（頂點） eIdx 最遲開始時間 減去 活動持續時間
                lte = g_ltv[eIdx] - e->weigh; 
                if (ete == lte)
                {
                    printf("(%c - %c)->",g_init_vexs[i],g_init_vexs[eIdx]);
                }
                e= e->next;
            }
        }
    }
    printf(" end\n");
}

 

編程所用的圖：

拓撲排序結果：

 

過程：

1.從J開始，無后繼，不做任何事情；

2.G，G的ltv為27，ltv-weight = 27-2 < 27,所以G的ltv為25；

3.I，I的ltv為27，ltv-weight = 27 -3 < 27,所以I的ltv為24；

4.H，H的ltv為24（I的ltv），24-5 < 24,所以H 的ltv為19；

依次類推。。。

 

完成top排序和關鍵路徑后：

全局存放各個頂點的最早開始和最遲開始時間：

完整代碼：

// grp-top.cpp : 定義控制台應用程序的入口點。
//
// grp-top.cpp : 定義控制台應用程序的入口點。
//

#include "stdafx.h"
#include <stdlib.h>


#define MAXVEX 100
#define IFY 65535


typedef char VertexType;
typedef int  EdgeType;
typedef int  IdxType;
typedef int QueueType;
typedef int StackType;


//-------
int *g_etv = NULL;
int *g_ltv = NULL;
int *g_StkAfterTop;
int g_topOfStk;


///---------------------------------------
//邊節點
typedef struct EdgeNode{
    IdxType idx;
    int weigh;
    struct EdgeNode* next;
}eNode;

//頂點節點
typedef struct VexNode{
    int numIn;        //入度數量
    IdxType idx;
    eNode *fitstedge;
}vNode;

//圖的集合：包含了一個頂點數組
typedef struct {
    vNode adjList[MAXVEX];
    int numVextexs,numEdges;
}GraphAdjList;

///-----------------------------------
/*VertexType g_init_vexs[MAXVEX] = {'A','B','C','D','E','F','G','H','I','J','K','L'};

char *g_input[] = {
    "A->B->C->D",
    "B->E",
    "C->F->I->J",
    "D->E->I->J",
    "E",
    "F->K",
    "G->F->H->K",
    "H->I",
    "I->J->L",
    "J->E->K",
    "K->L",
    "L"
};*/

///-----------------------------------
VertexType g_init_vexs[MAXVEX] = {'A','B','C','D','E','F','G','H','I','J'};

char *g_input[] = {
    "A->B->C",
    "B->D->E",
    "C->D->F",
    "D->E",
    "E->G->H",
    "F->H",
    "G->J",
    "H->I",
    "I->J",
    "J",
    NULL
};

char *g_input_weigh[] = {
    "3,4",//A
    "5,6",//B
    "8,7",//C
    "3",//D
    "9,4",//E
    "6",//F
    "2",//G
    "5",//H
    "3",//I
    " ",//J
    NULL
};
//===============================================================
//隊列

//隊列節點
typedef struct Node {
    QueueType data;
    struct Node *next;
}QNode,*qQNode;

//隊列指示
typedef struct {
    int length;
    qQNode frnt,rear;    
}spQueue;

void init_Queue(spQueue *Q)
{
    (*Q).frnt = NULL;
    (*Q).rear = NULL;
    (*Q).length = 0;
}
bool isEmptyQueue(spQueue Q)
{
    if (Q.length == 0)
    {
        return true;
    }
    return false;
}
//進隊
void unshiftQueue(spQueue *Q,QueueType elem)
{
    //隊列空
    if (isEmptyQueue(*Q))
    {
        qQNode n = (qQNode)malloc(sizeof(QNode));
        n->data = elem;
        n->next = NULL;

        (*Q).frnt = n;
        (*Q).rear = n;
        (*Q).length = 1;
    }
    else
    {
        qQNode n = (qQNode)malloc(sizeof(QNode));
        n->data = elem;
        n->next = NULL;

        (*Q).rear->next = n;

        (*Q).rear = n;
        (*Q).length++;
    }
}

//出隊
QueueType shiftQueue(spQueue *Q)
{
    if (isEmptyQueue(*Q))
    {
        printf("Warning:Queue is empty!!!\n");
        return NULL;
    }
    if ((*Q).length == 1)
    {
        QueueType sh = (*Q).frnt->data;
        (*Q).frnt = NULL;
        (*Q).rear = NULL;
        (*Q).length = 0;
        return sh;
    }
    QueueType sh = (*Q).frnt->data;
    (*Q).frnt = (*Q).frnt->next;
    (*Q).length--;

    return sh;
}

//打印隊列
void prt_que(spQueue que)
{
    if (isEmptyQueue(que))
    {
        return ;
    }
    qQNode pos = que.frnt;
    while(que.rear->next != pos && pos != NULL)
    {
        printf(" %d ",pos->data);
        pos = pos->next;
    }
    printf("\n");
}
//===============================================================

///-------
//由節點找節點的序號
IdxType strFindIdx(char ch)
{
    int i=0;
    VertexType *p = g_init_vexs;
    while(p != NULL)
    {
        if(*p == ch)
        {
            return i;
        }
        p++;
        i++;
    }
    return i;
}

//由序號找節點
VertexType idxFindStr(IdxType i)
{
    return g_init_vexs[i];
}

void prt_strings(char *p)
{
    char *pos = p;
    while (NULL != *pos)
    {
        printf("%c",*pos);
        pos++;
    }
    printf("\n");
}

void prt_strArrays(char *p[],int num)
{
    char **pos = p; 
    int i=0;
    while( *pos != NULL && i < num)
    {
        prt_strings(*pos);
        pos++;
        i++;
    }
}

//自己規定：頂點只能是大寫。
bool isVexter(char p)
{
    if (p>='A' && p<='Z')
    {
        return true;
    }
    return false;
}

bool isNumeric(char p)
{
    if (p >= '0' && p <= '9')
    {
        return true;
    }
    return false;
}

void init_GrapAdjList(GraphAdjList *g,char **str,char **wstr)
{
    char **pos = str;
    
    int cnt=0;
    int vcnt = 0;
    char **wpos = wstr;//weight value

    //入度清零
    int i;
    for (i=0;i<MAXVEX;i++)
    {
        (*g).adjList[i].numIn = 0;
    }

    while (*pos != NULL) //g_input的每行的首指針
    {
        int i=0;
        while(**pos != NULL) //g_input的每行字母
        {
            if(isVexter(**pos)) //判斷是否為頂點（我規定‘A’-‘Z’之間為頂點標志）
            {
                if (i == 0) //建立頂點的節點
                {
                    (*g).adjList[cnt].idx = strFindIdx(**pos);
                    (*g).adjList[cnt].fitstedge = NULL;
                    
                    i=1;
                }
                else if(i == 1) //建立第一個邊的節點
                {
                    eNode* n = (eNode*)malloc(sizeof(eNode));
                    n->idx = strFindIdx(**pos);
                    n->next = NULL;

                    //weight
                    while (!isNumeric(**wpos))
                    {
                        (*wpos)++;
                    }
                    n->weigh = **wpos-'0';
                    (*wpos)++;

                    (*g).adjList[cnt].fitstedge = n;
                    i=2;

                    //添加入度
                    int iidx = strFindIdx(**pos);
                    (*g).adjList[iidx].numIn++;
                }
                else //邊節點連接到前一個邊節點上
                {    
                    eNode* n = (eNode*)malloc(sizeof(eNode));
                    n->idx = strFindIdx(**pos);
                    n->next = NULL;

                    //weight
                    while (!isNumeric(**wpos))
                    {
                        (*wpos)++;
                    }
                    n->weigh = **wpos-'0';
                    (*wpos)++;

                    //first splist
                    eNode *r = (*g).adjList[cnt].fitstedge;
                    while (r->next != NULL)
                    {
                        r = r->next;
                    }
                    r->next = n;

                    //添加入度
                    int iidx = strFindIdx(**pos);
                    (*g).adjList[iidx].numIn++;
                }
            }
            (*pos)++; 
        }

        wpos++;
        cnt++;
        pos++;
        
    }
    (*g).numVextexs = cnt;
}

int TopplogicalSort(GraphAdjList *g)
{
    int count=0;
    eNode *e=NULL;

    StackType *stack=NULL;
    StackType top=0;
    stack = (StackType *)malloc((*g).numVextexs*sizeof(StackType));
    
    int i;
    
    //初始化拓撲序列棧
    g_topOfStk = 0;
    //開辟拓撲序列棧對應的最早開始時間數組
    g_etv = (int *)malloc((*g).numVextexs*sizeof(int));
    //初始化數組
    for (i=0;i<(*g).numVextexs;i++)
    {
        g_etv[i]=0;
    }
    //開辟拓撲序列的頂點數組棧
    g_StkAfterTop = (int *)malloc(sizeof(int)*(*g).numVextexs);
    
    
    

    for (i=0;i<(*g).numVextexs;i++)
    {
        if (!(*g).adjList[i].numIn)
        {
            stack[++top] = i;
    //        printf("init no In is %c\n",g_init_vexs[i]);
        }
    }
    

    while(top)
    {
        int geter = stack[top];
        top--;

        //把拓撲序列保存到拓撲序列棧，為后面做准備
        g_StkAfterTop[g_topOfStk++] = geter;
        
        printf("%c -> ",g_init_vexs[(*g).adjList[geter].idx]);
        count++;

        //獲取當前點出度的點，對出度的點的入度減一（當前點要出圖）。
        //獲取當前頂點的出度點表
        e = (*g).adjList[geter].fitstedge;
        while(e)
        {
            int eIdx = e->idx;
            //選取的出度點的入度減一
            int crntIN = --(*g).adjList[eIdx].numIn;
            if (crntIN == 0)
            {
                //如果為0，則說明該頂點沒有入度了，是下一輪的輸出點。
                stack[++top] = eIdx;
        //        printf("running the vex is %c\n",g_init_vexs[e->idx]);
            }

            //求出關鍵路徑
            if ((g_etv[geter] + e->weigh) > g_etv[eIdx])
            {
                g_etv[eIdx] = g_etv[geter] + e->weigh;
            }

            e = e->next;
        }
    }
    if (count < (*g).numVextexs)//如果圖本身就是一個大環，或者圖中含有環，這樣有環的頂點不會進棧而被打印出來。
    {
        return false;
    }
    else
    {
        printf("finish\n");
        return true;
    }
    
}
void CriticalPath(GraphAdjList g)
{
    int i;
    int geter;
    eNode *e = NULL;
    g_topOfStk--;
    //1.初始化最遲開始時間數組(匯點的最早開始時間（初值）)
    g_ltv = (int *)malloc(sizeof(int)*g.numVextexs);
    for (i=0;i<g.numVextexs;i++)
    {
        g_ltv[i] = g_etv[g.numVextexs-1];
    }

    //2.求每個點的最遲開始時間，從匯點到源點推。
    while (g_topOfStk)
    {
        //獲取當前出棧（反序）的序號
        geter = g_StkAfterTop[g_topOfStk--];
        //對每個出度點
        if (g.adjList[geter].fitstedge != NULL)
        {
            e = g.adjList[geter].fitstedge;
            while(e != NULL)
            {
                int eIdx = e->idx;
                if (g_ltv[eIdx] - e->weigh < g_ltv[geter])
                {
                    g_ltv[geter] = g_ltv[eIdx] - e->weigh;
                }
                e = e->next;
            }
        }
    }

    int ete,lte;//活動最早開始和最遲開始時間

    

    printf("start:->");
    //3.求關鍵活動，即ltv和etv相等的
    for (i=0;i<g.numVextexs;i++)
    {
        if (g.adjList[i].fitstedge)
        {
            e = g.adjList[i].fitstedge;
            while(e)
            {
                int eIdx = e->idx;
                //活動（i->eIdx）最早開始時間：事件（頂點） i最早開始時間
                ete = g_etv[i];
                //活動（i->eIdx）最遲開始時間：事件（頂點） eIdx 最遲開始時間 減去 活動持續時間
                lte = g_ltv[eIdx] - e->weigh; 
                if (ete == lte)
                {
                    printf("(%c - %c)->",g_init_vexs[i],g_init_vexs[eIdx]);
                }
                e= e->next;
            }
        }
    }
    printf(" end\n");
}


int _tmain(int argc, _TCHAR* argv[])
{
    GraphAdjList grp;
    printf("print Matix: of Vextexs:\n");
    prt_strArrays(g_input,10);
    printf("print Matix: of Weigh:\n");
    prt_strArrays(g_input_weigh,10);

    init_GrapAdjList(&grp,g_input,g_input_weigh);
    printf("Top sort:\n");
    if (!TopplogicalSort(&grp))
    {
        printf("grp wrong!\n");
    }
    
    CriticalPath(grp);

    getchar();
    return 0;
}

測試結果：