Skip to content

Commit b74ee20

Browse files
maolonglongmaolonglong
committed
feat: add solutions to lc problem: No.0802.Find Eventual Safe States
1 parent 22358b4 commit b74ee20

File tree

5 files changed

+277
-2
lines changed

5 files changed

+277
-2
lines changed

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

+93-1
Original file line numberDiff line numberDiff line change
@@ -53,22 +53,114 @@
5353

5454
<!-- 这里可写通用的实现逻辑 -->
5555

56+
出度为零的点是安全的，如果一个点**只能**到达安全的点，那么它同样是安全的，所以问题转换成了拓扑排序
57+
5658
<!-- tabs:start -->
5759

5860
### **Python3**
5961

6062
<!-- 这里可写当前语言的特殊实现逻辑 -->
6163

6264
```python
63-
65+
class Solution:
66+
def eventualSafeNodes(self, graph: List[List[int]]) -> List[int]:
67+
n = len(graph)
68+
outDegree = [len(vs) for vs in graph]
69+
revGraph = [[] for _ in range(n)]
70+
for u, vs in enumerate(graph):
71+
for v in vs:
72+
revGraph[v].append(u)
73+
q = deque([i for i, d in enumerate(outDegree) if d == 0])
74+
while q:
75+
for u in revGraph[q.popleft()]:
76+
outDegree[u] -= 1
77+
if outDegree[u] == 0:
78+
q.append(u)
79+
return [i for i, d in enumerate(outDegree) if d == 0]
6480
```
6581

6682
### **Java**
6783

6884
<!-- 这里可写当前语言的特殊实现逻辑 -->
6985

7086
```java
87+
class Solution {
88+
public List<Integer> eventualSafeNodes(int[][] graph) {
89+
int n = graph.length;
90+
int[] outDegrees = new int[n];
91+
Queue<Integer> queue = new ArrayDeque<>();
92+
List<List<Integer>> revGraph = new ArrayList<>();
93+
for (int i = 0; i < n; i++) {
94+
revGraph.add(new ArrayList<>());
95+
}
96+
for (int u = 0; u < n; u++) {
97+
for (int v : graph[u]) {
98+
revGraph.get(v).add(u);
99+
}
100+
outDegrees[u] = graph[u].length;
101+
if (outDegrees[u] == 0) {
102+
queue.offer(u);
103+
}
104+
}
105+
106+
while (!queue.isEmpty()) {
107+
int v = queue.poll();
108+
for (int u : revGraph.get(v)) {
109+
if (--outDegrees[u] == 0) {
110+
queue.offer(u);
111+
}
112+
}
113+
}
114+
115+
List<Integer> ans = new ArrayList<>();
116+
for (int i = 0; i < n; i++) {
117+
if (outDegrees[i] == 0) {
118+
ans.add(i);
119+
}
120+
}
121+
return ans;
122+
}
123+
}
124+
```
71125

126+
### **Go**
127+
128+
```go
129+
func eventualSafeNodes(graph [][]int) []int {
130+
n := len(graph)
131+
outDegree := make([]int, n)
132+
revGraph := make([][]int, n)
133+
queue := make([]int, 0)
134+
ans := make([]int, 0)
135+
136+
for u, vs := range graph {
137+
for _, v := range vs {
138+
revGraph[v] = append(revGraph[v], u)
139+
}
140+
outDegree[u] = len(vs)
141+
if outDegree[u] == 0 {
142+
queue = append(queue, u)
143+
}
144+
}
145+
146+
for len(queue) > 0 {
147+
v := queue[0]
148+
queue = queue[1:]
149+
for _, u := range revGraph[v] {
150+
outDegree[u]--
151+
if outDegree[u] == 0 {
152+
queue = append(queue, u)
153+
}
154+
}
155+
}
156+
157+
for i, d := range outDegree {
158+
if d == 0 {
159+
ans = append(ans, i)
160+
}
161+
}
162+
return ans
163+
}
72164
```
73165

74166
### **...**

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

+93-1
Original file line numberDiff line numberDiff line change
@@ -43,18 +43,110 @@
4343

4444
## Solutions
4545

46+
The point with zero out-degree is safe, and if a point can **only** reach the safe point, then it is also safe, so the problem can be converted to topological sorting.
47+
4648
<!-- tabs:start -->
4749

4850
### **Python3**
4951

5052
```python
51-
53+
class Solution:
54+
def eventualSafeNodes(self, graph: List[List[int]]) -> List[int]:
55+
n = len(graph)
56+
outDegree = [len(vs) for vs in graph]
57+
revGraph = [[] for _ in range(n)]
58+
for u, vs in enumerate(graph):
59+
for v in vs:
60+
revGraph[v].append(u)
61+
q = deque([i for i, d in enumerate(outDegree) if d == 0])
62+
while q:
63+
for u in revGraph[q.popleft()]:
64+
outDegree[u] -= 1
65+
if outDegree[u] == 0:
66+
q.append(u)
67+
return [i for i, d in enumerate(outDegree) if d == 0]
5268
```
5369

5470
### **Java**
5571

