802. Find Eventual Safe States [Medium]

/**
 * 自己的思路，DFS
 * 开始代码一直runtime error，看了discuss发现是因为helper里没有在进入递归前将dp[i]设为false
 * Runtime: 4 ms, faster than 99.18%
 * Memory Usage: 49 MB, less than 39.07%
 */
class Solution {
    public List<Integer> eventualSafeNodes(int[][] graph) {
        List<Integer> res = new ArrayList<>();
        Boolean[] visited = new Boolean[graph.length];
        for (int i = 0; i < graph.length; i++) {
            if (helper(visited, graph, i)) {
                res.add(i);
            }
        }
        return res;
    }
    
    private boolean helper(Boolean[] visited, int[][] graph, int i) {
        if (visited[i] != null)
            return visited[i];
        visited[i] = false; // 这里一定要先将visited设为false，因为在这条路的递归中可能会再回到当前节点，如果在进入递归前没给visited[i]一个值，会造成死循环，回到当前节点就说明是false了
        for (int next : graph[i]) {
            if (!helper(visited, graph, next)) {
                return false;
            }
        }
        visited[i] = true;
        return true;
    }
}

第一次复习

和上次代码一样，而且也没有想到BFS的办法

看discuss找到了一个，但是比较tricky，只当锻炼思维

思路和计划课表（🟠 leetcode207. Course Schedule）中的BFS差不多，那边是用某一方向的邻接表（因为是判断环，方向正反无所谓，全部边逆向也没关系）和indegree数组，这里是用反向的邻接表和outdegree数组。

对比：

207用BFS和用DFS差不多，因为indegree数组初始化搭着建立邻接表的循环一起完成，不会比建立不需要初始化的Boolean[]耽误多少时间。

但本题用BFS比用DFS慢很多，因为本题直接给出了邻接表，而我们要把它反向，浪费了时间空间。而且本题要求结果升序排列，用DFS得到的list直接是升序的，而BFS得到的list需要sort一次再返回。如果本题像207那样只给边让我们自己构建邻接表、不要求list有序，那这里的BFS就也会和DFS差不多了。

/**
 * 找有向图中出发无环的点集合
 * BFS，这题的BFS比较tricky，需要构建：
 * 一个出度数组，来找到每次到了terminal的点（出度为0）
 * 一张反向临接表，来找到各个出度被当前走到了terminal的点影响的点，将它们的出度➖1
 * what's more，最后还要排序得到的List，因为题目要求升序排列节点，而BFS中加入节点的顺序是先加计算完后出度为0的点，是无序的
 * （在DFS中因为我们判断节点没有无环的顺序是0～n-1，因此自然是从小到大添加的节点，就没有排序的问题）
 * Runtime: 24 ms, faster than 36.86%
 * Memory Usage: 49 MB, less than 56.92%
 */
class Solution {
    
    public List<Integer> eventualSafeNodes(int[][] graph) {
        List<Integer> res = new LinkedList();
        int n = graph.length;
        int[] outdegree = new int[n];
        List<Integer>[] reversedAdjacency = new List[n];
        LinkedList<Integer> queue = new LinkedList();
        
        // construct reversedAdjacency, outdegree array, and queue
        for (int i = 0; i < n; i++) {
            reversedAdjacency[i] = new LinkedList();
        }
        for (int i = 0; i < n; i++) {
            int[] nextNodes = graph[i];
            outdegree[i] = nextNodes.length;
            if (nextNodes.length == 0) {
                queue.add(i);
            }
            for (int node : nextNodes) {
                reversedAdjacency[node].add(i);
            }
        }
        
        // topological sort (BFS)
        while (!queue.isEmpty()) {
            int curr = queue.poll();
            res.add(curr);
            for (int pre : reversedAdjacency[curr]) {
                if (--outdegree[pre] == 0) {
                    queue.offer(pre);
                }
            }
        }
        
        Collections.sort(res);
        return res;
    }
    
}