Day24——关键路径

颜妮儿

已于 2022-04-23 23:10:02 修改

阅读量429

点赞数

分类专栏： Java 文章标签： java

于 2022-04-23 23:04:45 首次发布

本文链接：https://blog.csdn.net/Z__XY_/article/details/124372232

版权

Java 专栏收录该内容

42 篇文章 0 订阅

订阅专栏

有向无环图：若一个有向图中不存在环，则称为有向无环图，简称DAG。

AOV网：若用DAG图表示一个工程，其顶点表示活动，用有向边表示活动必须先于活动进行的关系，将这样的有向无环图称为顶点代表活动的网络，记为AOV网。在AOV网中，活动是活动的直接前驱，活动是活动的直接后继，这种前驱和后继关系具有传递性，且任何活动不能以它自己作为自己的前驱和后继。

拓扑排序：在图论中，有一个有向无环图的顶点组成的序列，当且仅当满足：

每个顶点出现且只出现一次。
若顶点在序列中排在顶点的前面，则在图中不存在从顶点到顶点的路径。

对一个AOV网进行拓扑排序的常用方法：

在AOE网中找一个没有前驱的顶点，并加入序列；
删除以该顶点作为起点的所有有向边；
重复以上两个步骤，直到AOV网为空或网中不再存在无前驱的顶点（后面的情况说明这个有向图中存在环）

对应代码

//Step 1.The in-degree of each node.
int[] tempInDegrees=new int[numNodes];
for(int i=0;i<numNodes;i++) {
    for(int j=0;j<numNodes;j++) {
        if(weightMatrix.getValue(i, j)!=-1) {
            tempInDegrees[j]++;
        }//Of if
    }//Of for j
}//Of for i

//Step 2. Topology sorting.
for(int i=0;i<numNodes;i++) {
    if(tempInDegrees[i]==0) {
        System.out.println("Removing "+i);

        for(int j=0;j<numNodes;j++) {
            if(weightMatrix.getValue(i, j)!=-1) {
                tempInDegrees[j]--;
            }
        }
    }
}

逆拓扑排序：顾名思义，是拓扑排序的逆序列，可以通过拓扑排序获得，也可以与求拓扑排序相同，只是每次输出的是出度为0的点。

AOE网：在带权有向图中，以顶点表示时间，以有向边表示活动，以边上的权值表示完成该活动的开销，称为用边表示的网络，是一个有向无环图。在AOE网中仅有一个入度为0的顶点，称为源点，它表示整个工程的开始；网络中也仅存在一个出度为0的顶点，称为汇点，它表示整个工程的结束。

关键路径：在AOE网中从源点到汇点的路径可能有多条，并且路径长度不同。完成路径上的活动所花的开销虽然不同，但是只有所有路径上的活动都已完成，整个工程才能算结束。因此，从源点到汇点的所有路径中，具有最大路径长度的路径被称为关键路径，而把关键路径上的活动称为关键活动。关键路径表示完成整个工程的最短时间。
求每个活动的最早开始时间： $v e []$ （初始值设为0）

1、通过遍历找出所有顶点的入度，并用inDegree[]记录；

2、在所有顶点中找到入度为0的顶点 $v_i$ ，然后遍历该结点所指向的所有顶点 $v_j$ ，并更新指向顶点的 $v e [j] = m a x (v e [j], v e [i] + w e i g h t (i, j))$ ，最后inDegree[j]–；
3、重复步骤2直到遍历所有入度为0的顶点；
代码：

int tempValue;

		// Step 1.The in-degree of each node.
		int[] tempInDegrees = new int[numNodes];
		for (int i = 0; i < numNodes; i++) {
			for (int j = 0; j < numNodes; j++) {
				if (weightMatrix.getValue(i, j) != -1) {
					tempInDegrees[j]++;
				} // Of if
			} // Of for j
		} // Of for i

		System.out.println("In-degree of nodes: " + Arrays.toString(tempInDegrees));

		// Step 2. Topology sorting.
		int[] tempEarliestTimeArray = new int[numNodes];
		for (int i = 0; i < numNodes; i++) {
			if (tempInDegrees[i] > 0) {
				continue;
			} // Of if

			System.out.println("Removing " + i);

			for (int j = 0; j < numNodes; j++) {
				if (weightMatrix.getValue(i, j) != -1) {
					tempInDegrees[j]--;

					tempValue = tempEarliestTimeArray[i] + weightMatrix.getValue(i, j);
					if (tempEarliestTimeArray[j] < tempValue) {
						tempEarliestTimeArray[j] = tempValue;
					} // Of if
				} // Of if
			} // Of for j

		} // Of for i

		System.out.println("Earlest start time: " + Arrays.toString(tempEarliestTimeArray));

求每个活动最迟开始时间：vl[]（初始值设为汇点的最早开始时间）

1、通过遍历找出所有顶点的出度，并用outDegree[]记录；
2、在所有顶点中找到出度为0的顶点i，然后遍历该结点所指向的所有顶点j，并更新指向顶点的 $v l [j] = m i n (v l [j], v l [i] - w e i g h t (j, i))$ ，最后outDegree[j]–；
3、重复步骤2直到遍历所有出度为0的顶点；
代码和求最早开始时间大同小异。
完整代码：

