关键路径(CriticalPath)算法

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

#define MAXVEX 30        //最大顶点数
#define MAXEDGE 30        //最大边数
#define INFINITY 65535    //∞

//定义全局变量
int *etv, *ltv;//事情最早发生和最迟发生指针数组
int *stack2;//用于存储拓扑排序的栈
int top2;//用于指向stack2栈指针

/*    邻接矩阵结构    */
typedef struct
{
    int vexs[MAXVEX];//顶点下标
    int arc[MAXVEX][MAXVEX];//矩阵(路径)
    int numVertexes, numEdges;//当前图中的顶点数和边数
}MGraph;


/*    邻接表结构    */
typedef struct EdgeNode    //
{//边表结点
    int adjvex;//顶点下标
    int weight;//路径
    struct EdgeNode *next;//指向想一个边表结点
}EdgeNode;

typedef struct VertexNode
{//顶点结点
    int in;//入度
    int data;//顶点信息
    EdgeNode *firstedge;//指向边表头指针
}VertexNode, AdjList[MAXVEX];

typedef struct
{
    AdjList adjList;//顶点向量
    int numVertexes, numEdges;//顶点数和边数
}graphAdjList, *GraphAdjList;



void CreateMGraph(MGraph *G)
{/*    构建图    */
    int i, j;

//    printf("请输入顶点数和边数：\n");
    G->numVertexes = 10;
    G->numEdges = 13;

    //初始化顶点下标
    for(i=0; i<G->numVertexes; i++)
        G->vexs[i] = i;

    //初始化矩阵
    for(i=0; i<G->numVertexes; i++)
        for(j=0; j<G->numVertexes; j++)
            if(i == j)
                G->arc[i][j] = 0;
            else
                G->arc[i][j] = INFINITY;

    //内置输入
    G->arc[0][1] = 3;
    G->arc[0][2] = 4;
    G->arc[1][3] = 5;
    G->arc[1][4] = 6;
    G->arc[2][3] = 8;
    G->arc[2][5] = 7;
    G->arc[3][4] = 3;
    G->arc[4][6] = 9;
    G->arc[4][7] = 4;
    G->arc[5][7] = 6;
    G->arc[6][9] = 2;
    G->arc[7][8] = 5;
    G->arc[8][9] = 3;

    return ;
}



void CreateALGraph(MGraph G, GraphAdjList *GL)
{/*    利用邻接矩阵，构建邻接表    */
    int i, j;
    EdgeNode *e;
    
    *GL = (GraphAdjList)malloc(sizeof(graphAdjList));//*GL代表主函数的GL指向
    (*GL)->numVertexes = G.numVertexes;/*    读取信息    */
    (*GL)->numEdges = G.numEdges;

    //初始化
    for(i=0; i<G.numVertexes; i++)
    {
        (*GL)->adjList[i].in = 0;
        (*GL)->adjList[i].data = G.vexs[i];//读取顶点下标
        (*GL)->adjList[i].firstedge = NULL;
    }

    //构建邻接表
    for(i=0; i<G.numVertexes; i++)
        for(j=0; j<G.numVertexes; j++)
            if(0 != G.arc[i][j]  &&  INFINITY > G.arc[i][j])
            {//若存在路径
                e = (EdgeNode *)malloc(sizeof(EdgeNode));//申请
                e->adjvex = j;//存顶点
                e->weight = G.arc[i][j];//存路径
                e->next = (*GL)->adjList[i].firstedge;//存表头指针
                (*GL)->adjList[i].firstedge = e;//头插
                (*GL)->adjList[j].in ++;//顶点入度+1
            }
    return ;
}



