#210 Course Schedule II

Description

There are a total of numCourses courses you have to take, labeled from 0 to numCourses - 1. You are given an array prerequisites where prerequisites[i] = [ai, bi] indicates that you must take course bi first if you want to take course ai.

For example, the pair [0, 1], indicates that to take course 0 you have to first take course 1.
Return the ordering of courses you should take to finish all courses. If there are many valid answers, return any of them. If it is impossible to finish all courses, return an empty array.

Examples

Example 1:

Input: numCourses = 2, prerequisites = [[1,0]]
Output: [0,1]
Explanation: There are a total of 2 courses to take. To take course 1 you should have finished course 0. So the correct course order is [0,1].

Example 2:

Input: numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]]
Output: [0,2,1,3]
Explanation: There are a total of 4 courses to take. To take course 3 you should have finished both courses 1 and 2. Both courses 1 and 2 should be taken after you finished course 0.
So one correct course order is [0,1,2,3]. Another correct ordering is [0,2,1,3].

Example 3:

Input: numCourses = 1, prerequisites = []
Output: [0]

思路

Question: 为什么同样是深搜，到这里就这么难了啊QuQ
这里的深搜我用了两个indicator，一个用来标识哪些节点已经被使用过（确定存在一条无环路径的的两个节点及其路径上的所有节点），一个用来标识在这条路径上哪些节点已经被使用过（用来判断是否存在环）

需要注意的是，因为是prerequisite，所以当前节点的安放要放置在所有outgoing节点运行完之后，这样确保了前置课程已经全部走完，再完成当前课程（也就是代码里面的route.add(v)要放在循环查找邻接链表之后）

但我觉得我的算法还不是很清晰，等看一下topology search再看看有没有更清楚的方法

• 更新
  做了802之后悟到了，可以通过同一个数组来判断访问情况，需要注意的是更新访问数组的位置，具体方法可以看802的思路
  这里要注意的是他需要倒序输出，所以route的add操作放在dfs_visit函数的末尾进行

代码

class Solution {
    List<List<Integer>> adjecency = new ArrayList<>();
    int[] visited;
    int[] visitedInOnePath;
    
    public List<Integer> dfs_visit(int v){
        if (visited[v] == 1)
            return new ArrayList<>();
        
        List<Integer> route = new ArrayList<>();
        List<Integer> wrong = new ArrayList<>();
        wrong.add(-1);
        
        for (Integer nextNode: adjecency.get(v)){
            if (visitedInOnePath[nextNode] == 1)
                return wrong;
            if (visited[nextNode] == 0){
                visitedInOnePath[nextNode] = 1;
                List<Integer> nextRoute = dfs_visit(nextNode);
                if (nextRoute.size() >= 1 && nextRoute.get(0) == -1)
                    return wrong;
                route.addAll(nextRoute);
                visitedInOnePath[nextNode] = 0;
            }
        }
        
        visited[v] = 1;
        route.add(v);
        return route;
    }
    
    public int[] findOrder(int numCourses, int[][] prerequisites) {
        visited = new int[numCourses];
        visitedInOnePath = new int[numCourses];
        
        for (int i = 0; i < numCourses; i++)
            adjecency.add(new ArrayList<>());
        
        for (int[] prerequisit: prerequisites){
            adjecency.get(prerequisit[0]).add(prerequisit[1]);
        }
        
        List<Integer> route = new ArrayList<>();
        
        for (int i = 0; i < numCourses; i++){
            visitedInOnePath[i] = 1;
            List<Integer> tmp = dfs_visit(i);
            if (tmp.size() >= 1 && tmp.get(0) == -1)
                return new int[0];
            route.addAll(tmp);
            
            visitedInOnePath[i] = 0;
        }
        
        int[] finalAnswer = new int[route.size()];
        for (int i = 0; i < route.size(); i++)
            finalAnswer[i] = route.get(i);
        
        return finalAnswer;
    }
}

更新

class Solution {
    int[] visited;
    List<List<Integer>> adj = new ArrayList<>();
    List<Integer> route = new ArrayList<>();
    
    public boolean dfs_visit(int v) {
        if (visited[v] > 0)
            return visited[v] == 2;
        
        visited[v] = 1;		// 注意这里的放置位置，不用在循环里面更新visited了！
        for (int node: adj.get(v)){
            if (!dfs_visit(node))
                return false;
        }
        
        visited[v] = 2;
        route.add(v);
        return true;
    }
    
    public int[] findOrder(int numCourses, int[][] prerequisites) {
        visited = new int[numCourses];
        for (int i = 0; i < numCourses; i++)
            adj.add(new ArrayList<>());
        
        for (int[] pair: prerequisites){
            adj.get(pair[0]).add(pair[1]);
        }
        
        for (int i = 0; i < numCourses; i++){
            if (!dfs_visit(i))
                return new int[0];
        }
        
        return route.stream().mapToInt(Integer::valueOf).toArray();
    }
}