LeetCode 207. 课程表
你这个学期必须选修 numCourse 门课程,记为 0 到 numCourse-1 。
在选修某些课程之前需要一些先修课程。 例如,想要学习课程 0 ,你需要先完成课程 1 ,我们用一个匹配来表示他们:[0,1]
给定课程总量以及它们的先决条件,请你判断是否可能完成所有课程的学习?
示例 1:
输入: 2, [[1,0]]
输出: true
解释: 总共有 2 门课程。学习课程 1 之前,你需要完成课程 0。所以这是可能的。
示例 2:
输入: 2, [[1,0],[0,1]]
输出: false
解释: 总共有 2 门课程。学习课程 1 之前,你需要先完成课程 0;并且学习课程 0 之前,你还应先完成课程 1。这是不可能的。
提示:
输入的先210. 课程表 II决条件是由 边缘列表 表示的图形,而不是 邻接矩阵 。详情请参见图的表示法。
你可以假定输入的先决条件中没有重复的边。
1 <= numCourses <= 10^5
思路
拓扑排序.构建的邻接表的每一个节点存放的是后继节点的集合.
每一步总是输出当前没有前驱(入度为0)的顶点,可以设置一个队列存放所有入度为0的顶点.
算法步骤:
- 首先遍历课程与课程之间的关系列表,构建邻接表,统计所有节点的入度并且存放每一个节点相邻的节点
- 将所有入度为0的节点放入一个队列中
- 只要队列不为空,就从队首取出入度为0的节点,将这个节点输出到结果集中,代表已经上过该课程,并且将这个节点的所有邻接点的入度减1(相当于裁剪了一个边,因为前一个课程已经修完,当前课程不受上一门课程的限制),减1之后判断这个邻接点的入度是否为0,如果为0,将其放到队列中,代表接下来可以直接学习该课程.
- 最后检查结果集合中的顶点个数是否和课程数相同即可.
代码
class Solution:daima
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
n = numCourses
in_degree = [0 for _ in range(n)] # 入度数组,初始化全为0
neibor = [set() for _ in range(n)] # 邻接表
# 想要学习课程0,你需要先完成课程1,用[0, 1]表示,1在前,0在后
# 注意邻接表存放的是后继节点的集合
for second, first in prerequisites:
in_degree[second] += 1
neibor[first].add(second)
queue = [] # 存放所有入度为0的节点
for i in range(n):
if in_degree[i] == 0:
queue.append(i)
count = 0 # 记录已修的课程数目
while queue:
top = queue.pop(0)
count += 1
for nex in neibor[top]:
in_degree[nex] -= 1
if in_degree[nex] == 0:
queue.append(nex)
return count == n
LeetCode 210. 课程表 II
现在你总共有 n 门课需要选,记为 0 到 n-1。
在选修某些课程之前需要一些先修课程。 例如,想要学习课程 0 ,你需要先完成课程 1 ,我们用一个匹配来表示他们: [0,1]
给定课程总量以及它们的先决条件,返回你为了学完所有课程所安排的学习顺序。
可能会有多个正确的顺序,你只要返回一种就可以了。如果不可能完成所有课程,返回一个空数组。
示例 1:
输入: 2, [[1,0]]
输出: [0,1]
解释: 总共有 2 门课程。要学习课程 1,你需要先完成课程 0。因此,正确的课程顺序为 [0,1] 。
示例 2:
输入: 4, [[1,0],[2,0],[3,1],[3,2]]
输出: [0,1,2,3] or [0,2,1,3]
解释: 总共有 4 门课程。要学习课程 3,你应该先完成课程 1 和课程 2。并且课程 1 和课程 2 都应该排在课程 0 之后。
因此,一个正确的课程顺序是 [0,1,2,3] 。另一个正确的排序是 [0,2,1,3] 。
说明:
输入的先决条件是由边缘列表表示的图形,而不是邻接矩阵。详情请参见图的表示法。
你可以假定输入的先决条件中没有重复的边。
提示:
这个问题相当于查找一个循环是否存在于有向图中。如果存在循环,则不存在拓扑排序,因此不可能选取所有课程进行学习。
通过 DFS 进行拓扑排序 ,拓扑排序也可以通过 BFS 完成。
思路
和第一题基本上一样,只需要把上的课的序号存储下来就可以了,增加一行代码就可以
注意结果判断以下是不是可以修完所有课程,如果可以,返回课程结果,不可以就返回空数组
代码
class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
n = numCourses
in_degree = [0 for _ in range(n)] # 入度数组,初始化全为0
neibor = [set() for _ in range(n)] # 邻接表
# 想要学习课程0,你需要先完成课程1,用[0, 1]表示,1在前,0在后
# 注意邻接表存放的是后继节点的集合
for second, first in prerequisites:
in_degree[second] += 1
neibor[first].add(second)
res = [] # 存放上过课程的序号
queue = [] # 存放所有入度为0的节点
for i in range(n):
if in_degree[i] == 0:
queue.append(i)
count = 0 # 记录已修的课程数目
while queue:
top = queue.pop(0)
res.append(top) # 把该课程放到结果集中,代表上过
count += 1
for nex in neibor[top]:
in_degree[nex] -= 1
if in_degree[nex] == 0:
queue.append(nex)
return res if count == n else [] # 先判断是否可以上完所有课程
LeetCode 630. 课程表 III
这里有 n 门不同的在线课程,他们按从 1 到 n 编号。每一门课程有一定的持续上课时间(课程时间)t 以及关闭时间第 d 天。一门课要持续学习 t 天直到第 d 天时要完成,你将会从第 1 天开始。
给出 n 个在线课程用 (t, d) 对表示。你的任务是找出最多可以修几门课。
示例:
输入: [[100, 200], [200, 1300], [1000, 1250], [2000, 3200]]
输出: 3
解释:
这里一共有 4 门课程, 但是你最多可以修 3 门:
首先, 修第一门课时, 它要耗费 100 天,你会在第 100 天完成, 在第 101 天准备下门课。
第二, 修第三门课时, 它会耗费 1000 天,所以你将在第 1100 天的时候完成它, 以及在第 1101 天开始准备下门课程。
第三, 修第二门课时, 它会耗时 200 天,所以你将会在第 1300 天时完成它。
第四门课现在不能修,因为你将会在第 3300 天完成它,这已经超出了关闭日期。
提示:
整数 1 <= d, t, n <= 10,000 。
你不能同时修两门课程。
思路
利用贪心思想,使用大顶堆.
算法步骤:
- 首先按照结束时间对课程进行排序
- 使用一个大顶堆来存储已经选择的课程的长度
- 一旦发现安排了当前课程之后,其结束时间超过了最晚时间,那么就从已经安排的课程中,取消掉一门最耗时的课程.
代码
class Solution:
def scheduleCourse(self, courses: List[List[int]]) -> int:
# 按照结束时间对课程进行排序
courses = sorted(courses, key=lambda x: x[1])
day = 0 # 记录课程结束时间
heap = [] # 存储选择的课程的长度
for course in courses: # 遍历所有课程
day += course[0] # 更新课程结束时间
heapq.heappush(heap, -course[0]) # 存储课程长度,注意此处的负号,python只有小顶堆,添加负号变为大顶堆
if day > course[1]: # 如果超过了最晚时间,则弹出最耗时的那个课程
day += heapq.heappop(heap) # 因为堆中存储的是时长的负数,所以此处是加,相当于减
return len(heap)