/**
	 * 
	 *********************
	 * @Title: criticalPath
	 * @Description: TODO( Critical path. Net validity checks such as loop check not
	 *               implemented.The source should be 0 and the destination should
	 *               be n-1.)
	 *
	 * @return The node sequence of the path.
	 *********************
	 *
	 */
	public boolean[] criticalPath() {

		int tempValue;

		// Step 1.The in-degree of each node.
		int[] tempInDegrees = new int[numNodes];
		for (int i = 0; i < numNodes; i++) {
			for (int j = 0; j < numNodes; j++) {
				if (weightMatrix.getValue(i, j) != -1) {
					tempInDegrees[j]++;
				} // Of if
			} // Of for j
		} // Of for i

		System.out.println("In-degree of nodes: " + Arrays.toString(tempInDegrees));

		// Step 2. Topology sorting.
		int[] tempEarliestTimeArray = new int[numNodes];
		for (int i = 0; i < numNodes; i++) {
			if (tempInDegrees[i] > 0) {
				continue;
			} // Of if

			System.out.println("Removing " + i);

			for (int j = 0; j < numNodes; j++) {
				if (weightMatrix.getValue(i, j) != -1) {
					tempInDegrees[j]--;

					tempValue = tempEarliestTimeArray[i] + weightMatrix.getValue(i, j);
					if (tempEarliestTimeArray[j] < tempValue) {
						tempEarliestTimeArray[j] = tempValue;
					} // Of if
				} // Of if
			} // Of for j

		} // Of for i

		System.out.println("Earlest start time: " + Arrays.toString(tempEarliestTimeArray));

		// Step 3. The out-degree of each node.
		int[] tempOutDegrees = new int[numNodes];
		for (int i = 0; i < numNodes; i++) {
			for (int j = 0; j < numNodes; j++) {
				if (weightMatrix.getValue(i, j) != -1) {
					tempOutDegrees[i]++;
				} // Of if
			} // Of for j
		} // Of for i

		System.out.println("Out-degree of nodes: " + Arrays.toString(tempOutDegrees));

		// Step 4. Reverse topology sorting.
		int[] tempLatestTimeArray = new int[numNodes];
		for (int i = 0; i < numNodes; i++) {
			tempLatestTimeArray[i] = tempEarliestTimeArray[numNodes - 1];
		} // Of for i

		for (int i = numNodes - 1; i >= 0; i--) {
			if (tempOutDegrees[i] > 0) {
				continue;
			} // Of if
			System.out.println("Removing " + i);

			for (int j = 0; j < numNodes; j++) {
				if (weightMatrix.getValue(j, i) != -1) {
					tempOutDegrees[j]--;

					tempValue = tempLatestTimeArray[i] - weightMatrix.getValue(j, i);
					if (tempLatestTimeArray[j] > tempValue) {
						tempLatestTimeArray[j] = tempValue;
					} // Of if
				} // Of if
			} // Of for j

		} // Of for i

		System.out.println("Latest start time: " + Arrays.toString(tempLatestTimeArray));

		boolean[] resultCriticalArray = new boolean[numNodes];
		for (int i = 0; i < numNodes; i++) {
			if (tempEarliestTimeArray[i] == tempLatestTimeArray[i]) {
				resultCriticalArray[i] = true;
			} // Of if
		} // Of for i

		System.out.println("Critical array: " + Arrays.toString(resultCriticalArray));
		System.out.print("Critical nodes: ");
		for (int i = 0; i < numNodes; i++) {
			if (resultCriticalArray[i]) {
				System.out.print(" " + i);
			} // Of if
		} // Of for i
		System.out.println();

		return resultCriticalArray;

	}// Of criticalPath

	/**
	 *********************
	 * The entrance of the program.
	 * 
	 * @param args Not used now.
	 *********************
	 */
	public static void main(String args[]) {
		Net tempNet0 = new Net(3);
		System.out.println(tempNet0);

		int[][] tempMatrix1 = { { 0, 9, 3, 6 }, { 5, 0, 2, 4 }, { 3, 2, 0, 1 }, { 2, 8, 7, 0 } };
		Net tempNet1 = new Net(tempMatrix1);
		System.out.println(tempNet1);

		// Dijkstra
		tempNet1.dijkstra(1);

		// An undirected net is required.
		int[][] tempMatrix2 = { { 0, 7, MAX_DISTANCE, 5, MAX_DISTANCE }, { 7, 0, 8, 9, 7 },
				{ MAX_DISTANCE, 8, 0, MAX_DISTANCE, 5 }, { 5, 9, MAX_DISTANCE, 0, 15 }, { MAX_DISTANCE, 7, 5, 15, 0 } };
		Net tempNet2 = new Net(tempMatrix2);
		tempNet2.prim();

		// A directed net without loop is required.
		// Node cannot reach itself.It is indicated by -1.
		int[][] tempMatrix3 = { { -1, 3, 2, -1, -1, -1 }, { -1, -1, -1, 2, 3, -1 }, { -1, -1, -1, 4, -1, 3 },
				{ -1, -1, -1, -1, -1, 2 }, { -1, -1, -1, -1, -1, 1 }, { -1, -1, -1, -1, -1, -1 } };
		Net tempNet3 = new Net(tempMatrix3);
		System.out.println("--------critical path");
		tempNet3.criticalPath();

	}// Of main