難度 medium
現在你總共有 n 門課需要選，記為 0 到 n-1。

在選修某些課程之前需要一些先修課程。 例如，想要學習課程 0 ，你需要先完成課程 1 ，我們用一個匹配來表示他們: [0,1]

給定課程總量以及它們的先決條件，返回你為了學完所有課程所安排的學習順序。

可能會有多個正確的順序，你只要返回一種就可以了。如果不可能完成所有課程，返回一個空陣列。

示例 1:

輸入: 2, [[1,0]]
輸出: [0,1]
解釋: 總共有 2 門課程。要學習課程 1，你需要先完成課程 0。因此，正確的課程順序為 [0,1] 。
示例 2:

輸入: 4, [[1,0],[2,0],[3,1],[3,2]]
輸出: [0,1,2,3] or [0,2,1,3]
解釋: 總共有 4 門課程。要學習課程 3，你應該先完成課程 1 和課程 2。並且課程 1 和課程 2 都應該排在課程 0 之後。
因此，一個正確的課程順序是 [0,1,2,3] 。另一個正確的排序是 [0,2,1,3] 。
說明:

輸入的先決條件是由邊緣列表表示的圖形，而不是鄰接矩陣。詳情請參見圖的表示法。
你可以假定輸入的先決條件中沒有重複的邊。
提示:

這個問題相當於查詢一個迴圈是否存在於有向圖中。如果存在迴圈，則不存在拓撲排序，因此不可能選取所有課程進行學習。
通過 DFS 進行拓撲排序 - 一個關於Coursera的精彩視訊教程（21分鐘），介紹拓撲排序的基本概念。
拓撲排序也可以通過 BFS 完成。

解題思路：這道題的思路還是相對比較直接的，首先用一個graph記錄從先修課到後修課的連結，同時把後修課用一個vector儲存起來，接下來，開始遍歷後修課陣列容器in，如果容器裡面有一個數的值為0，說明這一門課沒有先修課，把這門課作為第一門課，用佇列儲存起來，然後開始從佇列進行搜尋，把當前課記錄到res中，從graph中找到以當前這門課為先修課的所有後修課，然後後修課陣列對應的該課的數值減一，如果某個後修課對應的數值變為0，那麼說明這門課的所有先修課都已經修過了，那把這個後修課再放到q中，對它繼續進行搜尋就可以了。
程式碼

class Solution {
    public int[] findOrder(int numCourses, int[][] prerequisites) {
        int[] need = new int[numCourses];
        HashMap<Integer, List<Integer>> map = new HashMap<>(numCourses);
        for(int i=0; i<prerequisites.length; i++){
            List<Integer> list = map.getOrDefault(prerequisites[i][1], new ArrayList<>());
            list.add(prerequisites[i][0]);
            map.put(prerequisites[i][1], list);
            need[prerequisites[i][0]]++;
        }
        Queue<Integer> q = new LinkedList<>();
        for(int i=0; i<need.length; i++){
            if(need[i]==0) q.add(i);
        }
        List<Integer> res = new ArrayList<>();
        while(!q.isEmpty()){
            int t = q.poll();
            res.add(t);
            List<Integer> integers = map.get(t);
            if(integers!=null){
                for (Integer integer : integers) {
                    need[integer]--;
                    if(need[integer]==0) q.add(integer);
                }
            }
        }
        if(res.size()!=numCourses) res.clear();
        int[] newRes = new int[res.size()];
        for(int i=0; i<res.size(); i++) newRes[i] = res.get(i);
        return newRes;
    }
}
 

程式碼t65 s39 cpp

class Solution {
public:
    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
        vector<int> res;
        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<in.size(); i++){
            if(in[i]==0) q.push(i);
        }
        while(!q.empty()){
            int t = q.front();
            res.push_back(t);
            q.pop();
            for(auto &x : graph[t]){
                in[x]--;
                if(in[x]==0) q.push(x);
            }
        }
        if(res.size()!=numCourses) res.clear();
        return res;
    }
};

參考資料：