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;
    }
}

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>();
    }
}