6)图[4]关键路径

关键路径求解

 

#include "iostream"
#include "vector"
#include "stack"
using namespace std;

const int MaxNumVertex  = 20; //最大顶点数
const int infinity = 65535;//无穷大
typedef int elementtype;       //elementtype 为int 型
class graph{
public:
    graph();
    ~graph();
    elementtype insertvertex(elementtype v); //在图中增加一个顶点
    elementtype insertedge(elementtype v,elementtype u,elementtype weight);//在图中增加一条从v顶点到u顶点的弧
    elementtype firstadj(elementtype v);//求图g中顶点v的第一个邻接点
    elementtype nextadj(elementtype v,elementtype m);//求图中顶点v的m邻接点之后的邻接点
    elementtype firstpre(elementtype v);//求图中顶点v的第一个前驱
    elementtype nextpre(elementtype v,elementtype m);//求图中顶点v的m前驱点之后的前驱点
    elementtype degreein(elementtype v);//求图中顶点v的入度数
    elementtype FindDegreein(elementtype ind[]);//各顶点的入度存放于入度数组中
    elementtype degreeout(elementtype v);//求图中顶点v的入度数
    elementtype FindDegreeout(elementtype oud[]);//各顶点的入度存放于入度数组中
    elementtype EW(elementtype E[]);//最早发生时间的求解
    bool CriticalPath();//关键路径
    elementtype create();//创建图
    int  CurrentVertex;//当前顶点数

private:
    elementtype vertex[MaxNumVertex];//顶点表
    elementtype edge[MaxNumVertex][MaxNumVertex];//图中弧的类型
    
};

/*
*初始化
*/
graph::graph()
{
    CurrentVertex = 0; 
    int i,j;
    for (i=MaxNumVertex-1;i>=1;i--)
    {
        for (j=MaxNumVertex-1;j>=1;j--)
        {
            edge[i][j] = 0;

        }
    }
    
}

/*
*在图中增加一个顶点
*/
elementtype graph::insertvertex(elementtype v)
{
    //判断这个顶点是否已经存在
    int i;
    bool flags = true;
    for(i=1; i<=CurrentVertex; i++)
    {
        if(vertex[i]==v)
        {
            flags = false;
            break;
        }
    }
    
    if(flags)
    {
        CurrentVertex++;
        vertex[CurrentVertex] = v;
    }else{
        cout<<v<<"顶点已经存在!"<<endl;
    }
    return 0;
}

/*
*在图中增加一条从v顶点到u顶点的弧
*/
elementtype graph::insertedge(elementtype v,elementtype u,elementtype weight)
{
    if(edge[v][u]!=0)
    {
        cout<<v<<"->"<<u<<"这条弧弧已经存在!"<<endl;
    }else{
        edge[v][u] = weight;
    }
    return 0;
}


/*
*求图中顶点v的第一个邻接点
*/
elementtype graph::firstadj(elementtype v)
{
    int u,i;
    bool flags = true;//用于判断是否存在邻接点
    for(i=1;i<=CurrentVertex;i++)
    {
        if(edge[v][i]!=0){
            u = i;
            flags = false;
            break;
        }
    }
    if(flags) u = 0;//邻接点不存在
    return u;
}

/*
*求图中顶点v的m邻接点以后的邻接点
*/
elementtype graph::nextadj(elementtype v,elementtype m)
{
    int i,u;
    bool flags = true;
    for(i=m+1;i<=CurrentVertex;i++)
    {
        if(edge[v][i]!=0)
        {
            u = i;
            flags = false;
            break;
        }
    }
    if(flags) u = 0;//邻接点不存在
    return u;
}

/*
*求图中顶点v的第一个前驱
*/
elementtype graph::firstpre(elementtype v)
{
    int u,i;
    bool flags = true;//用于判断是否存在邻接点
    for(i=1;i<=CurrentVertex;i++)
    {
        if(edge[i][v]!=0){
            u = i;
            flags = false;
            break;
        }
    }
    if(flags) u = 0;//前驱点不存在
    return u;
}

/*
*求图中顶点v的m前驱点之后的前驱点
*/
elementtype graph::nextpre(elementtype v,elementtype m)
{
    int i,u;
    bool flags = true;
    for(i=m+1;i<=CurrentVertex;i++)
    {
        if(edge[i][v]!=0)
        {
            u = i;
            flags = false;
            break;
        }
    }
    if(flags) u = 0;//前驱点不存在
    return u;
}
/*
*求图中顶点v的入度数
*/
elementtype graph::degreein(elementtype v)
{
    int i,num = 0;
    for (i=1;i<=CurrentVertex;i++)
    {
        if(edge[i][v]!=0)num++;
    }
    return num;
}

/*
*每个顶点的入度
*/
elementtype graph::FindDegreein(elementtype ind[])
{
    int i;
    for(i=1;i<=CurrentVertex;i++)
    {
        ind[i] = degreein(i);
    }
    return 0;
}

/*
*求图中顶点v的出度数
*/
elementtype graph::degreeout(elementtype v)
{
    int i,num = 0;
    for (i=1;i<=CurrentVertex;i++)
    {
        if(edge[v][i]!=0)num++;
    }
    return num;
}

