求AOE网的关键路径

转自http://blog.csdn.net/jkay_wong/article/details/6696701

以边表示活动，以顶点表示事件的有向网称为AOE(activity on edge)网.AOE网是一个

有向无环图，权值表示活动持续的时间。可以用AOE网来估计工程完成的时间。由于工程

只有一个开始点和一个完成点，所以在无环路的条件下，网中只有一个入度为0的点和一

个出度为0的点.

下面是几个和AOE网有关的概念：

(1)路径长度：路径上各个活动的持续时间之和

(2)完成工程的最短时间：由于AOE网中有活动是并行进行的，所以完成工程的最短时间

就是从开始点到完成点的最长路劲长度。

(3)活动最早开始时间(earlist time)(e(i))：从开始点到顶点vi的最长路径称为事件vi的最早发生时间，

这个时间决定了以vi为尾的弧表示的活动的最早开始时间.

(4)活动最晚开始时间(latest time)(l(i))：在不推迟整个工程完成的前提下，活动最迟开始的时间

(5)完成活动的时间余量：该活动的最迟开始时间减去最早开始时间

(6)关键路径(critical path)：路径长度最长的路径称为关键路径

(7)关键活动(critical activity):关键路径上的活动称为关键活动，关键活动的特点是:e(i)=l(i)

分析关键路径的目的就是辨别在整个工程中哪些是关键活动，以便争取提高关键活动的工作

效率，缩短整个工程的工期。

文件"aoe.h"

#include<iostream>  

#include<string>  

#include<stack>  

#include<iomanip>  

using namespace std;  

  

const int MAX_VEX_NUM=20;  

int ve[20];//全局变量,存放各个事件的最早发生时间  

  

class ArcNode //表结点  

{  

public:  

    int adjvex;  

    int info;//权值  

    ArcNode *nextarc;  

};  

  

class VNode //头结点  

{  

public:  

    string data;  

    int indegree; //顶点的入度  

    ArcNode *firstarc;  

};  

  

class ALGraph   

{  

private:  

    VNode vertices[MAX_VEX_NUM];  

    int arcnum;  

    int vexnum;  

public:  

  

    void Create_ALG()  

    {  

        //构造有向网       

        string v1,v2;  

        int i,j,w;  

        ArcNode *p=NULL;  

  

        cout<<"输入顶点数和边数：";  

        cin>>vexnum>>arcnum;  

  

        cout<<"输入顶点名称：";  

        for(i=0;i<vexnum;i++)  

        {  

            cin>>vertices[i].data;  

            vertices[i].firstarc=NULL;  

            vertices[i].indegree=0;  

        }  

  

        for(int k=0;k<arcnum;k++)  

        {  

            cout<<"按照尾->头的顺序输入每条边对应的两个顶点和该边的权值：";  

            cin>>v1>>v2>>w;  

            i=Locate_Vex(v1);  

            j=Locate_Vex(v2);  

  

            while(i==-1 || j==-1)  

            {  

                cout<<"输入的顶点错误，重新输入：";  

                cin>>v1>>v2;  

                i=Locate_Vex(v1);  

                j=Locate_Vex(v2);  

            }  

  

            p=new ArcNode;  

            p->adjvex=j;  

            p->info=w;  

            p->nextarc=vertices[i].firstarc;  

            vertices[i].firstarc=p;  

            vertices[j].indegree+=1; //作为有向弧的头的顶点入度加1  

        }  

  

        cout<<"有向网构造完成"<<endl;  

    }  

  

    int Locate_Vex(string v) //求顶点在顶点数组中的位置  

    {  

        for(int k=0;k<vexnum && vertices[k].data!=v;k++);  

        if(k<vexnum)  

            return k;  

        else  

            return -1;  

    }  

                                /*关键路径求解思想*/  

            /*--------------------------------------------------------------- 

            / 辨别关键路径就是要找出l(i)=e(i)的活动，为了求AOE网中的e(i)和l(i) 

            / 首先应该求出每个事件的最早发生时间ve(j)和最晚发生时间vl(j),如果 

            / 活动ai用弧<j,k>表示,那么持续时间记为dut(<j,k>).则有如下关系： 

            / e(i)=ve(j),   l(i)=vl(k)-dut(<j,k>); 

            / 求事件的vj的最早发生时间ve(j)和最迟发生时间vl(j)要分两步进行： 

            / (1):从ve(0)=0(假设顶点0是开始点)开始，根据下面公式计算其它事件 

            / 的最早开始时间： ve(j)=Max{ve(i)+dut(<i,j>)} 其中i是j的所有直接前驱的集合 

            / (2)从vl(n-1)=ve(n-1)开始，根据下面公式计算其他事件的最晚开始时间： 

            / vl(i)=Min{vl(j)-dut(<i,j>)} 其中j是i的直接后继的集合 

            / 上述两个公式必须分别在拓扑有序和逆拓扑有序的前提下进行，也就是说ve(j-1) 

            / 必须在vj全部直接前驱的最早发生时间都求得以后才能确定。而vl(j-1)则必须在 

            / vj的所有直接后继的最晚发生时间求得之后才能确定，因此可以在拓扑排序的基础 

            / 上计算所有事件的ve(j-1)和vl(j-1). 

            / 为了能按逆拓扑有序序列的顺序计算各个顶点的vl值，需记下在拓扑排序的过程中 

            / 求得的拓扑有序序列，这只需要增加多一个栈，用来存储拓扑有序序列即可. 

            / 由于栈的结构特点，拓扑有序序列出栈就变成逆拓扑有序序列了. 

            /----------------------------------------------------------------*/  

  

