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[])) {
                 map.put(row[], new Node(row[], ));
             }

             if (!map.containsKey(row[])) {
                 map.put(row[], new Node(row[], ));
             }

             map.get(row[]).inDegree++;
             map.get(row[]).list.add(map.get(row[]));
         }

         Queue<Node> queue = new LinkedList<Node>();
         for (Node node : map.values()) {
             if (node.inDegree == ) {
                 queue.offer(node);
             }
         }

         while (!queue.isEmpty()) {
             Node node = queue.poll();
             for (Node child : node.list) {
                 child.inDegree--;
                 if (child.inDegree == ) {
                     queue.offer(child);
                 }
             }
         }
         for (Node node : map.values()) {
             if (node.inDegree != ) {
                 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 = ; 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[];
        Map<Integer, Node> map = new HashMap<Integer, Node>();
        // very important
        for (int i = ; i < n; i++){
            map.put(i, new Node(i, ));
        }

        for (int[] row : prerequisites) {
            map.get(row[]).inDegree++;
            map.get(row[]).list.add(map.get(row[]));
        }

        List<Integer> list = new ArrayList<Integer>();

        Queue<Node> queue = new LinkedList<Node>();
        for (Node node : map.values()) {
            if (node.inDegree == ) {
                queue.offer(node);
            }
        }

        while (!queue.isEmpty()) {
            Node node = queue.poll();
            list.add(node.value);
            for (Node child : node.list) {
                child.inDegree--;
                if (child.inDegree == ) {
                    queue.offer(child);
                }
            }
        }
        if (list.size() < n) return new int[];
        int[] result = new int[list.size()];
        for (int i = ; 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>();
    }
}