LeetCode 2050 并行课程3
1 题目
原题链接。
2 想法
题目本质上是一条拓扑排序的题,只不过,在拓扑排序的基础上,加上了一个时间的限制。每门课程规定了需要一定的时间完成,也就是说,完成一门课程的时间,需要根据先修课程确定。
拓扑排序可以使用广搜配合入度数组去处理,而计算某一门课程的时间,需要根据先修时间确定。可以肯定的是,如果一门课程没有先修课程,那么修这门课程的时间,就是time
数组中的时间。
而如果一门课程有先修课程,容易想到,需要根据最大的一门先修课程时间去确定,比如课程3
的先修课程是课程1
和课程2
,假设:
课程1
需要花费的单位时间为3
课程2
需要花费的单位时间为5
那么,课程3
需要花费的时间就是max(课程1,课程2)+课程3的时间
,也就是取课程1
和课程2
最大值再加上修课程3
的时间。
这样,可以推测,如果一门课程n+1
有n门
先修课程,那么修课程n+1
的时间,就是这修n门
课程的最大值,再加上修课程n+1
的时间。这实际上就是一个简单的动态规划:
dp[n+1] = max(dp[0]..dp[n])+time[n+1]
3 实现
代码有很详细的注释:
import java.util.*;
public class Solution {
public int minimumTime(int n, int[][] relations, int[] time) {
// 时间dp,注意存储的是dp[1]..dp[n]
int[] dp = new int[n + 1];
// 存储入度,为了方便计算同样开了n+1
int[] inDegree = new int[n + 1];
// 邻接表
List<List<Integer>> list = new ArrayList<>();
for (int i = 0; i <= n; i++) {
list.add(new ArrayList<>());
}
// 通过邻接表建图
for (int[] r : relations) {
// 更新入度
++inDegree[r[1]];
list.get(r[0]).add(r[1]);
}
// 广搜队列
LinkedList<Integer> queue = new LinkedList<>();
for (int i = 1; i <= n; i++) {
// 如果入度为0
if (inDegree[i] == 0) {
// 可以直接设置dp[i]的值,因为入度为0代表课程i没有先修课程
dp[i] = time[i - 1];
// 加入广搜队列
queue.addLast(i);
}
}
// 广搜队列不为空
while (!queue.isEmpty()) {
// 获取当前队列大小
int size = queue.size();
// 遍历当前队列中入度为0的课程
for (int i = 0; i < size; i++) {
// 出队
int front = queue.pollFirst();
// 获取先修课程指向的是哪些课程
for (int v : list.get(front)) {
// 课程v的时间是dp[v]与先修课程front+修课程v的最大值
dp[v] = Math.max(dp[v], dp[front] + time[v - 1]);
// 将课程v的入度减1,表示已经完成一门课程
if (--inDegree[v] == 0) {
// 如果入度为0,也就是先修课程全部完成,将其入队
queue.addLast(v);
}
}
}
}
// 取最大值,不能直接dp[n],因为最后修的课程不一定是课程n,所以需要遍历一次,取所有dp的最大值
int res = 0;
for (int v : dp) {
res = Math.max(v, res);
}
return res;
}
}
时间与内存如下:
4 优化
4.1 队列优化
对于带队列的题目,一个常见的优化技巧是使用数组去模拟队列。
需要注意的是,这需要根据题目去确定,虽然队列中存储的是点,但是实际上存储的是边,因为每遍历到一个点就将对应的出边(的点)加入到队列中。观察题目边的范围:
直接取这个范围的队列即可,不会OOM
:
int[] queue = new int[(int) Math.min(n * (n + 1L) / 2, 5L * 10_000)];
注意由于n
取值可能比较大,导致n^2
可能会爆int
,所以需要做一下强制转换。
然后用两个变量代表队头和队尾:
int queueFront = 0;
int queueTail = 0;
// 入队
queue[queueTail++] = i;
// 出队
i = queue[queueFront++];
完整代码(逻辑与上面一样,只是修改了队列部分):
import java.util.*;
public class Solution {
public int minimumTime(int n, int[][] relations, int[] time) {
int[] dp = new int[n + 1];
int[] inDegree = new int[n + 1];
List<List<Integer>> list = new ArrayList<>();
for (int i = 0; i <= n; i++) {
list.add(new ArrayList<>());
}
for (int[] r : relations) {
++inDegree[r[1]];
list.get(r[0]).add(r[1]);
}
int[] queue = new int[(int) Math.min(n * (n + 1L) / 2, 5L * 10_000)];
int queueFront = 0;
int queueTail = 0;
for (int i = 1; i <= n; i++) {
if (inDegree[i] == 0) {
dp[i] = time[i - 1];
// 入队
queue[queueTail++] = i;
}
}
// 判断队列是否为空
while (queueFront < queueTail) {
// 获取队列大小
int size = queueTail - queueFront;
for (int i = 0; i < size; i++) {
// 出队
int front = queue[queueFront++];
for (int v : list.get(front)) {
dp[v] = Math.max(dp[v], dp[front] + time[v - 1]);
if (--inDegree[v] == 0) {
// 入队
queue[queueTail++] = v;
}
}
}
}
int res = 0;
for (int v : dp) {
res = Math.max(v, res);
}
return res;
}
}
时间:
有一点点的优化,但是不多。
4.2 算法细节优化
末尾可以看到有一处计算最大值的地方:
int res = 0;
for (int v : dp) {
res = Math.max(v, res);
}
为什么需要再次遍历dp
计算最大值呢?
因为不知道哪一个dp
最大,但是,可以在每一次dp
计算结束的时候,计算res
:
import java.util.*;
public class Solution {
public int minimumTime(int n, int[][] relations, int[] time) {
int[] dp = new int[n + 1];
int[] inDegree = new int[n + 1];
List<List<Integer>> list = new ArrayList<>();
for (int i = 0; i <= n; i++) {
list.add(new ArrayList<>());
}
for (int[] r : relations) {
++inDegree[r[1]];
list.get(r[0]).add(r[1]);
}
int[] queue = new int[(int) Math.min(n * (n + 1L) / 2, 5L * 10_000)];
int queueFront = 0;
int queueTail = 0;
int res = 0;
for (int i = 1; i <= n; i++) {
if (inDegree[i] == 0) {
// 计算最大值
res = Math.max(res, time[i - 1]);
dp[i] = time[i - 1];
queue[queueTail++] = i;
}
}
while (queueFront < queueTail) {
int size = queueTail - queueFront;
for (int i = 0; i < size; i++) {
int front = queue[queueFront++];
// dp[front]已经确定是计算完毕了,用dp[front]计算最大值
res = Math.max(res, dp[front]);
for (int v : list.get(front)) {
dp[v] = Math.max(dp[v], dp[front] + time[v - 1]);
if (--inDegree[v] == 0) {
queue[queueTail++] = v;
}
}
}
}
return res;
}
}
时间:
貌似没影响,再继续优化一下。
4.3 建图优化
没错,就是使用链式前向星代替邻接表进行建图优化。
链式前向星介绍可以参考此处,不细说了。
最终代码:
import java.util.*;
public class Solution {
public int minimumTime(int n, int[][] relations, int[] time) {
int[] dp = new int[n + 1];
int[] inDegree = new int[n + 1];
int[] last = new int[n + 1];
int edgeCount = relations.length;
int[] pre = new int[edgeCount + 1];
// 初始化last为-1
Arrays.fill(last, -1);
for (int i = 0; i < edgeCount; i++) {
int v0 = relations[i][0];
int v1 = relations[i][1];
++inDegree[v1];
// 建图
pre[i] = last[v0];
last[v0] = i;
}
int[] queue = new int[(int) Math.min(n * (n + 1L) / 2, 5L * 10_000)];
int queueFront = 0;
int queueTail = 0;
int res = 0;
for (int i = 1; i <= n; i++) {
if (inDegree[i] == 0) {
res = Math.max(res, time[i - 1]);
dp[i] = time[i - 1];
queue[queueTail++] = i;
}
}
while (queueFront < queueTail) {
int size = queueTail - queueFront;
for (int i = 0; i < size; i++) {
int front = queue[queueFront++];
res = Math.max(res, dp[front]);
// 遍历所有边
for (int lastEdge = last[front]; lastEdge != -1; lastEdge = pre[lastEdge]) {
int v = relations[lastEdge][1];
dp[v] = Math.max(dp[v], dp[front] + time[v - 1]);
if (--inDegree[v] == 0) {
queue[queueTail++] = v;
}
}
}
}
return res;
}
}
时间:
至此优化完成。
5 总结
题目以拓扑排序为基础,再其中加入了计算时间的动态规划。
实现时,拓扑排序可以广搜+队列实现,计算时间的dp
是比较简单的一维dp
,转移方程也比较好推。
写代码时有些细节要注意:
- 数组分配
n+1
而不是n
- 由于一开始的算法不完善导致了计算完成
dp
后还需要再遍历一次dp
取最大值
优化主要依靠链式前向星的时间优化,队列优化以及算法细节优化效果并不明显。