feat: solve No.802

Author: BaffinLee

801-900/802. Find Eventual Safe States.md

@@ -0,0 +1,104 @@
+# 802. Find Eventual Safe States
+
+- Difficulty: Medium.
+- Related Topics: Depth-First Search, Breadth-First Search, Graph, Topological Sort.
+- Similar Questions: Build a Matrix With Conditions.
+
+## Problem
+
+There is a directed graph of `n` nodes with each node labeled from `0` to `n - 1`. The graph is represented by a **0-indexed** 2D integer array `graph` where `graph[i]` is an integer array of nodes adjacent to node `i`, meaning there is an edge from node `i` to each node in `graph[i]`.
+
+A node is a **terminal node** if there are no outgoing edges. A node is a **safe node** if every possible path starting from that node leads to a **terminal node** (or another safe node).
+
+Return **an array containing all the **safe nodes** of the graph**. The answer should be sorted in **ascending** order.
+
+ 
+Example 1:
+
+![](https://s3-lc-upload.s3.amazonaws.com/uploads/2018/03/17/picture1.png)
+
+```
+Input: graph = [[1,2],[2,3],[5],[0],[5],[],[]]
+Output: [2,4,5,6]
+Explanation: The given graph is shown above.
+Nodes 5 and 6 are terminal nodes as there are no outgoing edges from either of them.
+Every path starting at nodes 2, 4, 5, and 6 all lead to either node 5 or 6.
+```
+
+Example 2:
+
+```
+Input: graph = [[1,2,3,4],[1,2],[3,4],[0,4],[]]
+Output: [4]
+Explanation:
+Only node 4 is a terminal node, and every path starting at node 4 leads to node 4.
+```
+
+ 
+**Constraints:**
+
+
+	
+- `n == graph.length`
+	
+- `1 <= n <= 104`
+	
+- `0 <= graph[i].length <= n`
+	
+- `0 <= graph[i][j] <= n - 1`
+	
+- `graph[i]` is sorted in a strictly increasing order.
+	
+- The graph may contain self-loops.
+	
+- The number of edges in the graph will be in the range `[1, 4 * 104]`.
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[][]} graph
+ * @return {number[]}
+ */
+var eventualSafeNodes = function(graph) {
+    var map = Array(graph.length);
+    var path = Array(graph.length);
+    var res = [];
+    for (var i = 0; i < graph.length; i++) {
+        if (isSafeNode(i, graph, map, path)) {
+            res.push(i);
+        }
+    }
+    return res;
+};
+
+var isSafeNode = function(i, graph, map, path) {
+    if (graph[i].length === 0 || map[i] === 1) return true;
+    if (map[i] === 2 || path[i] === 1) return false;
+    path[i] = 1;
+    for (var j = 0; j < graph[i].length; j++) {
+        var index = graph[i][j];
+        if (!isSafeNode(index, graph, map, path)) {
+            path[i] = 0;
+            map[i] = 2;
+            return false;
+        }
+    }
+    path[i] = 0;
+    map[i] = 1;
+    return true;
+};
+```
+
+**Explain:**
+
+DFS (Depth First Search).
+
+**Complexity:**
+
+`n` nodes, `m` edges.
+
+* Time complexity : O(n + m).
+* Space complexity : O(n + m).