图论之课程表

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

思路

拓扑排序．构建的邻接表的每一个节点存放的是后继节点的集合．
每一步总是输出当前没有前驱（入度为０）的顶点，可以设置一个队列存放所有入度为０的顶点．

算法步骤：

• 首先遍历课程与课程之间的关系列表，构建邻接表，统计所有节点的入度并且存放每一个节点相邻的节点
• 将所有入度为０的节点放入一个队列中
• 只要队列不为空，就从队首取出入度为０的节点，将这个节点输出到结果集中，代表已经上过该课程，并且将这个节点的所有邻接点的入度减１（相当于裁剪了一个边，因为前一个课程已经修完，当前课程不受上一门课程的限制），减１之后判断这个邻接点的入度是否为０，如果为０，将其放到队列中，代表接下来可以直接学习该课程．
• 最后检查结果集合中的顶点个数是否和课程数相同即可．

代码

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)