    //求所有事件的最早发生时间  

    bool Topo_Order(stack<int> &T)  

    {  

        stack<int> s;  

        ArcNode *p=NULL;  

        for(int i=0;i<vexnum;i++)  

            if(!vertices[i].indegree)  

                s.push(i);  

        int count=0;  

        for(i=0;i<vexnum;i++)  

            ve[i]=0; //设各顶点最早发生为0  

        while(!s.empty())  

        {  

            int k=s.top();  

            s.pop();  

            T.push(k);  

            count++;  

            for(p=vertices[k].firstarc;p;p=p->nextarc)  

            {  

                int w=p->adjvex;  

                if(vertices[w].indegree)  

                    vertices[w].indegree--;  

                if(!vertices[w].indegree)  

                    s.push(w);  

                if(ve[k]+p->info>ve[w]) //求ve[w]的最早发生时间  

                    ve[w]=ve[k]+p->info;  

            }  

        }  

        if(count<vexnum)  

            return 0;  

        else  

            return 1;  

    }  

      

    //求所有事件的最晚发生时间并求出关键活动和关键路径  

    void Critical_Path()  

    {  

        stack<int> T;  

        string cp[10];  

        int c=0;  

        if(!Topo_Order(T))  

        {  

            cout<<"该有向网有环！"<<endl;  

            return;  

        }  

        int vl[20];  

        for(int i=0;i<vexnum;i++)  

            vl[i]=ve[vexnum-1]; //初始化顶点事件最迟发生时间  

          

        while(!T.empty())  

        {  

            ArcNode *p=NULL;  

            int j=T.top();  

            T.pop();  

            for(p=vertices[j].firstarc;p;p=p->nextarc)  

            {  

                int k=p->adjvex;  

                int dut=p->info;  

                if(vl[k]-dut<vl[j])  

                    vl[j]=vl[k]-dut;  

            }  

        }  

        //下面是根据关键活动的特点(最早开始时间和最晚开始时间相等)求关键活动，做上标记  

        cout<<"tail  head  weight  earliest time  latest time  tag "<<endl;  

        for(int j=0;j<vexnum;j++)  

            for(ArcNode *p=vertices[j].firstarc;p;p=p->nextarc)  

            {  

                int k=p->adjvex;  

                int dut=p->info;  

                int ee=ve[j];  

                int el=vl[k]-dut;  

                char tag;  

                tag=(ee==el)?'*':' ';  

                cout<<setw(3)<<vertices[j].data<<setw(6)<<vertices[k].data<<setw(7)<<dut<<setw(9)<<ee<<setw(16)<<el<<setw(9)<<tag<<endl;  

                if(tag=='*' && j==0)  

                {  

                    cp[c]=vertices[j].data;  

                    c++;  

                    cp[c]=vertices[k].data;  

                    c++;  

                }  

                else if(tag=='*' && j!=0)  

                {  

                    cp[c]=vertices[k].data;  

                    c++;  

                }             

            }  

        cout<<"The critical activities are ended with * "<<endl;  

        cout<<"So the critical path is :";  

        for(i=0;i<c-1;i++)  

            cout<<cp[i]<<"->";  

        cout<<cp[c-1]<<endl;  

    }  

  

};  

主函数"main.cpp"

#include"aoe.h"  

  

int main()  

{  

    ALGraph G;  

    G.Create_ALG();  

    G.Critical_Path();  

    cout<<endl;  

    return 0;  

}  

输入和输出结果：

输入顶点数和边数：6 8  

输入顶点名称：v1 v2 v3 v4 v5 v6  

按照尾->头的顺序输入每条边对应的两个顶点和该边的权值：v1 v2 3  

按照尾->头的顺序输入每条边对应的两个顶点和该边的权值：v1 v3 2  

按照尾->头的顺序输入每条边对应的两个顶点和该边的权值：v2 v5 3  

按照尾->头的顺序输入每条边对应的两个顶点和该边的权值：v2 v4 2  

按照尾->头的顺序输入每条边对应的两个顶点和该边的权值：v3 v4 4  

按照尾->头的顺序输入每条边对应的两个顶点和该边的权值：v3 v6 3  

按照尾->头的顺序输入每条边对应的两个顶点和该边的权值：v4 v6 2  

按照尾->头的顺序输入每条边对应的两个顶点和该边的权值：v5 v6 1  

有向网构造完成  

tail  head  weight  earliest time  latest time  tag  

 v1    v3      2        0               0        *  

 v1    v2      3        0               1  

 v2    v4      2        3               4  

 v2    v5      3        3               4  

 v3    v6      3        2               5  

 v3    v4      4        2               2        *  

 v4    v6      2        6               6        *  

 v5    v6      1        6               7  

The critical activities are ended with *  

So the critical path is :v1->v3->v4->v6  

  

Press any key to continue  

根据输入所生成的有向网如下所示：



当关键路径只有一条时，输出关键路径是对的，当关键路径不知一条时就是错的，但是依然是可以找出所有的关键活动，路径输出的算法，以后会完善到可以输出所以关键路径

求逆拓扑有序序列 除了利用求拓扑有序时进栈外，还可以直接用DFS遍历该有向图，直到该结点的所有邻接结点都输出之后，才将其输出，这个序列就是逆拓扑有序序列