802. Find Eventual Safe States [Medium]

最新推荐文章于 2021-08-05 10:32:36 发布

原创最新推荐文章于 2021-08-05 10:32:36 发布 · 169 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

刷题专栏收录该内容

175 篇文章

订阅专栏

这篇博客探讨了在解决有向图中寻找安全节点的问题时，深度优先搜索（DFS）和广度优先搜索（BFS）的策略。作者首先分享了一段使用DFS实现的代码，该代码能在99.18%的情况下更快地运行，并且由于DFS的自然顺序，结果列表无需额外排序。接着，作者提到了一个BFS的解决方案，虽然它需要构建反向邻接表和出度数组，并在最后进行排序，导致其效率低于DFS。博客还分析了两种方法在不同场景下的优缺点，并提供了BFS的实现代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

/**
 * 自己的思路，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;
    }
    
}