Leetcode: 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?

For example:

2, [[1,0]]

There are a total of 2 courses to take. To take course 1 you should have finished course 0. So it is possible.

2, [[1,0],[0,1]]

There are a total of 2 courses to take. To take course 1 you should have finished course 0, and to take course 0 you should also have finished course 1. So it is impossible.

Note:
The input prerequisites is a graph represented by a list of edges, not adjacency matrices. Read more about how a graph is represented.

直观的是拓扑排序法，topological ordering。找到出度为0的节点，从图中依次删除，并更新相连节点的出度。如果最终所有节点都可以被删除，或者所有节点的出度都为0，那么这个图是无环图，可拓扑排序。

class Solution {
public:
    bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
        if (prerequisites.empty()) {
            return true;
        }
        
        vector<vector<pair<int, int>>> edges(numCourses);
        for (int i = 0; i < prerequisites.size(); ++i) {
            edges[prerequisites[i].first].push_back(prerequisites[i]);
        }
        
        vector<int> outdegrees(numCourses, 0);
        for (int i = 0; i < numCourses; ++i) {
            for (const auto& iter : edges[i]) {
                ++outdegrees[iter.second];
            }
        }
        
        // Find all nodes with zero outdegrees.
        queue<int> zeroOutdegrees;
        for (int i = 0; i < numCourses; ++i) {
            if (outdegrees[i] == 0) {
                zeroOutdegrees.push(i);
            }
        }
        
        // Remove vertex with zero outdegree .
        while (!zeroOutdegrees.empty()) {
            int curNode = zeroOutdegrees.front();
            zeroOutdegrees.pop();
            for (const auto& iter : edges[curNode]) {
                if (--outdegrees[iter.second] == 0) {
                    zeroOutdegrees.push(iter.second);
                }
            }
        }
        
        for (int i = 0; i < numCourses; ++i) {
            if (outdegrees[i] != 0) {
                return false;
            }
        }
        
        return true;
    }
};

也可以DFS遍历图，在这个过程中标记节点是否被访问过。如果DFS过程中发现某个节点已经正在被访问，说明存在环。需要三个状态来标识节点：未访问，正在访问，已访问。

class Solution {
public:
    bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
        if (prerequisites.empty()) {
            return true;
        }
        
        unordered_multimap<int, int> edges;
        for (int i = 0; i < prerequisites.size(); ++i) {
            edges.emplace(prerequisites[i].second, prerequisites[i].first);
        }
        
        bool canFinish = true;
        vector<int> used(numCourses, 0);
        for (auto iter = edges.begin(); iter != edges.end() && canFinish; ++iter) {
            if (used[iter->first] == 0) {
                canFinish = canFinish && visitGraphNode(iter->first, edges, used);
            }
        }
        
        return canFinish;
    }
    
    bool visitGraphNode(int node, const unordered_multimap<int, int>& edges, vector<int>& used) {
        used[node] = 1;
        auto range = edges.equal_range(node);
        for (auto iter = range.first; iter != range.second; ++iter) {
            if (used[iter->second] == 1) {
                return false;
            }
            else if (used[iter->second] == 0) {
                if (!visitGraphNode(iter->second, edges, used)) {
                    return false;
                }
            }
        }
        used[node] = 2;
        return true;
    }
};