拓扑排序和关键路径

一、拓扑排序

1、AOV网络

顶点活动网络（Activity On Vertex Network），即一个有向图G，各顶点表示活动，各条边表示活动之间的领先关系。

AOV网络是一个有向无环图。

2、拓扑排序算法

（1）在图中选择一个入度为0 的顶点，并输出之；

（2）从图中删除该顶点极其所有出边，借助栈或队列存储产生的新的入读为0 的顶点；

（3）重复（1）和（2）直至输出所有顶点。

3、代码

public void TopoSort(Graph graph, int[] order) {
System.out.println("初始入度：");
for (int i = 0; i < nodeNum; i++)
System.out.print(inDegree[i] + " ");
System.out.println();

Queue<Node> queue = new LinkedList<>();

for (int i = 0; i < nodeNum; i++) {
if (inDegree[i] == 0) {
// 入度为零的节点入队列
queue.offer(vertex[i]);
}
}

int count = 0, nextPos;
for (int i = 0; i < nodeNum; i++) {
if (!queue.isEmpty()) {
Node node = queue.poll();
order[count++] = node.id;
// 将该节点的所有邻接点的入度减一
while (node.next != null) {
node = node.next;
nextPos = getVertexPos(node.id);
inDegree[nextPos]--;
if (inDegree[nextPos] == 0)
queue.offer(vertex[nextPos]);
}
}
}

System.out.println("拓扑排序：");
for (int i = 0; i < nodeNum; i++) {
System.out.print(order[i] + " ");
}
System.out.println();
}

执行结果

拓扑排序：
0 1 7 4 2 8 3 6 5

二、关键路径

1、AOE网络

顶点表示事件，有向边表示活动，有向边的权值表示活动的所需时间，入边代表活动已完成，出边表示活动刚开始。

2、关键路径

完成工程所需的最短时间，即从开始顶点到完成顶点的最长路径的长度，该最长路径称为关键路径。

3、关键路径算法

（1）求事件可能的最早发生时间earliest[]

earliest(0) = 0

earliest(j) = max{earliest(i) + w(i,j)}

（2）求时间允许的最迟发生时间latest[]

latest(n-1) = earliest(n-1)

latest(i) = min{latest(j) - w(i,j)}

（3）求活动的最早开始时间和最迟发生时间early[]和late[]

early(k) = earlest(i)

late(k) = latest(j) -w(i,j)

当early[k] = late[k]时，对应的ak即为一个关键路径。

4、代码

/**
* 事件可能的最早发生时间
*
* @param g
* @param order
* @param earliest
*/
public void Earliest(Graph g, int[] order, int[] earliest) {
int i, k;
for (i = 0; i < nodeNum; i++) {
earliest[i] = 0;
}
for (i = 0; i < nodeNum; i++) {
k = order[i];
Node node = vertex[getVertexPos(k)].next;
while (node != null) {
if (earliest[node.id] < earliest[k] + node.weight)
earliest[node.id] = earliest[k] + node.weight;
node = node.next;
}
}
}

/**
* 事件允许的最晚发生时间
*
* @param g
* @param order
* @param earliest
* @param latest
*/
public void Latest(Graph g, int[] order, int[] earliest, int[] latest) {
int i, j, k;
for (i = 0; i < nodeNum; i++) {
latest[i] = earliest[nodeNum - 1];
}
for (i = nodeNum - 2; i > -1; i--) {
j = order[i];
Node node = vertex[getVertexPos(j)].next;
while (node != null) {
k = node.id;
if (latest[j] > latest[k] - node.weight)
latest[j] = latest[k] - node.weight;
node = node.next;
}
}
}

public void CriticalPath(Graph graph, int[] earliest, int[] latest) {
int[] early = new int[edgeNum], late = new int[edgeNum];
early[0] = earliest[0];
early[1] = earliest[0];
early[2] = earliest[0];
early[3] = earliest[1];
early[4] = earliest[2];
early[5] = earliest[3];
early[6] = earliest[4];
early[7] = earliest[4];
early[8] = earliest[5];
early[9] = earliest[6];
early[10] = earliest[7];

late[0] = latest[1] - a[0];
late[1] = latest[2] - a[1];
late[2] = latest[3] - a[2];
late[3] = latest[4] - a[3];
late[4] = latest[4] - a[4];
late[5] = latest[5] - a[5];
late[6] = latest[6] - a[6];
late[7] = latest[7] - a[7];
late[8] = latest[7] - a[8];
late[9] = latest[8] - a[9];
late[10] = latest[8] - a[10];

System.out.println("关键路径：");
for (int i = 0; i < edgeNum; i++) {
if (early[i] == late[i]) {
System.out.print("a" + i + " ");
}
}
System.out.println();
}

执行结果

earliest:
0 6 4 5 7 7 16 15 19
latest:
0 6 6 9 7 11 17 15 19
early:
0 0 0 6 4 5 7 7 7 16 15
late:
0 2 4 6 6 9 8 7 11 17 15
关键路径：
a0 a3 a7 a10