数据结构与算法-拓扑排序&&关键路径

拓扑排序

对一个有向无环图G进行拓扑排序，是将G中所有顶点排成一个线性序列，使得图中任意一对顶点u和v，若边∈E(G)，则u在线性序列中出现在v之前。通常，这样的线性序列称为满足拓扑次序的序列，简称拓扑序列。简单的说，由某个集合上的一个偏序得到集合上的一个全序，这个操作称之为拓扑排序。
在一个表示工程的有向图中，用顶点表示活动，用弧表示活动之间的优先关系，这样有向图为顶点表示活动的网，我们称为AOV网。

算法思路

• 从AOV网中选择⼀个入度为0的顶点输出
• 然后删去此顶点,并删除以此顶点为尾的弧.
• 继续重复此步骤,直到输出全部顶点或AOV网中不存在入度为0的顶点为⽌.

代码实现

typedef int Status;

typedef struct MGraph {
    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;

Status TopologicalSort(GraphAdjList GL) {
    int *stack = malloc(sizeof(int) * GL->numVertexes);
    int top = 0;
    for (int i = 0; i < GL->numVertexes; i++) {
        if (GL->adjList[i].in == 0) {
            stack[++top] = i;
        }
    }
    
    EdgeNode *e;
    int getTop, k;
    int count = 0;
    while (top != 0) {
        getTop = stack[top--];
        printf("%d -> ", GL->adjList[getTop].data);
        count++;
        
        for (e = GL->adjList[getTop].firstedge; e; e = e->next) {
            k = e->adjvex;
            if (--GL->adjList[k].in == 0) {
                stack[++top] = k;
            }
        }
    }
    
    if (count < GL->numVertexes) {
        return ERROR;
    }
    
    return OK;
}

关键路径

在一个表示工程的带权有向图中，用顶点表示事件，用有向边表示活动，用边上的权值表示活动的持续时间，这种有向图的边表表示活动的网,我们称之为AOE 网(Activity On Edge Network)
没有入边的顶点称为始点或源点；
没有出边的顶点称为终点或汇点；
由于一个⼯程，总有一个开始，一个结束。所以正常情况下，AOE⽹网只有一个源点和一个汇点。

• 路径上各个活动所持续的时间之和称为路径长度
• 从源点到汇点具有最大的路径叫关键路径
• 在关键路径上的活动叫关键活动

核心参数

• 事件最早发生的时间etv(earliest time of vertex): 即顶点Vk的最早发生时间；
• 事件最晚发生时间ltv(latest time fo vertex):即顶点Vk的最晚发生时间，也就是每个顶点对应的事件最晚需要开始的时间，超出此时间将会延误整个工期；
• 活动的最早开工时间ete(earliest time of edge): 即弧Ak的最早发生时间；
• 活动的最晚开工时间lte(latest time of edge): 即弧Ak的最晚发生时间，也就是不推迟工期的最晚开工时间；

代码实现

int *etv, *ltv; // 事件最早发生时间和最迟发生时间数组，全局变量
int *stack2;    // 用于存储拓扑序列的栈
int top2;       // 用于stack2的指针

Status TopologicalSort(GraphAdjList GL) {
    int *stack = malloc(sizeof(int) * GL->numVertexes);
    int top = 0;
    for (int i = 0; i < GL->numVertexes; i++) {
        if (GL->adjList[i].in == 0) {
            stack[++top] = i;
        }
    }
    
    top2 = 0;
    stack2 = malloc(sizeof(int) * GL->numVertexes);
    etv = malloc(sizeof(int) * GL->numVertexes);
    for (int i = 0; i < GL->numVertexes; i++) {
        etv[i] = 0;
    }
    
    EdgeNode *e;
    int getTop, k;
    int count = 0;
    while (top != 0) {
        getTop = stack[top--];
        printf("%d -> ", 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 == 0) {
                stack[++top] = k;
            }
            
            if (etv[getTop] + e->weight > etv[k]) {
                etv[k] = etv[getTop] + e->weight;
            }
        }
    }
    
    if (count < GL->numVertexes) {
        return ERROR;
    }
    
    return OK;
}

void CriticalPath(GraphAdjList GL) {
    int i, k, getTop;
    EdgeNode *e;
    
    TopologicalSort(GL);
    
    ltv = malloc(sizeof(int) * GL->numVertexes);
    for(i = 0; i < GL->numVertexes; i++) {
        ltv[i] = etv[GL->numVertexes - 1];
    }
    
    while (top2 != 0) {
        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;
            }
        }
    }
    
    int ete,lte;
    for (int 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("<%d-%d> length:%d\n", GL->adjList[j].data, GL->adjList[k].data, e->weight);
            }
        }
    }
}