Course Schedule I II LeetCode Java

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.

这道题目考的是拓扑排序相关内容，不了解什么是拓扑排序，可以参考博客：http://blog.youkuaiyun.com/dm_vincent/article/details/7714519

所以，这道题目也有两种解法(程序参考自：https://leetcode.com/discuss/39456/java-dfs-and-bfs-solution)：

BFS：

public class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        ArrayList[] graph = new ArrayList[numCourses];
        int[] degree = new int[numCourses];
        Queue queue = new LinkedList();
        int count=0;

        for(int i=0;i<numCourses;i++)
            graph[i] = new ArrayList();

        for(int i=0; i<prerequisites.length;i++){
            degree[prerequisites[i][1]]++;
            graph[prerequisites[i][0]].add(prerequisites[i][1]);
        }
        for(int i=0; i<degree.length;i++){
            if(degree[i] == 0){
                queue.add(i);
                count++;
            }
        }

        while(queue.size() != 0){
            int course = (int)queue.poll();
            for(int i=0; i<graph[course].size();i++){
                int pointer = (int)graph[course].get(i);
                degree[pointer]--;
                if(degree[pointer] == 0){
                    queue.add(pointer);
                    count++;
                }
            }
        }
        if(count == numCourses)
            return true;
        else    
            return false;
    }
}

DFS:

        public boolean canFinishDFS(int numCourses, int[][] prerequisites) {
            ArrayList[] graph = new ArrayList[numCourses];
            for(int i=0;i<numCourses;i++)
                graph[i] = new ArrayList();

            boolean[] visited = new boolean[numCourses];
            boolean[] visiting=new boolean[numCourses];
            for(int i=0; i<prerequisites.length;i++){
                graph[prerequisites[i][1]].add(prerequisites[i][0]);
            }

            for(int i=0; i<numCourses; i++){
                if(!dfs(graph,visited,visiting,i))
                    return false;
            }
            return true;
        }

        private boolean dfs(ArrayList[] graph, boolean[] visited, boolean[] visiting, int course){
            if(visiting[course])
                return false;
            if(visited[course])
                return true;

            visiting[course] = true;;

            for(int i=0; i<graph[course].size();i++){
                if(!dfs(graph,visited,visiting,(int)graph[course].get(i)))
                    return false;
            }
            visiting[course]=false;
            visited[course] = true;
            return true;
        }

Course Schedule II

这道题目和上道题目思路类似，只不过要求输出选课的顺序

同样有两种解法

BFS：

    public int[] findOrder(int numCourses, int[][] prerequisites){
        ArrayList<Integer>[] graph=new ArrayList[numCourses];
        int degree[] =new int[numCourses];
        Queue<Integer> queue=new LinkedList<Integer>();
        int count=0;
        int[] rst=new int[numCourses];

        for(int i=0;i<numCourses;i++){
            graph[i]=new ArrayList<Integer>();
        }

        for(int i=0;i<prerequisites.length;i++){
            degree[prerequisites[i][0]]++;
            graph[prerequisites[i][1]].add(prerequisites[i][0]);
        }

        for(int i=0;i<degree.length;i++){
            if(degree[i]==0){
                queue.add(i);
                rst[count]=i;
                count++;
            }
        }
        while(queue.size()!=0){
            int course=(int)queue.poll();
            for(int i=0;i<graph[course].size();i++){
                int pointer=(int)graph[course].get(i);
                degree[pointer]--;
                if(degree[pointer]==0){
                    queue.add(pointer);
                    rst[count]=pointer;
                    count++;
                }
            }
        }
        if(count == numCourses)
            return rst;
        else    
            return new int[0];
    } 

DFS：

public class Solution {
        private int[] rst;
        private int count;
        public int[] findOrder(int numCourses, int[][] prerequisites) {
            ArrayList[] graph = new ArrayList[numCourses];
            rst=new int[numCourses];
            count=0;
            for(int i=0;i<numCourses;i++)
                graph[i] = new ArrayList();

            boolean[] visited = new boolean[numCourses];
            boolean[] visiting=new boolean[numCourses];
            for(int i=0; i<prerequisites.length;i++){
                graph[prerequisites[i][0]].add(prerequisites[i][1]);
            }

            for(int i=0; i<numCourses; i++){
                if(!dfs2(graph,visited,visiting,i))
                    return new int[0];
            }
            return rst;
        }

        private boolean dfs2(ArrayList[] graph, boolean[] visited, boolean[] visiting, int course){
            if(visiting[course])
                return false;
            if(visited[course])
                return true;

            visiting[course] = true;;

            for(int i=0; i<graph[course].size();i++){
                if(!dfs2(graph,visited,visiting,(int)graph[course].get(i)))
                    return false;
            }
            visiting[course]=false;
            visited[course] = true;
            rst[count]=course;
            count++;
            return true;
        }
}