Skip to content

Commit 4f59100

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1059
No.1059.All Paths from Source Lead to Destination
1 parent 1472f2d commit 4f59100

File tree

6 files changed

+402
-2
lines changed

6 files changed

+402
-2
lines changed

‎solution/1000-1099/1059.All Paths from Source Lead to Destination/README.md

+149-1
Original file line numberDiff line numberDiff line change
@@ -65,22 +65,170 @@
6565

6666
<!-- 这里可写通用的实现逻辑 -->
6767

68+
**方法一：记忆化搜索**
69+
70+
建图，然后从 `source` 出发，进行深度优先搜索：
71+
72+
如果遇到了 `destination`，判断此时是否还有出边，如果有出边，返回 `false`，否则返回 `true`。
73+
74+
如果遇到了环（此前访问过），或者遇到了没有出边的节点，直接返回 `false`。
75+
76+
否则，我们把当前节点标记为已访问，然后对当前节点的所有出边进行深度优先搜索，只要有一条路径无法可以到达 `destination`，就返回 `false`，否则返回 `true`。
77+
78+
过程中我们用一个数组 $f$ 记录每个节点的状态，每个 $f[i]$ 的值有三种，分别表示：
79+
80+
- 对于 $f[i] = 0$，表示节点 $i$ 未被访问；
81+
- 对于 $f[i] = 1$，表示节点 $i$ 已被访问，且可以到达 `destination`；
82+
- 对于 $f[i] = 2$，表示节点 $i$ 已被访问，但无法到达 `destination`。
83+
84+
时间复杂度 $O(n)$。其中 $n$ 为节点数。
85+
6886
<!-- tabs:start -->
6987

7088
### **Python3**
7189

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

7492
```python
75-
93+
class Solution:
94+
def leadsToDestination(self, n: int, edges: List[List[int]], source: int, destination: int) -> bool:
95+
@cache
96+
def dfs(i):
97+
if i == destination:
98+
return not g[i]
99+
if i in vis or not g[i]:
100+
return False
101+
vis.add(i)
102+
for j in g[i]:
103+
if not dfs(j):
104+
return False
105+
return True
106+
107+
g = defaultdict(list)
108+
for a, b in edges:
109+
g[a].append(b)
110+
vis = set()
111+
return dfs(source)
76112
```
77113

78114
### **Java**
79115

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

82118
```java
119+
class Solution {
120+
private List<Integer>[] g;
121+
private int[] f;
122+
private boolean[] vis;
123+
private int k;
124+
125+
public boolean leadsToDestination(int n, int[][] edges, int source, int destination) {
126+
vis = new boolean[n];
127+
g = new List[n];
128+
k = destination;
129+
f = new int[n];
130+
for (int i = 0; i < n; ++i) {
131+
g[i] = new ArrayList<>();
132+
}
133+
for (var e : edges) {
134+
g[e[0]].add(e[1]);
135+
}
136+
return dfs(source);
137+
}
138+
139+
private boolean dfs(int i) {
140+
if (i == k) {
141+
return g[i].isEmpty();
142+
}
143+
if (f[i] != 0) {
144+
return f[i] == 1;
145+
}
146+
if (vis[i] || g[i].isEmpty()) {
147+
return false;
148+
}
149+
vis[i] = true;
150+
for (int j : g[i]) {
151+
if (!dfs(j)) {
152+
f[i] = -1;
153+
return false;
154+
}
155+
}
156+
f[i] = 1;
157+
return true;
158+
}
159+
}
160+
```
161+
162+
### **C++**
163+
164+
```cpp
165+
class Solution {
166+
public:
167+
bool leadsToDestination(int n, vector<vector<int>>& edges, int source, int destination) {
168+
vector<bool> vis(n);
169+
vector<vector<int>> g(n);
170+
vector<int> f(n);
171+
for (auto& e : edges) {
172+
g[e[0]].push_back(e[1]);
173+
}
174+
function<bool(int)> dfs = [&](int i) {
175+
if (i == destination) {
176+
return g[i].empty();
177+
}
178+
if (f[i]) {
179+
return f[i] == 1;
180+
}
181+
if (vis[i] || g[i].empty()) {
182+
return false;
183+
}
184+
vis[i] = true;
185+
for (int j : g[i]) {
186+
if (!dfs(j)) {
187+
f[i] = -1;
188+
return false;
189+
}
190+
}
191+
f[i] = 1;
192+
return true;
193+
};
194+
return dfs(source);
195+
}
196+
};
197+
```
83198
199+
### **Go**
200+
201+
```go
202+
func leadsToDestination(n int, edges [][]int, source int, destination int) bool {
203+
vis := make([]bool, n)
204+
g := make([][]int, n)
205+
f := make([]int, n)
206+
for _, e := range edges {
207+
g[e[0]] = append(g[e[0]], e[1])
208+
}
209+
var dfs func(int) bool
210+
dfs = func(i int) bool {
211+
if i == destination {
212+
return len(g[i]) == 0
213+
}
214+
if f[i] != 0 {
215+
return f[i] == 1
216+
}
217+
if vis[i] || len(g[i]) == 0 {
218+
return false
219+
}
220+
vis[i] = true
221+
for _, j := range g[i] {
222+
if !dfs(j) {
223+
f[i] = -1
224+
return false
225+
}
226+
}
227+
f[i] = 1
228+
return true
229+
}
230+
return dfs(source)
231+
}
84232
```
85233

86234
### **...**

‎solution/1000-1099/1059.All Paths from Source Lead to Destination/README_EN.md

+131-1
Original file line numberDiff line numberDiff line change
@@ -58,13 +58,143 @@
5858
### **Python3**
5959

