拓扑排序及深度优先遍历

使用的算法

1. 深度优先搜索（DFS）
2. 有向无环图

题目描述

实现代码

import java.util.Scanner;

/**
 * 拓扑排序的分步分析
 * 
 * @Description
 * @author ningqian
 * @version
 * @date 2021年6月18日 下午3:14:59
 */
public class Solution12 {
	static int totalTime = 0;

	public static void main(String[] args) {
		// 输入节点的执行时间
		Scanner scan = new Scanner(System.in);
		String string = scan.nextLine();// 3,1,2,5,3,1
		String[] strings = string.split(",");
		// 1. time数组存储节点的执行时间
		int[] time = new int[strings.length];
		for (int i = 0; i < strings.length; i++) {
			time[i] = Integer.valueOf(strings[i]);
		}
		// 输入每个节点的依赖关系
		// 2,3,4;5;5,6;0;6;0
		String string2 = scan.nextLine();
		// string2是每个节点依赖关系的数组
		String[] strings2 = string2.split(";");
		// 利用二维数组存储节点之间的依赖关系
		// 0表示没有依赖，1表示存在依赖关系
		// 按列看表示节点的出度，按行看表示节点的入度
		/**
		 * n1 n2 n3 n4 n5 n6 0 0 0 0 0 0 0 n1 0 0 0 0 0 0 0 n2 0 1 0 0 0 0 0 n3 0 1 0 0
		 * 0 0 0 n4 0 1 0 0 0 0 0 n5 0 0 1 1 0 0 0 n6 0 0 0 1 0 1 0
		 * 
		 */
		int[][] deps = new int[strings2.length + 1][strings2.length + 1];
		// 遍历每一个节点依赖数组
		for (int i = 0; i < strings2.length; i++) {
			// string3是第i个节点的依赖节点数组
			String[] strings3 = strings2[i].split(",");
			for (int j = 0; j < strings3.length; j++) {
				int node = Integer.valueOf(strings3[j]);
				if (node == 0) {
					break;
				}
				deps[node][i + 1] = 1;
			}
		}

		// 找到出度为0的节点
		// 看的是某一列的所有行是否全为0
		for (int i = 1; i < deps.length; i++) {// 列
			boolean outFlag = false;
			for (int j = 1; j < deps.length; j++) {// 行
				if (deps[j][i] == 1) {
					outFlag = true;
					break;//
				}
			}
			if (outFlag == false) {// 出度为0
				// usedFlag数组表示每个节点是否被遍历过，初始化为false
				boolean[] usedFlag = new boolean[time.length];
				System.out.println("出度为0的节点是:" + i);
				doTime(deps, time, i, time[i - 1], usedFlag);
			}
		}

		System.out.println(totalTime);

	}

	/**
	 * 
	 * @Description：深度优先遍历有向无环图
	 * @author ningqian
	 * @date 2021-06-18 下午8:41:20
	 * @param deps     有向无环图的入出度关系矩阵
	 * @param time     每个节点的执行时间
	 * @param endNode  出度为0的节点下标
	 * @param sumTime  出度为0的节点的执行时间
	 * @param usedFlag 长度为节点个数的Boolean数组，初始化为false
	 */
	public static void doTime(int[][] deps, int[] time, int endNode, int sumTime, boolean[] usedFlag) {
		// 找当前节点的入度节点
		// 看的是行
		boolean inFlag = false;
		for (int i = 1; i < deps.length; i++) {
			// 值为1，且该节点没有被使用过
			if (deps[endNode][i] == 1 && usedFlag[i - 1] == false) {
				inFlag = true;
				break;
			}
		}
		if (inFlag == false) {// 没有找到入度的节点，即该节点的入度为0
			// 此时的执行时间为当前路径的执行时间，与原先的时间取最大
			totalTime = Math.max(totalTime, sumTime);
			System.out.println("当前路径的执行时间:" + sumTime);
			return;// 结束该条路径的计算
		}
		// 要重新计算一次的原因是上面的计算前驱节点找到后直接break，但下面这个的操作不能直接break，需要继续循环
		for (int i = 1; i < deps.length; i++) {
			if (deps[endNode][i] == 1 && usedFlag[i - 1] == false) {
				System.out.println(endNode + "的前驱节点为:" + i);
				usedFlag[i - 1] = true;
				doTime(deps, time, i, sumTime + time[i - 1], usedFlag);
				usedFlag[i - 1] = false;// 重新置为false,以便继续使用
			}
		}
	}

}