void TopologicalSort(GraphAdjList GL)
{/*    拓扑排序    */
    EdgeNode *e;
    int i, gettop, k;
    int top = 0;//用于指向stack栈顶
    int count = 0;//技术输出
    int *stack;//建栈存储入度位0的顶点
    stack = (int *)malloc(sizeof(int));
    for(i=0; i<GL->numVertexes; i++)//把所有入度位0的顶点如stack栈中
        if(0 == GL->adjList[i].in)
            stack[++top] = i;
    
    etv = (int *)malloc(sizeof(int) * GL->numVertexes);//最早发生etv指针申请空间
    for(i=0; i<GL->numVertexes; i++)//初始化最早发生etv数组
        etv[i] = 0;

    stack2 = (int *)malloc(sizeof(int) * GL->numVertexes);//存储拓扑排序序列
    top2 = 0;//用于指向stack2栈顶
    printf("Topological:\t");
    while(0 != top)
    {//若有顶点入度为0
        gettop = stack[top--];//出栈
        printf("%3d->", GL->adjList[gettop].data);//输出出栈的栈顶的顶点信息
        count ++;//输出记数

        stack2[++top2] = gettop;//出栈元素赋给存储拓扑序列栈
        
        for(e=GL->adjList[gettop].firstedge; e; e=e->next)
        {//出栈的栈顶元素若有邻接点
            k = e->adjvex;//邻接点-顶点下标
            if(! (--GL->adjList[k].in))//邻接点顶点下标-1(gettop已指向)，是否入度位0？
                stack[++top] = k;//是则入stack的栈

            /*出栈的最早发生时间值+出栈邻接表的路径  >  出栈邻接表顶点下标的最早发生时间值
              就是v0-v1-v3和v0-v2-v3都是从起点到达汇点，3哪一个路径较远    */
            if((etv[gettop] + e->weight) > etv[k])
                etv[k] = etv[gettop] + e->weight;
        }
    }
    printf("\n");

    if(count < GL->numVertexes)//若有环，则结束程序
        exit(-1);

    return ;
}



void CriticalPath(GraphAdjList GL)
{/*    关键路径    */
    EdgeNode *e;
    int i, gettop, k, j;
    int ete, lte;//最早发生和最迟发生的变量

    TopologicalSort(GL);//调用拓扑排序函数

    ltv = (int *)malloc(sizeof(int) * GL->numVertexes);//最迟发生指针边表指向申请空间
    for(i=0; i<GL->numVertexes; i++)//初始化最迟发生数组
        ltv[i] = etv[GL->numVertexes - 1];//起到汇最大值

    //输出最早发生数组
    printf("etv:\t\t");
    for(i=0; i<GL->numVertexes; i++)
        printf("%3d->", etv[i]);
    printf("\n");
    
    while(0 != top2)
    {//存放拓扑排序数列
        gettop = stack2[top2--];
        for(e=GL->adjList[gettop].firstedge; e; e=e->next)
        {
            k = e->adjvex;
            if((ltv[k] - e->weight) < ltv[gettop])
                ltv[gettop] = ltv[k] - e->weight;
            /*最晚发生时间值(出stack2(存拓扑排序)栈元素的邻接点顶点下标) - 邻接路径   <    最晚发生数组【出栈元素0】
              用拓扑排序的最长路径 - 邻接路径 < 最晚发生值[出栈元素]*/
        }
    }

    printf("ltv:\t\t");//输出最晚值数组
    for(i=0; i<GL->numVertexes; i++)
        printf("%3d->", ltv[i]);
    printf("\n");

    for(j=0; j<GL->numVertexes; j++)
        for(e=GL->adjList[j].firstedge; e; e=e->next)
        {
            k = e->adjvex;
            ete = etv[j];//最早发生时间
            lte = ltv[k] - e->weight;//最迟发生时间

            if(ete == lte)//相等即在关键路径上
                printf("<v%d - v%d> length : %d \n", GL->adjList[j].data, GL->adjList[k].data, e->weight);
        }

    return ;
}

int main(void)

{    
    MGraph G;
    GraphAdjList GL;
    system("title 关键路径");
    CreateMGraph(&G);
    CreateALGraph(G, &GL);
    CriticalPath(GL);

    return 0;
}