图——活动网络

AOV网

　　顶点表示活动的网络AOV，用顶点表示活动或任务，边表示活动或任务之间的优先关系的优先图G。

定义：从i到j存在一条路径，i为顶点j的前驱，<i,j>直接前驱。后继，直接后继

　　优先关系是传递的，判断优先关系是否反自反较困难，如果优先关系不是反自反的，那么存在那就存在一个活动是其自身的前驱。

　　判断AOV网络中不存在优先环路，可以证明优先关系是反自反的。

拓扑排序：所有顶点在一个先行序列中，对于图中的任意两个顶点i和j，i是j的前驱，则i在排序在j的前面。

topsort算法：

　　1.列出没有前驱的所有顶点

　　2.删除这些顶点及其出边

重复知道所有顶点被列出。

// AOV网，顶点活动网络，用于表示活动或者任务之间的优先关系。例如选课工程中，一些课程必须在其他课程修完，才能再修。
//定义 AOV网中，前驱，直接前驱，后继，直接后继
//AOV 网络中优先关系必须是传递和反自反的。
//AOV 网络中对图进行top排序，可以确定各顶点间的前驱和后继。也可以确定图有没有环

class AOV
{
public:
    AOV():graph(NULL){}
    void SetGraph(Graph_Adjacency * p){graph=p;}
    void TopSort();        //AOV网络的拓扑排序

    vector<int> * Get_Result() { return &top_result;}

private:
    Graph_Adjacency *graph;    //邻接表表示的图
    vector<int> top_result;
};

/************************************************************************/
/* AOV 网络拓扑排序，去掉依次入度为0的节点和边，并入栈，
如果所有节点都访问过，则结束，或则存在又向环路                          */
/************************************************************************/

void AOV::TopSort()
{
    int n=graph->Get_Vertexs();        //节点数
    head_node *inver=graph->Get_Inverse();        //邻接表
    head_node *adj=graph->Get_Adjacency();        //逆邻接表
    int *count= new int[n];        // 用于记录每个节点的入度    
    stack<int> stack;

    //初始化
    for (int i=0;i<n;i++)
    {
        count[i]=inver[i].count;        
        if (!count[i])
            stack.push(i);        //找出入度为空节点，入栈
    }

    for(i=0;i<n;i++)
    {
        //循环访问n个节点
        if (stack.isEmpty())
        {
            cout<<"error: network has a cycle, topsort terminated"<<endl;
            return;
        }

        int top=stack.Top();
        stack.pop();

        top_result.push_back(top);

        //top入度为0,去掉top相连的边，则top相连的顶点vi 的入度-1 
        for (vertex_node*p=adj[top].link;p;p=p->link)
        {
            int temp=p->vertex;
            count[temp]--;
            //如果count[temp]
            if (!count[temp])
            {
                stack.push(temp);
            }
        }
    }

    //输出
    cout<<"the network top sort list is : ";
    for (vector<int>::const_iterator iter=top_result.begin();iter!=top_result.end();++iter)
    {
        printf("v%d ",*iter);
    }
    cout<<endl;
}

top排序时间复杂度：

O(e+n)

 AOE网络（边活动网络）

图中优先边表示在一个工程中，表示所需要完成的任务或活动，而顶点表示事件，用来表示活动完成，当一个事件完成，就标志着所有该事件的所有活动都已完成。

//边活动网络，图中又向边表示工程所需要完成的任务或活动，顶点表事件，
//当一个事件发生时表示该事件的所有活动都已完成。在工程中，活动是可以同时进行的。只有各自对应的事件发生时，活动才可以进行。
//AOE网络中评价工程执行情况，可确定工程执行的最少时间，和工程中活动关键性的评价
//关键路径：具有最长路径长度的路径
//关键活动，最迟开始时间和最早开始时间的差值，表明活动的关键程度,关键活动既是：early(i)=late(i)