5672
```java
73+
class Solution {
74+
public List<Integer> eventualSafeNodes(int[][] graph) {
75+
int n = graph.length;
76+
int[] outDegrees = new int[n];
77+
Queue<Integer> queue = new ArrayDeque<>();
78+
List<List<Integer>> revGraph = new ArrayList<>();
79+
for (int i = 0; i < n; i++) {
80+
revGraph.add(new ArrayList<>());
81+
}
82+
for (int u = 0; u < n; u++) {
83+
for (int v : graph[u]) {
84+
revGraph.get(v).add(u);
85+
}
86+
outDegrees[u] = graph[u].length;
87+
if (outDegrees[u] == 0) {
88+
queue.offer(u);
89+
}
90+
}
91+
92+
while (!queue.isEmpty()) {
93+
int v = queue.poll();
94+
for (int u : revGraph.get(v)) {
95+
if (--outDegrees[u] == 0) {
96+
queue.offer(u);
97+
}
98+
}
99+
}
100+
101+
List<Integer> ans = new ArrayList<>();
102+
for (int i = 0; i < n; i++) {
103+
if (outDegrees[i] == 0) {
104+
ans.add(i);
105+
}
106+
}
107+
return ans;
108+
}
109+
}
110+
```
57111

112+
### **Go**
113+
114+
```go
115+
func eventualSafeNodes(graph [][]int) []int {
116+
n := len(graph)
117+
outDegree := make([]int, n)
118+
revGraph := make([][]int, n)
119+
queue := make([]int, 0)
120+
ans := make([]int, 0)
121+
122+
for u, vs := range graph {
123+
for _, v := range vs {
124+
revGraph[v] = append(revGraph[v], u)
125+
}
126+
outDegree[u] = len(vs)
127+
if outDegree[u] == 0 {
128+
queue = append(queue, u)
129+
}
130+
}
131+
132+
for len(queue) > 0 {
133+
v := queue[0]
134+
queue = queue[1:]
135+
for _, u := range revGraph[v] {
136+
outDegree[u]--
137+
if outDegree[u] == 0 {
138+
queue = append(queue, u)
139+
}
140+
}
141+
}
142+
143+
for i, d := range outDegree {
144+
if d == 0 {
145+
ans = append(ans, i)
146+
}
147+
}
148+
return ans
149+
}
58150
```
59151

60152
### **...**

‎solution/0800-0899/0802.Find Eventual Safe States/Solution.go

+35
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,35 @@
1+
func eventualSafeNodes(graph [][]int) []int {
2+
n := len(graph)
3+
outDegree := make([]int, n)
4+
revGraph := make([][]int, n)
5+
queue := make([]int, 0)
6+
ans := make([]int, 0)
7+
8+
for u, vs := range graph {
9+
for _, v := range vs {
10+
revGraph[v] = append(revGraph[v], u)
11+
}
12+
outDegree[u] = len(vs)
13+
if outDegree[u] == 0 {
14+
queue = append(queue, u)
15+
}
16+
}
17+
18+
for len(queue) > 0 {
19+
v := queue[0]
20+
queue = queue[1:]
21+
for _, u := range revGraph[v] {
22+
outDegree[u]--
23+
if outDegree[u] == 0 {
24+
queue = append(queue, u)
25+
}
26+
}
27+
}
28+
29+
for i, d := range outDegree {
30+
if d == 0 {
31+
ans = append(ans, i)
32+
}
33+
}
34+
return ans
35+
}

‎solution/0800-0899/0802.Find Eventual Safe States/Solution.java

+37
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
class Solution {
2+
public List<Integer> eventualSafeNodes(int[][] graph) {
3+
int n = graph.length;
4+
int[] outDegrees = new int[n];
5+
Queue<Integer> queue = new ArrayDeque<>();
6+
List<List<Integer>> revGraph = new ArrayList<>();
7+
for (int i = 0; i < n; i++) {
8+
revGraph.add(new ArrayList<>());
9+
}
10+
for (int u = 0; u < n; u++) {
11+
for (int v : graph[u]) {
12+
revGraph.get(v).add(u);
13+
}
14+
outDegrees[u] = graph[u].length;
15+
if (outDegrees[u] == 0) {
16+
queue.offer(u);
17+
}
18+
}
19+
20+
while (!queue.isEmpty()) {
21+
int v = queue.poll();
22+
for (int u : revGraph.get(v)) {
23+
if (--outDegrees[u] == 0) {
24+
queue.offer(u);
25+
}
26+
}
27+
}
28+
29+
List<Integer> ans = new ArrayList<>();
30+
for (int i = 0; i < n; i++) {
31+
if (outDegrees[i] == 0) {
32+
ans.add(i);
33+
}
34+
}
35+
return ans;
36+
}
37+
}

‎solution/0800-0899/0802.Find Eventual Safe States/Solution.py

+19
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,19 @@
1+
from typing import List
2+
from collections import deque
3+
4+
5+
class Solution:
6+
def eventualSafeNodes(self, graph: List[List[int]]) -> List[int]:
7+
n = len(graph)
8+
outDegree = [len(vs) for vs in graph]
9+
revGraph = [[] for _ in range(n)]
10+
for u, vs in enumerate(graph):
11+
for v in vs:
12+
revGraph[v].append(u)
13+
q = deque([i for i, d in enumerate(outDegree) if d == 0])
14+
while q:
15+
for u in revGraph[q.popleft()]:
16+
outDegree[u] -= 1
17+
if outDegree[u] == 0:
18+
q.append(u)
19+
return [i for i, d in enumerate(outDegree) if d == 0]

0 commit comments

Comments
 (0)