leecode 207&210 课程表

leecode 207 课程表

你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。

在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则 必须 先学习课程 bi 。

例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。
请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。

示例 1：

输入：numCourses = 2, prerequisites = [[1,0]]
输出：true
解释：总共有 2 门课程。学习课程 1之前，你需要完成课程 0 。这是可能的。

示例 2：

输入：numCourses = 2, prerequisites = [[1,0],[0,1]]
输出：false
解释：总共有 2门课程。学习课程 1 之前，你需要先完成​课程 0 ；并且学习课程 0 之前，你还应先完成课程 1 。这是不可能的。

深度优先算法/回溯

深度优先算法是最先进入脑海的解决方法
即不停地溯源，寻找课程的预学课
如果预学课还需要预学课
就继续查看预学课的预学课
如果存在矛盾关系直接返回False
如果不存在返回原课程查看
基础的回溯算法

class Solution:
    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
        from collections import defaultdict
        pre_dict = defaultdict(set) #记录课程的所有预学课
        for p,q in prerequisites:
            pre_dict[p].add(q)
        learn_flag = [0 for _ in range(numCourses)] #1-已经学过 0-初始状态 -1-visited

        def prelearn(course):
            if learn_flag[course] > 0:return True
            for p in pre_dict[course]:
                if learn_flag[course] < 0: # 访问锁定的课程说明存在矛盾
                    return False
                learn_flag[course] = -1 # 已经访问过的课程需要锁定
                if not prelearn(p):
                    return False
                learn_flag[course] = 1 #解除锁定
            return True

        for c in range(numCourses):
            if c not in pre_dict.keys():# 不需要预学课的课程可以直接学习
                learn_flag[c] = 1
                continue
            if not prelearn(c): return False # 判断能否学习该课程
            
        return True

广度优先算法/拓扑排序

思路：每次删除一个入度边个数为 0 的点，并刷新其他点的出度边个数。
最后验证删除的点是不是所有的点。

class Solution:
    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
        from collections import defaultdict
        degree = [0 for _ in range(numCourses)] #初始化入度边数
        pre_dict = defaultdict(set) #记录课程是哪些课的预选课
        for p,q in prerequisites:
            pre_dict[q].add(p)
            degree[p] += 1
        
        count = 0
        queue = deque() #入度边数=0的集合
        for c in range(numCourses):
            if degree[c] == 0:
                queue.append(c)
                count += 1
      
        while(queue):
            top = queue.popleft()
            for c in pre_dict[top]:
                degree[c] -= 1
                if degree[c] == 0:
                    queue.append(c)
                    count += 1

        return (count == numCourses)

leecode 210 课程表II

唯一的不同是返回的值

返回你为了学完所有课程所安排的学习顺序。可能会有多个正确的顺序，你只要返回 任意一种 就可以了。如果不可能完成所有课程，返回 一个空数组 。

只需要修改输出的部分就好了
该问题深度优先算法不是很使用
用广度优先算法比较方便

广度优先算法/拓扑排序

class Solution:
    def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
        from collections import defaultdict
        res = []
        degree = [0 for _ in range(numCourses)] #初始化入度边数
        pre_dict = defaultdict(set) #记录课程是哪些课的预选课
        for p,q in prerequisites:
            pre_dict[q].add(p)
            degree[p] += 1
        
        count = 0
        queue = deque() #入度边数=0的集合
        for c in range(numCourses):
            if degree[c] == 0:
                queue.append(c)
                count += 1
      
        while(queue):
            top = queue.popleft()
            res.append(top)
            for c in pre_dict[top]:
                degree[c] -= 1
                if degree[c] == 0:
                    queue.append(c)
                    count += 1

        if count == numCourses:
            return res
        else:
            return []

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/course-schedule