LeetCode刷题实战210：课程表 II-技术圈

算法的重要性，我就不多说了吧，想去大厂，就必须要经过基础知识和业务逻辑面试+算法面试。所以，为了提高大家的算法能力，这个公众号后续每天带大家做一道算法题，题目就从LeetCode上面选！

今天和大家聊的问题叫做 课程表 II，我们先来看题面：

https://leetcode-cn.com/problems/course-schedule-ii/

There are a total of n courses you have to take labelled from 0 to n - 1.

Some courses may have prerequisites, for example, if prerequisites[i] = [ai, bi] this means you must take the course bi before the course ai.

Given the total number of courses numCourses and a list of the prerequisite pairs, return the ordering of courses you should take to finish all courses.

If there are many valid answers, return any of them. If it is impossible to finish all courses, return an empty array.

题意

现在你总共有 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 进行拓扑排序 - 一个关于Coursera的精彩视频教程（21分钟），介绍拓扑排序的基本概念。
拓扑排序也可以通过 BFS 完成。

解题

本题跟 207 题完全一致，只是增加了路径输出。207可以点击看， LeetCode刷题实战207：课程表

广度优先

class Solution {
public:
    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
      unordered_map<int, unordered_set<int>> m;
      vector<int> indegree(numCourses, 0);
      for(auto& pre : prerequisites)
      {
        m[pre[1]].insert(pre[0]);
        indegree[pre[0]]++;
      }
      queue<int> q;
      int tp, finish = 0, i;
      for(i = 0; i < numCourses; ++i)
        if(indegree[i] == 0)
          q.push(i);
      vector<int> ans(numCourses);
      i = 0;
    while(!q.empty())
    {
      tp = q.front();
      finish++;
      ans[i++] = tp;
      q.pop();
      for(auto id : m[tp])
      {
        if(--indegree[id] == 0)
          q.push(id);
      }
    }
    if(i != numCourses)
      return {};
    return ans;
    }
};

深度优先

class Solution {
    unordered_map<int, unordered_set<int>> m;
    vector<int> ans;
public:
    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
        vector<int> indegree(numCourses, 0);
      for(auto& pre : prerequisites)
      {
            m[pre[1]].insert(pre[0]);
            indegree[pre[0]]++;
        }
        bool can = true;
        vector<int> visited(numCourses,0);
      for(int i = 0; i < numCourses; ++i)
        {
            if(indegree[i]==0)//从入度0的开始
                dfs(i, visited, can);
            if(!can)
                return {};
        }
        if(ans.size() < numCourses)//不够个数，说明有的存在环
            return {};
        reverse(ans.begin(),ans.end());//反序
        return ans;
    }

    void dfs(int i, vector<int> & visited, bool &can)
    {
        if(!can) return;
        if(visited[i]==2) return;
        if(visited[i]==1)
        {
            can = false;
            return;
        }
        visited[i] = 1;//进入的时候为1
        for(auto id : m[i])
            dfs(id, visited, can);
        visited[i] = 2;//出去的时候为2
        ans.push_back(i);//出去的时候push进去，（这是最后做的）最终答案反序即可
    }
};