feat: add solutions to lc problem: No.0802

No.0802.Find Eventual Safe States

Author: yanglbme

solution/0800-0899/0802.Find Eventual Safe States/README.md

@@ -53,8 +53,22 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：拓扑排序**
+
 出度为零的点是安全的，如果一个点**只能**到达安全的点，那么它同样是安全的，所以问题转换成了拓扑排序。
 
+我们可以将图中所有边反向，得到一个反图，然后在反图上运行拓扑排序。
+
+时间复杂度 $O(n+m)$，其中 $n$ 表示图中的点数，$m$ 表示图中的边数。
+
+**方法二：DFS + 三色标记法**
+
+若起始节点位于一个环内，或者能到达一个环，则该节点不是安全的。否则，该节点是安全的。
+
+-   白色（用 0 表示）：该节点尚未被访问；
+-   灰色（用 1 表示）：该节点位于递归栈中，或者在某个环上；
+-   黑色（用 2 表示）：该节点搜索完毕，是一个安全节点。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -64,19 +78,38 @@
 ```python
 class Solution:
     def eventualSafeNodes(self, graph: List[List[int]]) -> List[int]:
-        n = len(graph)
-        outDegree = [len(vs) for vs in graph]
-        revGraph = defaultdict(list)
-        for u, vs in enumerate(graph):
-            for v in vs:
-                revGraph[v].append(u)
-        q = deque([i for i, d in enumerate(outDegree) if d == 0])
+        rg = defaultdict(list)
+        indeg = [0] * len(graph)
+        for i, vs in enumerate(graph):
+            for j in vs:
+                rg[j].append(i)
+            indeg[i] = len(vs)
+        q = deque([i for i, v in enumerate(indeg) if v == 0])
         while q:
-            for u in revGraph[q.popleft()]:
-                outDegree[u] -= 1
-                if outDegree[u] == 0:
-                    q.append(u)
-        return [i for i, d in enumerate(outDegree) if d == 0]
+            i = q.popleft()
+            for j in rg[i]:
+                indeg[j] -= 1
+                if indeg[j] == 0:
+                    q.append(j)
+        return [i for i, v in enumerate(indeg) if v == 0]
+```
+
+```python
+class Solution:
+    def eventualSafeNodes(self, graph: List[List[int]]) -> List[int]:
+        def dfs(i):
+            if color[i]:
+                return color[i] == 2
+            color[i] = 1
+            for j in graph[i]:
+                if not dfs(j):
+                    return False
+            color[i] = 2
+            return True
+
+        n = len(graph)
+        color = [0] * n
+        return [i for i in range(n) if dfs(i)]
 ```
 
 ### **Java**