6060
```python
61-
61+
class Solution:
62+
def leadsToDestination(self, n: int, edges: List[List[int]], source: int, destination: int) -> bool:
63+
@cache
64+
def dfs(i):
65+
if i == destination:
66+
return not g[i]
67+
if i in vis or not g[i]:
68+
return False
69+
vis.add(i)
70+
for j in g[i]:
71+
if not dfs(j):
72+
return False
73+
return True
74+
75+
g = defaultdict(list)
76+
for a, b in edges:
77+
g[a].append(b)
78+
vis = set()
79+
return dfs(source)
6280
```
6381

6482
### **Java**
6583

6684
```java
85+
class Solution {
86+
private List<Integer>[] g;
87+
private int[] f;
88+
private boolean[] vis;
89+
private int k;
90+
91+
public boolean leadsToDestination(int n, int[][] edges, int source, int destination) {
92+
vis = new boolean[n];
93+
g = new List[n];
94+
k = destination;
95+
f = new int[n];
96+
for (int i = 0; i < n; ++i) {
97+
g[i] = new ArrayList<>();
98+
}
99+
for (var e : edges) {
100+
g[e[0]].add(e[1]);
101+
}
102+
return dfs(source);
103+
}
104+
105+
private boolean dfs(int i) {
106+
if (i == k) {
107+
return g[i].isEmpty();
108+
}
109+
if (f[i] != 0) {
110+
return f[i] == 1;
111+
}
112+
if (vis[i] || g[i].isEmpty()) {
113+
return false;
114+
}
115+
vis[i] = true;
116+
for (int j : g[i]) {
117+
if (!dfs(j)) {
118+
f[i] = -1;
119+
return false;
120+
}
121+
}
122+
f[i] = 1;
123+
return true;
124+
}
125+
}
126+
```
127+
128+
### **C++**
129+
130+
```cpp
131+
class Solution {
132+
public:
133+
bool leadsToDestination(int n, vector<vector<int>>& edges, int source, int destination) {
134+
vector<bool> vis(n);
135+
vector<vector<int>> g(n);
136+
vector<int> f(n);
137+
for (auto& e : edges) {
138+
g[e[0]].push_back(e[1]);
139+
}
140+
function<bool(int)> dfs = [&](int i) {
141+
if (i == destination) {
142+
return g[i].empty();
143+
}
144+
if (f[i]) {
145+
return f[i] == 1;
146+
}
147+
if (vis[i] || g[i].empty()) {
148+
return false;
149+
}
150+
vis[i] = true;
151+
for (int j : g[i]) {
152+
if (!dfs(j)) {
153+
f[i] = -1;
154+
return false;
155+
}
156+
}
157+
f[i] = 1;
158+
return true;
159+
};
160+
return dfs(source);
161+
}
162+
};
163+
```
67164
165+
### **Go**
166+
167+
```go
168+
func leadsToDestination(n int, edges [][]int, source int, destination int) bool {
169+
vis := make([]bool, n)
170+
g := make([][]int, n)
171+
f := make([]int, n)
172+
for _, e := range edges {
173+
g[e[0]] = append(g[e[0]], e[1])
174+
}
175+
var dfs func(int) bool
176+
dfs = func(i int) bool {
177+
if i == destination {
178+
return len(g[i]) == 0
179+
}
180+
if f[i] != 0 {
181+
return f[i] == 1
182+
}
183+
if vis[i] || len(g[i]) == 0 {
184+
return false
185+
}
186+
vis[i] = true
187+
for _, j := range g[i] {
188+
if !dfs(j) {
189+
f[i] = -1
190+
return false
191+
}
192+
}
193+
f[i] = 1
194+
return true
195+
}
196+
return dfs(source)
197+
}
68198
```
69199

70200
### **...**

‎solution/1000-1099/1059.All Paths from Source Lead to Destination/Solution.cpp

+32
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
class Solution {
2+
public:
3+
bool leadsToDestination(int n, vector<vector<int>>& edges, int source, int destination) {
4+
vector<bool> vis(n);
5+
vector<vector<int>> g(n);
6+
vector<int> f(n);
7+
for (auto& e : edges) {
8+
g[e[0]].push_back(e[1]);
9+
}
10+
function<bool(int)> dfs = [&](int i) {
11+
if (i == destination) {
12+
return g[i].empty();
13+
}
14+
if (f[i]) {
15+
return f[i] == 1;
16+
}
17+
if (vis[i] || g[i].empty()) {
18+
return false;
19+
}
20+
vis[i] = true;
21+
for (int j : g[i]) {
22+
if (!dfs(j)) {
23+
f[i] = -1;
24+
return false;
25+
}
26+
}
27+
f[i] = 1;
28+
return true;
29+
};
30+
return dfs(source);
31+
}
32+
};

‎solution/1000-1099/1059.All Paths from Source Lead to Destination/Solution.go

+30
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
func leadsToDestination(n int, edges [][]int, source int, destination int) bool {
2+
vis := make([]bool, n)
3+
g := make([][]int, n)
4+
f := make([]int, n)
5+
for _, e := range edges {
6+
g[e[0]] = append(g[e[0]], e[1])
7+
}
8+
var dfs func(int) bool
9+
dfs = func(i int) bool {
10+
if i == destination {
11+
return len(g[i]) == 0
12+
}
13+
if f[i] != 0 {
14+
return f[i] == 1
15+
}
16+
if vis[i] || len(g[i]) == 0 {
17+
return false
18+
}
19+
vis[i] = true
20+
for _, j := range g[i] {
21+
if !dfs(j) {
22+
f[i] = -1
23+
return false
24+
}
25+
}
26+
f[i] = 1
27+
return true
28+
}
29+
return dfs(source)
30+
}

0 commit comments

Comments
 (0)