class AOE
{
public:
    AOE();
    void SetGraph(Graph_Adjacency * p){graph=p;}
    void critical_path();        //关键路径，返回关键路径长度
    void critical_activity();    //关键活动
    int Get_Path_Length(int v);    //获取顶点v的路径长度

private:
    Graph_Adjacency *graph;
    int earliest[max_vertexs];        //记录事件最早开始时间
    int latest[max_vertexs];        //记录事件最晚开始时间
    int start,end;            //AOE 网络中开始和结束顶点。
};

 在AOE网络中，有些活动可以并行进行，所以完成整个工程所需时间是从开始顶点到终止节点的最长路径长度。关键路径就是具有最长路径长度的路径。

在AOE网络中，关键路径可能不止一条。

事件vi，最早发生时间，是从v0到vi的最长路径长度，把活动ai的最早开始时间记为early(i)

活动ai最迟开始时间，late[i],在比增加工期前提下，活动ai最迟能够开始的时间。

关键活动：earl[i]==late[i]

计算AOE网络中，所有活动的最早eary[i],最晚late[i] 开始时间。就可以确定哪些活动是关键活动，去掉非关键活动，从开始到结束得到的路径就是关键路径。

/************************************************************************/
/* AOE 网络                                                             */
/************************************************************************/

AOE::AOE()
{
    graph=NULL;
    memset(earliest,0,sizeof(int)*max_vertexs);
    memset(latest,0,sizeof(int)*max_vertexs);
    start=0;
    end=0;

}


//关键活动
void AOE::critical_activity()
{
    /*
    //首先确定每个节点事件的最早开始，最晚开始时间.
    //可以按有向图AOV网路中，top排序序列依次确定顶点的最早开始时间。可以确定，earlist(j)=max(earist(i)+<i,j>持续时间)，i是j的直接前驱
    //这样通过top排序，可以确定earlist(i)在earlist[j]前先算出
    */

    //AOV 确定top排序
    AOV aov;    
    aov.SetGraph(graph);
    aov.TopSort();

    head_node *adj=graph->Get_Adjacency();
    head_node *inv=graph->Get_Inverse();
    int n=graph->Get_Vertexs();

    vertex_node *p=NULL;

    //求earlist
    vector<int> *result=aov.Get_Result();
    for (vector<int>::const_iterator iter=result->begin();iter!=result->end();++iter)
    {
        int v=*iter;
        for (p=adj[v].link;p;p=p->link)
        {
            int w=p->vertex;
            if (earliest[v]+p->weight > earliest[w])
                earliest[w]=earliest[v]+p->weight;
        }
        
    }
    /*
    //求latest
    //latest 求法和earlist相同，不过是从top排序逆序列开始算最迟开始时间,依次算出其前驱的latest
    //latest[i]=min(latest[j]-<i,j>),其中j是i直接后继。
    */

    int critical=earliest[n-1];
    for(int i=0;i<n;i++)
    {
        latest[i]=critical;
    }
    for (vector<int>::reverse_iterator r_iter=result->rbegin();r_iter!=result->rend();++r_iter)
    {
        int v=*r_iter;
        for(p=inv[v].link;p;p=p->link)
        {
            int w=p->vertex;
            if (latest[v]-p->weight<latest[w])
                latest[w]=latest[v]-p->weight;
        }
    }

    //通过vi事件的earlist和latest，事件的最早最迟开始时间
    //求活动的最早和最迟开始时间
    //假设 k=<i,j> 表示一个活动，k最早开始时间eary(k)=earlist[i],最迟开始时间late[k]=latest[j]-<i,j>持续时间

    vector<Edge> critical_set;
    for (i=0;i<n;i++)
    {
        //遍历所有活动即边
        int from=0,to=0;
        for (p=adj[i].link;p;p=p->link)
        {
            from=i,to=p->vertex;
            int activity_degree=activity_degree=latest[to]-p->weight-earliest[from];    //活动程度即活动的最迟开始时间-最早开始时间
            if (activity_degree==0)
            {
                //关键活动
                Edge cri(from,to,p->weight);
                critical_set.push_back(cri);
            }    
        }
    }

    //输出所有关键活动
    cout<<"the critical activity:"<<endl;
    for (vector<Edge>::iterator cri_iter=critical_set.begin();cri_iter!=critical_set.end();++cri_iter)
        cri_iter->print();
    cout<<endl;

}



//关键路径
void AOE::critical_path()
{
    //有关键路径所组成的图G'
    //在G'中找出从开始到结束节点的一条路径，则为关键路径
}