LintCode-615: Course Schedule and Course Schedule II 拓扑排序经典题

615. Course Schedule

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, is it possible for you to finish all courses?

Example
Example 1:

Input: n = 2, prerequisites = [[1,0]]
Output: true
Example 2:

Input: n = 2, prerequisites = [[1,0],[0,1]]
Output: false

这题是一道拓扑排序的经典题。我用的是BFS。
思路跟前面贴的拓扑排序一样，最后当result.size()不等于numCourses时就返回false(也就是有环)，否则返回true。
代码如下：

class Solution {
public:
    /*
     * @param numCourses: a total of n courses
     * @param prerequisites: a list of prerequisite pairs
     * @return: true if can finish all courses or false
     */
     
    struct ClassNode {
        int indegree;
        vector<int> neighbors;
        ClassNode(int x=0) : indegree(x) {}
    };
    
    bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
        vector<ClassNode> courses(numCourses);
        vector<int> result;
        queue<int> q;
        for (int i=0; i<prerequisites.size(); ++i) {
            courses[prerequisites[i].first].indegree++;
            courses[prerequisites[i].second].neighbors.push_back(prerequisites[i].first);
        }
    
        for (int i=0; i<numCourses; ++i) {
            if (courses[i].indegree==0) {
                q.push(i);
                result.push_back(i);
            }
        }
        while(!q.empty()) {
            int c=q.front();
            q.pop();
            for (auto j : courses[c].neighbors) {
                courses[j].indegree--;
                if (courses[j].indegree==0) {
                    q.push(j);
                    result.push_back(j);
                }
            }
        }
        if (result.size()==numCourses) return true;
        else return false;
    }
};

[LintCode] 616 Course Schedule II
Description
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
Given n = 2, prerequisites = [[1,0]]
Return [0,1]

Given n = 4, prerequisites = [1,0],[2,0],[3,1],[3,2]]
Return [0,1,2,3] or [0,2,1,3]

Course Schedule II 要求输出符合条件的课程列表，则最后的if else 输出应改为：

        if (result.size()==numCourses) 
            return result;
        else {
            vector<int> temp;
            return  temp;
       }

即result.size()不为n时即不存在解。

二刷：

class Solution {
public:
    /*
     * @param numCourses: a total of n courses
     * @param prerequisites: a list of prerequisite pairs
     * @return: the course order
     */
    vector<int> findOrder(int numCourses, vector<pair<int, int>> &prerequisites) {
        int n = prerequisites.size();
        vector<int> result;
        
        if (n == 0) {
            for (int i = 0; i < numCourses; ++i) result.push_back(i);
            return result;
        }
        
        vector<int> degrees(numCourses); //this course depends on how many courses
        map<int, multiset<int>> edges; //course, dependencies on this course

        for (int i = 0; i < n; ++i) {
            degrees[prerequisites[i].first]++;
            edges[prerequisites[i].second].insert(prerequisites[i].first);
        }
        
        queue<int> q;
        for (int i = 0; i < numCourses; ++i) {
            if (degrees[i] == 0) q.push(i);
        }
        
        if (q.empty()) return {};
        
        while(!q.empty()) {
            int curCourse = q.front();
            q.pop();
            result.push_back(curCourse);
            
            for (auto dep : edges[curCourse]) {
                degrees[dep]--;
                if (degrees[dep] == 0) {
                    q.push(dep);
                }
            }
        }
        
        if (result.size() == numCourses) return result;
        return {};
        
    }
};

代码同步在：
https://github.com/luqian2017/Algorithm

三刷：注意visited数组没用。不需要。

class Solution {
public:
    /**
     * @param numCourses: a total of n courses
     * @param prerequisites: a list of prerequisite pairs
     * @return: the course order
     */
    vector<int> findOrder(int numCourses, vector<vector<int>> &prerequisites) {
        int rowSize = prerequisites.size();
       
        vector<int> res;
        queue<int> q;
        vector<vector<int>> followers(numCourses, vector<int>());
        vector<int> followings(numCourses, 0);
//        vector<bool> visited(numCourses, false);

        for (int i = 0; i < rowSize; i++) {
            int first = prerequisites[i][1];
            int second = prerequisites[i][0];
            followers[first].push_back(second);
            followings[second]++;
        }

        for (int i = 0; i < numCourses; i++) {
            if (followings[i] == 0) {
                q.push(i);
     //           visited[i] = false;
            }
        }

        while (!q.empty()) {
            int frontCourse = q.front();
            q.pop();
            res.push_back(frontCourse);
            for (auto followCourse : followers[frontCourse]) {
  //              if (visited[followCourse]) continue;
                followings[followCourse]--;
                if (followings[followCourse] == 0) {
                    q.push(followCourse);
                }
            }
        }

        return res;
    }
};

四刷：

class Solution {
public:
    /**
     * @param numCourses: a total of n courses
     * @param prerequisites: a list of prerequisite pairs
     * @return: the course order
     */
    vector<int> findOrder(int numCourses, vector<vector<int>> &prerequisites) {
        int n = prerequisites.size();
        //if (n == 0) return {};
        vector<int> res;
        vector<set<int>> edges(numCourses, set<int>()); //不是n
        vector<set<int>> depends(numCourses, set<int>()); //不是n
        for (int i = 0; i < n; i++) { //不是i<n
            edges[prerequisites[i][1]].insert(prerequisites[i][0]);
            depends[prerequisites[i][0]].insert(prerequisites[i][1]);
        }
        queue<int> q;
        for (int i = 0; i < numCourses; i++) {
            if (depends[i].size() == 0) {
                q.push(i);
            }
        }
        while (!q.empty()) {
            int frontNode = q.front();
            q.pop();
            res.push_back(frontNode);
            if (!edges[frontNode].empty()) {
                for (auto edge : edges[frontNode]) {
                    depends[edge].erase(frontNode);
                    if (depends[edge].size() == 0) {
                        q.push(edge);
                    }
                }
            }
        }
        if (res.size() < numCourses) return {};
        return res;
    }
};