/*
*每个顶点的出度
*/
elementtype graph::FindDegreeout(elementtype outd[])
{
    int i;
    for(i=1;i<=CurrentVertex;i++)
    {
        outd[i] = degreeout(i);
    }
    return 0;
}


/*
*最早发生时间的求解
*/
elementtype graph::EW(elementtype E[])
{
    int i,x,w,v;
    stack<int> s;//定义并初始索要用到的栈
    elementtype ind[MaxNumVertex];//求各顶点的入度存放于入度数组ind中
    FindDegreein(ind);//

    for(i=1;i<=CurrentVertex;i++)//各个结点最早发生时间的初始化
    {
        E[i] = -1;
    }

    
    for(i=1;i<=CurrentVertex;i++)//将入度为0的顶点入栈
    {
        if(ind[i]==0)
        {
            s.push(i);
            v = i;
            E[i] = 0;//第一个入度为0的结点的最早发生时间为0
        }
    }
    int count =0;//用于统计已经完成的结点数目
    while(!s.empty())
    {
        x = s.top();
        count++;//计数
        s.pop();
        w = firstadj(x);//开始对v的各个后继顶点的入度-1
        while(w!=0)
        {
            if(E[w]<(E[x]+edge[x][w]))
            {
                E[w] = E[x]+edge[x][w];//更新w的最早发生时间
            }
            if(!(--ind[w]))//若w的入度-1后为0，则入栈
            {
                s.push(w);
            }
            w = nextadj(x,w);
        }
    }
    if(count<CurrentVertex)return false;//产生有回路的标志
    else return true;
    return 0;
}

/*
*关键路径
*/
bool graph::CriticalPath()
{
    int i,x,w,v;
    stack<int> s;//定义并初始索要用到的栈
    elementtype ind[MaxNumVertex];//求各顶点的入度存放于入度数组ind中
    elementtype outd[MaxNumVertex];//求各顶点的出度存放于出度数组outd中
    elementtype E[MaxNumVertex];
    elementtype L[MaxNumVertex];
    FindDegreein(ind);//求各个结点的入度
    FindDegreeout(outd);//求各个结点的出度
    EW(E);//求各个结点的最早发生时间
    
    for(i=1;i<=CurrentVertex;i++)
    {
        L[i] = infinity;//各个结点最迟发生时间的初始化
    }
    for(i=1;i<=CurrentVertex;i++)//将出度为0的顶点入栈
    {
        if(outd[i]==0)
        {
            s.push(i);
            v = i;
            L[i] = E[i];//第一个出度为0的结点的最迟发生时间
        }
    }
    int count =0;//用于统计已经完成的结点数目
    while(!s.empty())
    {
        x = s.top();
        count++;//计数
        s.pop();
        w = firstpre(x);//开始对v的各个前驱顶点的出度-1
        while(w!=0)
        {
            if(L[w]>(L[x]-edge[w][x]))
            {
                L[w] = L[x]-edge[w][x];//更新w结点的最迟发生时间
            }
            if(!(--outd[w]))//若w的出度-1后为0，则入栈
            {
                s.push(w);
            }
            w = nextpre(x,w);
        }

    }

    cout<<"E[i],L[i]:"<<endl;
    for(i=1;i<=CurrentVertex;i++)//输出各个节点的最早发生时间和最迟发生时间
    {
        cout<<"E["<<i<<"]="<<E[i]<<",L["<<i<<"]="<<L[i]<<endl;
    }
    cout<<endl;

    vector<int>equal;//记录E[I]=L[I]
    for(i=1;i<=CurrentVertex;i++)
    {
        if(E[i]==L[i])
        {
            equal.push_back(i);
        }
    }

    int start,end;
    for(i=1;i<=CurrentVertex;i++)//寻找起始结点
    {
        if(ind[i]==0)
        {
            start = i;
            break;
        }
    }
    FindDegreeout(outd);//求各个结点的出度
    for(i=CurrentVertex;i>=1;i--)//寻找终止结点
    {
        if(outd[i]==0)
        {
            end = i;
            break;
        }
    }

    cout<<"CriticalPath is:";
    while(start!=end)
    {
        for(i=0;i<equal.size();i++)//输出关键路径
        {
            if(edge[start][equal[i]]!=0)
            {
                cout<<start<<"->";
                start = equal[i];
                if(start==end)
                {
                    cout<<start<<endl;
                }
                break;
            }
        }
    }
    return 0;
}

/*
*创建图
*/
elementtype graph::create()
{
    int i,numv,v,u,weight;
    cout<<"please create graph"<<endl;
    cout<<"input numvertex(顶点数):";
    cin>>numv;
    cout<<"input vertex(顶点):";
    for(i=1;i<=numv;i++)
    {
        cin>>v;
        insertvertex(v);
    }
    cout<<"input num(u,v,weight)(弧的数目):";
    cin>>numv;
    for(i=1;i<=numv;i++)
    {
        cout<<"u->v,weight:";
        cin>>u>>v>>weight;
        insertedge(u,v,weight);
    }
    cout<<"graph create finish！"<<endl<<endl;
    return 0;
}
graph::~graph()
{
}

int main()
{
    graph g;
    g.create();
    g.CriticalPath();
    return 0;
}

原始AOV网：

每个节点的最早发生时间[圆框对应的内容]和最迟发生时间[方框对应的内容]：

程序运行结果: