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.

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. There are several ways to represent a graph. For example, the input prerequisites is a graph represented by a list of edges. Is this graph representation appropriate?
3. Topological Sort via DFS - A great video tutorial (21 minutes) on Coursera explaining the basic concepts of Topological Sort.
4. Topological sort could also be done via BFS.

這道課程清單的問題對於我們學生來說應該不陌生，因為我們在選課的時候經常會遇到想選某一門課程，發現選它之前必須先上了哪些課程，這道題給了很多提示，第一條就告訴我們了這道題的本質就是在有向圖中檢測環。 LeetCode中關於圖的題很少，有向圖的僅此一道，還有一道關於無向圖的題是 Clone Graph 無向圖的複製。個人認為圖這種資料結構相比於樹啊，連結串列啊什麼的要更為複雜一些，尤其是有向圖，很麻煩。第二條提示是在講如何來表示一個有向圖，可以用邊來表示，邊是由兩個端點組成的，用兩個點來表示邊。第三第四條提示揭示了此題有兩種解法，DFS和BFS都可以解此題。我們先來看BFS的解法，我們定義二維陣列graph來表示這個有向圖，一位陣列in來表示每個頂點的入度。我們開始先根據輸入來建立這個有向圖，並將入度陣列也初始化好。然後我們定義一個queue變數，將所有入度為0的點放入佇列中，然後開始遍歷佇列，從graph裡遍歷其連線的點，每到達一個新節點，將其入度減一，如果此時該點入度為0，則放入佇列末尾。直到遍歷完佇列中所有的值，若此時還有節點的入度不為0，則說明環存在，返回false，反之則返回true。程式碼如下：

解法一：

class Solution {
public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        vector<vector<int> > graph(numCourses, vector<int>(0));
        vector<int> in(numCourses, 0);
        for (auto a : prerequisites) {
            graph[a[1]].push_back(a[0]);
            ++in[a[0]];
        }
        queue<int> q;
        for (int i = 0; i < numCourses; ++i) {
            if (in[i] == 0) q.push(i);
        }
        while (!q.empty()) {
            int t = q.front();
            q.pop();
            for (auto a : graph[t]) {
                --in[a];
                if (in[a] == 0) q.push(a);
            }
        }
        for (int i = 0; i < numCourses; ++i) {
            if (in[i] != 0) return false;
        }
        return true;
    }
};

下面我們來看DFS的解法，也需要建立有向圖，還是用二維陣列來建立，和BFS不同的是，我們像現在需要一個一維陣列visit來記錄訪問狀態，這裡有三種狀態，0表示還未訪問過，1表示已經訪問了，-1表示有衝突。大體思路是，先建立好有向圖，然後從第一個門課開始，找其可構成哪門課，暫時將當前課程標記為已訪問，然後對新得到的課程呼叫DFS遞迴，直到出現新的課程已經訪問過了，則返回false，沒有衝突的話返回true，然後把標記為已訪問的課程改為未訪問。程式碼如下：

解法二：

class Solution {
public:
    bool canFinish(int numCourses, vector<vector<int> >& prerequisites) {
        vector<vector<int> > graph(numCourses, vector<int>(0));
        vector<int> visit(numCourses, 0);
        for (auto a : prerequisites) {
            graph[a[1]].push_back(a[0]);
        }
        for (int i = 0; i < numCourses; ++i) {
            if (!canFinishDFS(graph, visit, i)) return false;
        }
        return true;
    }
    bool canFinishDFS(vector<vector<int> > &graph, vector<int> &visit, int i) {
        if (visit[i] == -1) return false;
        if (visit[i] == 1) return true;
        visit[i] = -1;
        for (auto a : graph[i]) {
            if (!canFinishDFS(graph, visit, a)) return false;
        }
        visit[i] = 1;
        return true;
    }
};

類似題目：

參考資料：