207. Course Schedule

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, 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:

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.

click to show more hints.

Hints:

1. This problem is equivalent to finding if a cycle exists in a directed graph. If a cycle exists, no topological ordering exists and therefore it will be impossible to take all courses.
2. Topological Sort via DFS - A great video tutorial (21 minutes) on Coursera explaining the basic concepts of Topological Sort.
3. Topological sort could also be done via BFS.

简要题解：

可以把问题转化为有向图的问题。课程代表图中的结点，课程之间的先后关系用图中的边表示。

为了直观方便，这里[v, u]用从v到u的边表示。（逻辑上，应该用从u到v的边表示，但这里不影响最终判断）

如果可以对图中的结点进行拓扑排序，则说明可以按照要求完成所有课程。

有向图中的结点能进行拓扑排序当且仅当图中没有圈。

而在一个dag中每一个边指向一个更小的post（后访问时刻）值

因此，可以通过一个dfs，然后判断prerequisite pairs中有没有存在边(v, u)使得post[v] < post[u]，如果存在，则返回false；反之，返回true

代码：

class Solution {
private:
    bool* visited;
    int* post;
    int clock;
public:
    void postvisit(int v) {
        post[v] = clock++;
    }

    void explore(int v, vector<pair<int, int>>& prerequisites) {
        visited[v] = true;

        for (int i = 0; i < prerequisites.size(); i++)
            if (prerequisites[i].first == v && !visited[prerequisites[i].second])
                explore(prerequisites[i].second, prerequisites);

        postvisit(v);
    }

    void dfs(int numCourses, vector<pair<int, int>>& prerequisites) {
        if (visited != NULL)
            delete[] visited;
        visited = new bool[numCourses];
        for (int i = 0; i < numCourses; i++)
            visited[i] = false;

        if (post != NULL)
            delete[] post;
        post = new int[numCourses];
        clock = 0;

        for (int i = 0; i < numCourses; i++)
            if (!visited[i])
                explore(i, prerequisites);
    }

    bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
        dfs(numCourses, prerequisites);

        for (int i = 0; i < prerequisites.size(); i++)
            if (post[prerequisites[i].first] < post[prerequisites[i].second])
                return false;

        if (visited != NULL)
            delete[] visited;
        if (post != NULL)
            delete[] post;

        return true;
    }
};