LeetCode 0207 -- 課程表

課程表

題目描述

現在你總共有n門課需要選，記爲0到n-1。

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

給定課程總量以及它們的先決條件，判斷是否可能完成所有課程的學習？

示例 1：

輸入: 2, [[1,0]] 
輸出: true
解釋: 總共有 2 門課程。學習課程 1 之前，你需要完成課程 0。所以這是可能的。

示例 2：

輸入: 2, [[1,0],[0,1]]
輸出: false
解釋: 總共有 2 門課程。學習課程 1 之前，你需要先完成​課程 0；並且學習課程 0 之前，你還應先完成課程 1。這是不可能的。

說明：

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

提示：

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

解題思路

個人AC

class Solution {
    private boolean cycle = false;

    public boolean canFinish(int numCourses, int[][] prerequisites) {
        if (numCourses <= 0) return false;
        if (prerequisites.length == 0) return true;
        
        boolean[] marked = new boolean[numCourses];
        boolean[] onStack = new boolean[numCourses];
        HashMap<Integer, List<Integer>> adj = new HashMap<>();
        for (int v = 0; v < numCourses; v++) {
            adj.put(v, new LinkedList<>());
        }
        for (int i = 0; i < prerequisites.length; i++) {
            adj.get(prerequisites[i][0]).add(prerequisites[i][1]);
        }

        for (int v = 0; v < numCourses; v++) {
            if (!marked[v]) hasCycle(v, adj, marked, onStack);
        }
        return !this.cycle;
    }

    private void hasCycle(int v, HashMap<Integer, List<Integer>> adj, boolean[] marked, boolean[] onStack) {
        onStack[v] = true;
        marked[v] = true;
        for (int w : adj.get(v)) {
            if (this.cycle) {
                return;
            } else if (!marked[w]) {
                hasCycle(w, adj, marked, onStack);
            } else if (onStack[w]) {
                cycle = true;
            }
        }
        onStack[v] = false;
    }
}

時間複雜度： $O(V + E)$；

空間複雜度： $O(V)$。

class Solution {

    public boolean canFinish(int numCourses, int[][] prerequisites) {
        if (numCourses <= 0) return false;
        int pLen = prerequisites.length;
        if (pLen == 0) return true;

        // 默認爲0，表示未被訪問；1表示正在訪問中；2表示已經訪問完了
        int[] marked = new int[numCourses];
        // 鄰接表
        HashSet<Integer>[] adj = new HashSet[numCourses];
        for (int v = 0; v < numCourses; v++) {
            adj[v] = new HashSet<>();
        }
        for (int i = 0; i < prerequisites.length; i++) {
            adj[prerequisites[i][0]].add(prerequisites[i][1]);
        }

        for (int v = 0; v < numCourses; v++) {
            if (hasCycle(v, adj, marked)) {
                return false;
            }
        }

        return true;
    }

    private boolean hasCycle(int v, HashSet<Integer>[] adj, int[] marked) {
        if (marked[v] == 1) {
            // 當前結點正在當前訪問鏈中被訪問，說明有環
            return true;
        }
        if (marked[v] == 2) {
            // 當前訪問鏈中沒有遇到環，該節點在其他訪問鏈中已經被訪問過了
            return false;
        }
        // 將當前結點標明爲正在訪問中
        marked[v] = 1;
        for (int w : adj[v]) {
            if (hasCycle(w, adj, marked)) {
                return true;
            }
        }
        // 訪問鏈走完，未發現環
        marked[v] = 2;
        return false;
    }
}

時間複雜度： $O(V + E)$；

空間複雜度： $O(V)$。

最優解

同上。