[LeetCode] (medium) 210. Course Schedule II

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

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

Some courses may have prerequisites, for example to take course 0 you have to first take course 1, which is expressed as a pair: [0,1]

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

There may be multiple correct orders, you just need to return one of them. If it is impossible to finish all courses, return an empty array.

Example 1:

Input: 2, [[1,0]] 
Output: [0,1]
Explanation: There are a total of 2 courses to take. To take course 1 you should have finished   
             course 0. So the correct course order is[0,1].

Example 2:

Input: 4, [[1,0],[2,0],[3,1],[3,2]]
Output: [0,1,2,3] or [0,2,1,3]
Explanation: There are a total of 4 courses to take. To take course 3 you should have finished both     
             courses 1 and 2. Both courses 1 and 2 should be taken after you finished course 0. 
             So one correct course order is[0,1,2,3]. Another correct ordering is[0,2,1,3].

Note:

1. The input prerequisites is a graph represented by a list of edges, not adjacency matrices. Read more about how a graph is represented.
2. You may assume that there are no duplicate edges in the input prerequisites.

---

 和207完全相同，一样没什么难度，看了别人的答案发现原来有不同的理解方式。

从拓扑关系的结构：

图中的边从被依赖的节点指向依赖的节点，从入度为零的节点出发（第一个需要手动寻找），逐层删去入读为零的节点与其相邻边

class Solution {
public:
    vector<int> findOrder(int numCourses, vector<pair<int, int>>& prerequisites) {
        vector<int> result;
        vector<vector<int>> succ(numCourses, vector<int>());
        vector<int> request(numCourses, 0);
        stack<int> S;
        
        for(int i = 0; i < prerequisites.size(); ++i){
            pair<int, int> cur = prerequisites[i];
            succ[cur.second].push_back(cur.first);
            ++request[cur.first];
        }
        
        for(int i = 0; i < numCourses; ++i){
            if(request[i] == 0){
                S.push(i);
                result.push_back(i);
            }
        }
        
        while(!S.empty()){
            int cur = S.top();  S.pop();
            for(int i : succ[cur]){
                --request[i];
                if(request[i] == 0){
                    S.push(i);
                    result.push_back(i);
                }
            }
        }
        if(result.size() == numCourses) return result;
        else return vector<int>();
    }
};

从图的性质出发：

边从依赖的节点指向被依赖的节点（其实这个方法中边的方向并不重要），遍历所有节点以之为起点使用DFS确保图中不存在环。

class Solution {
public:
    bool dfs(int curr, list<int>* adjacency, int *visited, vector<int>& solution){
        visited[curr] = 1;
        for (list<int>::iterator it = adjacency[curr].begin();it!=adjacency[curr].end();it++){
            if (visited[*it] == 1) return false;    //1代表活跃路径，此时发现环
            if (visited[*it] == 0) {                //0代表此节点尚未到达，此时dfs深入
                if (!dfs(*it, adjacency, visited, solution)) return false;
            }
        }
        
        visited[curr]  = 2;    //2代表此节点访问成功
        solution.push_back(curr);    //此时当前节点的所有后继（依赖课程）都已成功访问
        return true;
    }
    
    vector<int> findOrder(int numCourses, vector<pair<int, int>>& prerequisites) {
        int n = numCourses;
        list<int> adjacency[n];
        int visited[n];
        for (int i=0;i<n;i++){
            visited[i] = 0;
        }
        vector<int> solution;
        
        for (int i=0;i<prerequisites.size();i++){
            adjacency[prerequisites[i].first].push_back(prerequisites[i].second);
        }
        
        for (int i=0;i<n;i++){
            if (visited[i] == 0){
                if (!dfs(i, adjacency, visited, solution)){
                    return vector<int>();
                }
            }
        }
        
        return solution;
        
    }
};