@@ -87,39 +120,71 @@ class Solution:
 class Solution {
     public List<Integer> eventualSafeNodes(int[][] graph) {
         int n = graph.length;
-        int[] outDegrees = new int[n];
-        Queue<Integer> queue = new ArrayDeque<>();
-        List<List<Integer>> revGraph = new ArrayList<>();
-        for (int i = 0; i < n; i++) {
-            revGraph.add(new ArrayList<>());
-        }
-        for (int u = 0; u < n; u++) {
-            for (int v : graph[u]) {
-                revGraph.get(v).add(u);
+        int[] indeg = new int[n];
+        List<Integer>[] rg = new List[n];
+        for (int i = 0; i < n; ++i) {
+            rg[i] = new ArrayList<>();
+        }
+        Deque<Integer> q = new ArrayDeque<>();
+        for (int i = 0; i < n; ++i) {
+            for (int j : graph[i]) {
+                rg[j].add(i);
             }
-            outDegrees[u] = graph[u].length;
-            if (outDegrees[u] == 0) {
-                queue.offer(u);
+            indeg[i] = graph[i].length;
+            if (indeg[i] == 0) {
+                q.offer(i);
             }
         }
-
-        while (!queue.isEmpty()) {
-            int v = queue.poll();
-            for (int u : revGraph.get(v)) {
-                if (--outDegrees[u] == 0) {
-                    queue.offer(u);
+        while (!q.isEmpty()) {
+            int i = q.pollFirst();
+            for (int j : rg[i]) {
+                if (--indeg[j] == 0) {
+                    q.offer(j);
                 }
             }
         }
+        List<Integer> ans = new ArrayList<>();
+        for (int i = 0; i < n; ++i) {
+            if (indeg[i] == 0) {
+                ans.add(i);
+            }
+        }
+        return ans;
+    }
+}
+```
+
+```java
+class Solution {
+    private int[] color;
+    private int[][] g;
 
+    public List<Integer> eventualSafeNodes(int[][] graph) {
+        int n = graph.length;
+        color = new int[n];
+        g = graph;
         List<Integer> ans = new ArrayList<>();
-        for (int i = 0; i < n; i++) {
-            if (outDegrees[i] == 0) {
+        for (int i = 0; i < n; ++i) {
+            if (dfs(i)) {
                 ans.add(i);
             }
         }
         return ans;
     }
+
+    private boolean dfs(int i) {
+        if (color[i] > 0) {
+            return color[i] == 2;
+        }
+        color[i] = 1;
+        for (int j : g[i]) {
+            if (!dfs(j)) {
+                return false;
+            }
+        }
+        color[i] = 2;
+        return true;
+    }
 }
 ```
 
@@ -128,34 +193,59 @@ class Solution {
 ```go
 func eventualSafeNodes(graph [][]int) []int {
 	n := len(graph)
-	outDegree := make([]int, n)
-	revGraph := make([][]int, n)
-	queue := make([]int, 0)
-	ans := make([]int, 0)
-
-	for u, vs := range graph {
-		for _, v := range vs {
-			revGraph[v] = append(revGraph[v], u)
+	indeg := make([]int, n)
+	rg := make([][]int, n)
+	q := []int{}
+	for i, vs := range graph {
+		for _, j := range vs {
+			rg[j] = append(rg[j], i)
 		}
-		outDegree[u] = len(vs)
-		if outDegree[u] == 0 {
-			queue = append(queue, u)
+		indeg[i] = len(vs)
+		if indeg[i] == 0 {
+			q = append(q, i)
 		}
 	}
-
-	for len(queue) > 0 {
-		v := queue[0]
-		queue = queue[1:]
-		for _, u := range revGraph[v] {
-			outDegree[u]--
-			if outDegree[u] == 0 {
-				queue = append(queue, u)
+	for len(q) > 0 {
+		i := q[0]
+		q = q[1:]
+		for _, j := range rg[i] {
+			indeg[j]--
+			if indeg[j] == 0 {
+				q = append(q, j)
 			}
 		}
 	}
+	ans := []int{}
+	for i, v := range indeg {
+		if v == 0 {
+			ans = append(ans, i)
+		}
+	}
+	return ans
+}
+```
 
-	for i, d := range outDegree {
-		if d == 0 {
+```go
+func eventualSafeNodes(graph [][]int) []int {
+	n := len(graph)
+	color := make([]int, n)
+	var dfs func(int) bool
+	dfs = func(i int) bool {
+		if color[i] > 0 {
+			return color[i] == 2
+		}
+		color[i] = 1
+		for _, j := range graph[i] {
+			if !dfs(j) {
+				return false
+			}
+		}
+		color[i] = 2
+		return true
+	}
+	ans := []int{}
+	for i := range graph {
+		if dfs(i) {
 			ans = append(ans, i)
 		}
 	}
@@ -168,36 +258,120 @@ func eventualSafeNodes(graph [][]int) []int {
 ```cpp
 class Solution {
 public:
-    vector<int> eventualSafeNodes(vector<vector<int>> &graph) {
+    vector<int> eventualSafeNodes(vector<vector<int>>& graph) {
         int n = graph.size();
-        vector<vector<int>> revGraph(n);
-        vector<int> outDegree(n);
+        vector<int> indeg(n);
+        vector<vector<int>> rg(n);
+        queue<int> q;
         for (int i = 0; i < n; ++i)
         {
-            outDegree[i] += graph[i].size();
-            for (int j : graph[i])
-                revGraph[j].push_back(i);
+            for (int j : graph[i]) rg[j].push_back(i);
+            indeg[i] = graph[i].size();
+            if (indeg[i] == 0) q.push(i);
         }
-        queue<int> q;
-        for (int i = 0; i < n; ++i)
-            if (outDegree[i] == 0)
-                q.push(i);
         while (!q.empty())
         {
             int i = q.front();
             q.pop();
-            for (int j : revGraph[i])
-            {
-                if (--outDegree[j] == 0)
-                    q.push(j);
-            }
+            for (int j : rg[i]) if (--indeg[j] == 0) q.push(j);
         }
         vector<int> ans;
-        for (int i = 0; i < n; ++i)
-            if (outDegree[i] == 0)
-                ans.push_back(i);
+        for (int i = 0; i < n; ++i) if (indeg[i] == 0) ans.push_back(i);
+        return ans;
+    }
+};
+```
+
+```cpp
+class Solution {
+public:
+    vector<int> color;
+
+    vector<int> eventualSafeNodes(vector<vector<int>>& graph) {
+        int n = graph.size();
+        color.assign(n, 0);
+        vector<int> ans;
+        for (int i = 0; i < n; ++i) if (dfs(i, graph)) ans.push_back(i);
         return ans;
     }
+
+    bool dfs(int i, vector<vector<int>>& g) {
+        if (color[i]) return color[i] == 2;
+        color[i] = 1;
+        for (int j : g[i]) if (!dfs(j, g)) return false;
+        color[i] = 2;
+        return true;
+    }
+};
+```
+
+### **JavaScript**
+
+```js
+/**
+ * @param {number[][]} graph
+ * @return {number[]}
+ */
+var eventualSafeNodes = function (graph) {
+    const n = graph.length;
+    const rg = new Array(n).fill(0).map(() => new Array());
+    const indeg = new Array(n).fill(0);
+    const q = [];
+    for (let i = 0; i < n; ++i) {
+        for (let j of graph[i]) {
+            rg[j].push(i);
+        }
+        indeg[i] = graph[i].length;
+        if (indeg[i] == 0) {
+            q.push(i);
+        }
+    }
+    while (q.length) {
+        const i = q.shift();
+        for (let j of rg[i]) {
+            if (--indeg[j] == 0) {
+                q.push(j);
+            }
+        }
+    }
+    let ans = [];
+    for (let i = 0; i < n; ++i) {
+        if (indeg[i] == 0) {
+            ans.push(i);
+        }
+    }
+    return ans;
+};
+```
+
+```js
+/**
+ * @param {number[][]} graph
+ * @return {number[]}
+ */
+var eventualSafeNodes = function (graph) {
+    const n = graph.length;
+    const color = new Array(n).fill(0);
+    function dfs(i) {
+        if (color[i]) {
+            return color[i] == 2;
+        }
+        color[i] = 1;
+        for (const j of graph[i]) {
+            if (!dfs(j)) {
+                return false;
+            }
+        }
+        color[i] = 2;
+        return true;
+    }
+    let ans = [];
+    for (let i = 0; i < n; ++i) {
+        if (dfs(i)) {
+            ans.push(i);
+        }
+    }
+    return ans;
 };
 ```