207. Course Schedule I & II

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.

From: http://www.programcreek.com/2014/05/leetcode-course-schedule-java/

分析：

建立有向图，利用Toplogical sort逐一去掉没有father的节点。如果最后总的节点大于没有父节点的个数，表面里面有环。

public boolean canFinish(int numCourses, int[][] prerequisites) {
        if (prerequisites == null) return true;
        Map<Integer, Node> map = new HashMap<Integer, Node>();
        
        for (int[] row : prerequisites) {
            if (!map.containsKey(row[0])) {
                map.put(row[0], new Node(row[0], 0));
            }
            
            if (!map.containsKey(row[1])) {
                map.put(row[1], new Node(row[1], 0));
            }
            
            map.get(row[0]).inDegree++;
            map.get(row[1]).list.add(map.get(row[0]));
        }
        
        Queue<Node> queue = new LinkedList<Node>();
        for (Node node : map.values()) {
            if (node.inDegree == 0) {
                queue.offer(node);
            }
        }
        
        while (!queue.isEmpty()) {
            Node node = queue.poll();
            for (Node child : node.list) {
                child.inDegree--;
                if (child.inDegree == 0) {
                    queue.offer(child);
                }
            }
        }
        for (Node node : map.values()) {
            if (node.inDegree != 0) {
                return false;
            }
        }
        return true;
        
    }
}

class Node {
    int value;
    int inDegree;
    List<Node> list;

    public Node(int value, int inDegree) {
        this.value = value;
        this.inDegree = inDegree;
        list = new ArrayList<Node>();
    }
}

还有一种方法就是用dfs来看是否有back edge.

class Solution {
public static boolean hasCycle(List<List<Integer>> graph) {
        // null input checks, etc
        
        int numNodes = graph.size();
        boolean[] visited = new boolean[numNodes];
        boolean[] current = new boolean[numNodes];

        for (int i = 0; i < numNodes; ++i) {
            if (!visited[i]) {
                boolean foundCycle = dfs(graph, visited, current, i);
                if (foundCycle) {
                    return true;
                }
            }
        }
    
        return false;
    }
    
    private static boolean dfs(List<List<Integer>> graph, boolean[] visited, boolean[] current, int pos) {
        if (current[pos]) {
            return true;
        }
        if (visited[pos]) {
            return false;
        }
        visited[pos] = true;
        current[pos] = true;
    
        List<Integer> adj = graph.get(pos);
        for (int dest : adj) {
            boolean res = dfs(graph, visited, current, dest);
            if (res) {
                return true;
            }
        }
    
        current[pos] = false;
        return false;
    }
}

Python version

from collections import defaultdict

class Solution:
    def buildAdjacencyMap(self, edgesList):
        adjMap = defaultdict(list)
        for c1, c2 in edgesList:
            adjMap[c2].append(c1)
        return adjMap

    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
        adjMap = self.buildAdjacencyMap(prerequisites)
        state = [0] * numCourses

        def hasCycle(v):
            if state[v] == 1:
                return False
            if state[v] == -1:
                return True
            state[v] = -1

            for neighbor in adjMap[v]:
                if hasCycle(neighbor):
                    return True
            state[v] = 1
            return False

        for v in range(numCourses):
            if hasCycle(v):
                return False
        return True

from collections import deque, defaultdict
from typing import List

class Solution:
    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
        adj = defaultdict(list)
        indegree = [0] * numCourses

        # Build graph and indegree array
        for course, pre in prerequisites:
            adj[pre].append(course)
            indegree[course] += 1

        # Start with nodes having indegree 0
        queue = deque()
        for i in range(numCourses):
            if indegree[i] == 0:
                queue.append(i)

        finished = 0

        # BFS
        while queue:
            node = queue.popleft()
            finished += 1

            for neighbor in adj[node]:
                indegree[neighbor] -= 1
                if indegree[neighbor] == 0:
                    queue.append(neighbor)

        return finished == numCourses

Course Schedule II

找出选课的顺序。

public class Solution {
    public int[] findOrder(int n, int[][] prerequisites) {
        if (prerequisites == null) return new int[0];
        Map<Integer, Node> map = new HashMap<Integer, Node>();
        // very important
        for (int i = 0; i < n; i++){
            map.put(i, new Node(i, 0));
        }
        
        
        for (int[] row : prerequisites) {
            map.get(row[0]).inDegree++;
            map.get(row[1]).list.add(map.get(row[0]));
        }
        
        List<Integer> list = new ArrayList<Integer>();
        
        Queue<Node> queue = new LinkedList<Node>();
        for (Node node : map.values()) {
            if (node.inDegree == 0) {
                queue.offer(node);
            }
        }
        
        while (!queue.isEmpty()) {
            Node node = queue.poll();
            list.add(node.value);
            for (Node child : node.list) {
                child.inDegree--;
                if (child.inDegree == 0) {
                    queue.offer(child);
                }
            }
        }
        if (list.size() < n) return new int[0];
        int[] result = new int[list.size()];
        for (int i = 0; i < list.size(); i++) {
            result[i] = list.get(i);
        }
        return result;
    }
}

class Node {
    int value;
    int inDegree;
    List<Node> list;

    public Node(int value, int inDegree) {
        this.value = value;
        this.inDegree = inDegree;
        list = new ArrayList<Node>();
    }
}

Python Version

from collections import defaultdict, deque
from typing import List

class Solution:
    def buildAdjacencyMap(self, edgesList):
        adjMap = defaultdict(list)
        for c1, c2 in edgesList:
            adjMap[c2].append(c1)
        return adjMap

    def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
        adjMap = self.buildAdjacencyMap(prerequisites)
        topoOrder = []
        inDegrees = defaultdict(int)

        # build indegree map
        for v1, _ in prerequisites:
            inDegrees[v1] += 1

        queue = deque()
        # add all nodes with indegree 0
        for v in range(numCourses):
            if inDegrees[v] == 0:
                queue.append(v)

        while queue:
            v = queue.popleft()
            topoOrder.append(v)

            for des in adjMap[v]:
                inDegrees[des] -= 1
                if inDegrees[des] == 0:
                    queue.append(des)

        if len(topoOrder) != numCourses:
            return []
        return topoOrder