6 获取AOE网的关键路径--来源王英S同学

来源王英S同学

来源王英S同学

来源王英S同学

6 获取AOE网的关键路径

作者: 冯向阳时间限制: 1S章节: 课程设计

问题描述 :

建立一个有向网AOE网，设计并完成一算法Get_CriticalPath()，获取关键路径。该路径仅输出，不须保存。

提示：在AOE网中，

（1）关键活动：开始时间余量为0的活动。即活动的最早开始时间等于它的最迟开始时间。 

（2）根据各个顶点的Ve和Vl值，在求得每条弧s的最早开始时间e[s]和最迟开始时间l[s]后，若某条弧满足条件e[s]=l[s]，该弧所对应的活动即为关键活动。

（3）关键路径：由关键活动所形成的从源点到汇点的每一条路径（注意：关键路径可能有多条）。

参考函数原型：

//获取AOE网各顶点事件的最早发生时间ve和最迟发生时间vl、活动ak的最早开始时间e和最迟开始时间l、一条关键路径

template<class TypeOfVer, class TypeOfEdge>

bool adjlist_graph<TypeOfVer, TypeOfEdge>::Get_CriticalPath(int ve[], int vl[]);

输入说明 :

第一行：图的类型

第二行：结点数

第三行：结点集

第四行：边数

第五行：边集

第六行：权集

输出说明 :

第一行：顶点集

第二行：邻接表

空行

顶点i Ve[i] Vl[i]（列与列之间用格式控制符'\t'分隔）

...

空行

<弧尾,弧头> e[k] l[k]（列与列之间用格式控制符'\t'分隔）

...

空行

<弧尾,弧头>-><弧尾,弧头>...

DN
6
A B C D E F
8
0 1
0 2
1 3
1 4
2 3
2 5
3 5
4 5
3 2 2 3 4 3 2 1

--------------------

A B C D E F
A->2(2)->1(3)
B->4(3)->3(2)
C->5(3)->3(4)
D->5(2)
E->5(1)
F

A    0    0
B    3    4
C    2    2
D    6    6
E    6    7
F    8    8

<A,C>    0    0
<A,B>    0    1
<B,E>    3    4
<B,D>    3    4
<C,F>    2    5
<C,D>    2    2
<D,F>    6    6
<E,F>    6    7

(A,C)->(C,D)->(D,F)

#include <stdio.h>
#include <string.h>
#include <queue>
#include <stack>
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
const int maxn = 10010;
struct node
{
    int v,w;    //记录上一个顶点 （有向边的下一个）顶点，边权
};
int b[10010]={0},c[10010]={0};
char dian[10010];
//拓扑序列，放在栈中，出栈就是逆拓扑排序
stack<int>toporder;
vector<node>G[maxn];   //邻接表存储的图
int n,m,ve[maxn],vl[maxn],indegree[maxn]={0};  //n为顶点数,m为边数
bool 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 <G[u].size(); i++)
        {
            int v = G[u][i].v;
            indegree[v]--;
            if(indegree[v] == 0)
            {
                q.push(v);
            }
            if(ve[u] + G[u][i].w >ve[v])
            {
                ve[v] = ve[u] + G[u][i].w;
            }
        }
    }
    if(toporder.size() == n)
        return true;
    else
        return false;
}
int criticalpath()
{
    memset(ve,0,sizeof(ve));
    if(topologicalsort() == false)
    {
        return -1;
    }
    fill(vl,vl+n,ve[n-1]);    //vl数组初始化，初始值为汇点的ve值
    while(!toporder.empty())       //出栈，逆拓扑排序
    {
        int u = toporder.top();
        toporder.pop();
        for(int i = 0; i <G[u].size(); i++)
        {
            int v = G[u][i].v;
            if(vl[v] - G[u][i].w<vl[u])
            {
                vl[u] = vl[v] - G[u][i].w;
            }
        }
    }
    for(int u=0;u<n;u++)
    {
        cout<<dian[u]<<'\t'<<ve[u]<<'\t'<<vl[u]<<endl;
    }
    cout<<endl;
    //遍历邻接表的所有边，计算活动的最早开始时间e和最迟开始时间l
    for(int u = 0; u <n; u++)
    {
        for(int i = G[u].size()-1; i >=0; i--)
        {
            int v = G[u][i].v,w = G[u][i].w;
            int e = ve[u],l = vl[v] - w;
            cout<<'<'<<dian[u]<<','<<dian[v]<<'>'<<'\t'<<e<<'\t'<<l<<endl;
        }
    }
    cout<<endl;
    int flag1=0,flag2=0;
    for(int u = 0; u <n; u++)
    {
        for(int i = 0; i <G[u].size(); i++)
        {
            int v = G[u][i].v,w = G[u][i].w;
            int e = ve[u],l = vl[v] - w;
            if(e == l)
            {
                flag1++;
            }
        }
    }
    for(int u = 0; u <n; u++)
    {
        for(int i = 0; i <G[u].size(); i++)
        {
            int v = G[u][i].v,w = G[u][i].w;
            int e = ve[u],l = vl[v] - w;
            if(e == l&&flag2<flag1-1)
            {
                  cout<<'('<<dian[u]<<','<<dian[v]<<')'<<"->";
                  flag2++;
            }
            else if(e == l&&flag2==flag1-1)
            {
                cout<<'('<<dian[u]<<','<<dian[v]<<')';
            }
        }
    }
}

int main()
{

    string ss;
    cin>>ss;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>dian[i];
    }
    cin>>m;
    int s,t,weight;
    for(int i = 0; i <m; i++)
    {
        cin>>b[i]>>c[i];
    }
    for(int i=0;i<m;i++)
    {
        cin>>weight;
        node pt;   //用一个临时节点先存数据
        pt.w=weight;
        pt.v=c[i];
        G[b[i]].push_back(pt);   //邻接表
    }
    for(int i = 0; i <n; i++)
    {
           for(int p=0;p<G[i].size();p++)
           {
              indegree[G[i][p].v]++;
           }
    }
    for(int i=0;i<n-1;i++)
    {
        cout<<dian[i]<<' ';
    }
    cout<<dian[n-1]<<endl;
    for(int i=0;i<n;i++)
    {
        if(G[i].size()!=0)
        {
            cout<<dian[i]<<"->";
            for(int p=G[i].size()-1;p>0;p--)
                cout<<G[i][p].v<<'('<<G[i][p].w<<')'<<"->";
            cout<<G[i][0].v<<'('<<G[i][0].w<<')'<<endl;
        }
        else
        {
            cout<<dian[i]<<endl;
        }
    }
    cout<<endl;
    criticalpath();
    return 0;
}