Skip to content

Commit 4a2f472

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1466
No.1466.Reorder Routes to Make All Paths Lead to the City Zero
1 parent 93ff844 commit 4a2f472

File tree

6 files changed

+347
-2
lines changed

6 files changed

+347
-2
lines changed

‎solution/1400-1499/1466.Reorder Routes to Make All Paths Lead to the City Zero/README.md

Lines changed: 120 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -56,22 +56,141 @@
5656

5757
<!-- 这里可写通用的实现逻辑 -->
5858

59+
**方法一：DFS**
60+
61+
将图视为无向图。从编号 0 开始 dfs，如果遇到正向边，则需要累加一次变更。
62+
5963
<!-- tabs:start -->
6064

6165
### **Python3**
6266

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

6569
```python
66-
70+
class Solution:
71+
def minReorder(self, n: int, connections: List[List[int]]) -> int:
72+
def dfs(u):
73+
vis[u] = True
74+
ans = 0
75+
for v in g[u]:
76+
if not vis[v]:
77+
if (u, v) in s:
78+
ans += 1
79+
ans += dfs(v)
80+
return ans
81+
82+
g = defaultdict(list)
83+
s = set()
84+
for a, b in connections:
85+
g[a].append(b)
86+
g[b].append(a)
87+
s.add((a, b))
88+
vis = [False] * n
89+
return dfs(0)
6790
```
6891

6992
### **Java**
7093

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

7396
```java
97+
class Solution {
98+
public int minReorder(int n, int[][] connections) {
99+
Map<Integer, List<Pair<Integer, Boolean>>> g = new HashMap<>();
100+
for (int[] e : connections) {
101+
int u = e[0], v = e[1];
102+
g.computeIfAbsent(u, k -> new ArrayList<>()).add(new Pair<>(v, true));
103+
g.computeIfAbsent(v, k -> new ArrayList<>()).add(new Pair<>(u, false));
104+
}
105+
boolean[] vis = new boolean[n];
106+
return dfs(0, g, vis);
107+
}
108+
109+
private int dfs(int u, Map<Integer, List<Pair<Integer, Boolean>>> g, boolean[] vis) {
110+
vis[u] = true;
111+
int ans = 0;
112+
for (Pair<Integer, Boolean> e : g.getOrDefault(u, Collections.emptyList())) {
113+
int v = e.getKey();
114+
boolean exist = e.getValue();
115+
if (!vis[v]) {
116+
if (exist) {
117+
++ans;
118+
}
119+
ans += dfs(v, g, vis);
120+
}
121+
}
122+
return ans;
123+
}
124+
}
125+
```
126+
127+
### **C++**
128+
129+
```cpp
130+
class Solution {
131+
public:
132+
int minReorder(int n, vector<vector<int>>& connections) {
133+
unordered_map<int, vector<pair<int, bool>>> g;
134+
for (auto& e : connections)
135+
{
136+
int u = e[0], v = e[1];
137+
g[u].push_back({v, true});
138+
g[v].push_back({u, false});
139+
}
140+
vector<bool> vis(n);
141+
return dfs(0, g, vis);
142+
}
143+
144+
int dfs(int u, unordered_map<int, vector<pair<int, bool>>>& g, vector<bool>& vis) {
145+
vis[u] = true;
146+
int ans = 0;
147+
for (auto& p : g[u])
148+
{
149+
int v = p.first;
150+
bool exist = p.second;
151+
if (!vis[v])
152+
{
153+
if (exist) ++ans;
154+
ans += dfs(v, g, vis);
155+
}
156+
}
157+
return ans;
158+
}
159+
};
160+
```
74161

162+
### **Go**
163+
164+
```go
165+
func minReorder(n int, connections [][]int) int {
166+
type pib struct {
167+
v int
168+
b bool
169+
}
170+
g := map[int][]pib{}
171+
for _, e := range connections {
172+
u, v := e[0], e[1]
173+
g[u] = append(g[u], pib{v, true})
174+
g[v] = append(g[v], pib{u, false})
175+
}
176+
vis := make([]bool, n)
177+
var dfs func(int) int
178+
dfs = func(u int) int {
179+
ans := 0
180+
vis[u] = true
181+
for _, p := range g[u] {
182+
v, exist := p.v, p.b
183+
if !vis[v] {
184+
if exist {
185+
ans++
186+
}
187+
ans += dfs(v)
188+
}
189+
}
190+
return ans
191+
}
192+
return dfs(0)
193+
}
75194
```
76195

77196
### **...**

‎solution/1400-1499/1466.Reorder Routes to Make All Paths Lead to the City Zero/README_EN.md

Lines changed: 120 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -51,18 +51,137 @@
5151

5252
## Solutions
5353

54+
DFS.
55+
56+
Treat the graph as undirected. Start a dfs from the root, if you come across an edge in the forward direction, you need to reverse the edge.
57+
5458
<!-- tabs:start -->
5559

5660
### **Python3**
5761

5862
```python
59-
63+
class Solution:
64+
def minReorder(self, n: int, connections: List[List[int]]) -> int:
65+
def dfs(u):
66+
vis[u] = True
67+
ans = 0
68+
for v in g[u]:
69+
if not vis[v]:
70+
if (u, v) in s:
71+
ans += 1
72+
ans += dfs(v)
73+
return ans
74+
75+
g = defaultdict(list)
76+
s = set()
77+
for a, b in connections:
78+
g[a].append(b)
79+
g[b].append(a)
80+
s.add((a, b))
81+
vis = [False] * n
82+
return dfs(0)
6083
```
6184

6285
### **Java**
6386

6487
```java
88+
class Solution {
89+
public int minReorder(int n, int[][] connections) {
90+
Map<Integer, List<Pair<Integer, Boolean>>> g = new HashMap<>();
91+
for (int[] e : connections) {
92+
int u = e[0], v = e[1];
93+
g.computeIfAbsent(u, k -> new ArrayList<>()).add(new Pair<>(v, true));
94+
g.computeIfAbsent(v, k -> new ArrayList<>()).add(new Pair<>(u, false));
95+
}
96+
boolean[] vis = new boolean[n];
97+
return dfs(0, g, vis);
98+
}
99+
100+
private int dfs(int u, Map<Integer, List<Pair<Integer, Boolean>>> g, boolean[] vis) {
101+
vis[u] = true;
102+
int ans = 0;
103+
for (Pair<Integer, Boolean> e : g.getOrDefault(u, Collections.emptyList())) {
104+
int v = e.getKey();
105+
boolean exist = e.getValue();
106+
if (!vis[v]) {
107+
if (exist) {
108+
++ans;
109+
}
110+
ans += dfs(v, g, vis);
111+
}
112+
}
113+
return ans;
114+
}
115+
}
116+
```
117+
118+
### **C++**
119+
120+
```cpp
121+
class Solution {
122+
public:
123+
int minReorder(int n, vector<vector<int>>& connections) {
124+
unordered_map<int, vector<pair<int, bool>>> g;
125+
for (auto& e : connections)
126+
{
127+
int u = e[0], v = e[1];
128+
g[u].push_back({v, true});
129+
g[v].push_back({u, false});
130+
}
131+
vector<bool> vis(n);
132+
return dfs(0, g, vis);
133+
}
134+
135+
int dfs(int u, unordered_map<int, vector<pair<int, bool>>>& g, vector<bool>& vis) {
136+
vis[u] = true;
137+
int ans = 0;
138+
for (auto& p : g[u])
139+
{
140+
int v = p.first;
141+
bool exist = p.second;
142+
if (!vis[v])
143+
{
144+
if (exist) ++ans;
145+
ans += dfs(v, g, vis);
146+
}
147+
}
148+
return ans;
149+
}
150+
};
151+
```
65152

153+
### **Go**
154+
155+
```go
156+
func minReorder(n int, connections [][]int) int {
157+
type pib struct {
158+
v int
159+
b bool
160+
}
161+
g := map[int][]pib{}
162+
for _, e := range connections {
163+
u, v := e[0], e[1]
164+
g[u] = append(g[u], pib{v, true})
165+
g[v] = append(g[v], pib{u, false})
166+
}
167+
vis := make([]bool, n)
168+
var dfs func(int) int
169+
dfs = func(u int) int {
170+
ans := 0
171+
vis[u] = true
172+
for _, p := range g[u] {
173+
v, exist := p.v, p.b
174+
if !vis[v] {
175+
if exist {
176+
ans++
177+
}
178+
ans += dfs(v)
179+
}
180+
}
181+
return ans
182+
}
183+
return dfs(0)
184+
}
66185
```
67186

68187
### **...**

‎solution/1400-1499/1466.Reorder Routes to Make All Paths Lead to the City Zero/Solution.cpp

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
class Solution {
2+
public:
3+
int minReorder(int n, vector<vector<int>>& connections) {
4+
unordered_map<int, vector<pair<int, bool>>> g;
5+
for (auto& e : connections)
6+
{
7+
int u = e[0], v = e[1];
8+
g[u].push_back({v, true});
9+
g[v].push_back({u, false});
10+
}
11+
vector<bool> vis(n);
12+
return dfs(0, g, vis);
13+
}
14+
15+
int dfs(int u, unordered_map<int, vector<pair<int, bool>>>& g, vector<bool>& vis) {
16+
vis[u] = true;
17+
int ans = 0;
18+
for (auto& p : g[u])
19+
{
20+
int v = p.first;
21+
bool exist = p.second;
22+
if (!vis[v])
23+
{
24+
if (exist) ++ans;
25+
ans += dfs(v, g, vis);
26+
}
27+
}
28+
return ans;
29+
}
30+
};

‎solution/1400-1499/1466.Reorder Routes to Make All Paths Lead to the City Zero/Solution.go

Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
func minReorder(n int, connections [][]int) int {
2+
type pib struct {
3+
v int
4+
b bool
5+
}
6+
g := map[int][]pib{}
7+
for _, e := range connections {
8+
u, v := e[0], e[1]
9+
g[u] = append(g[u], pib{v, true})
10+
g[v] = append(g[v], pib{u, false})
11+
}
12+
vis := make([]bool, n)
13+
var dfs func(int) int
14+
dfs = func(u int) int {
15+
ans := 0
16+
vis[u] = true
17+
for _, p := range g[u] {
18+
v, exist := p.v, p.b
19+
if !vis[v] {
20+
if exist {
21+
ans++
22+
}
23+
ans += dfs(v)
24+
}
25+
}
26+
return ans
27+
}
28+
return dfs(0)
29+
}

‎solution/1400-1499/1466.Reorder Routes to Make All Paths Lead to the City Zero/Solution.java

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
class Solution {
2+
public int minReorder(int n, int[][] connections) {
3+
Map<Integer, List<Pair<Integer, Boolean>>> g = new HashMap<>();
4+
for (int[] e : connections) {
5+
int u = e[0], v = e[1];
6+
g.computeIfAbsent(u, k -> new ArrayList<>()).add(new Pair<>(v, true));
7+
g.computeIfAbsent(v, k -> new ArrayList<>()).add(new Pair<>(u, false));
8+
}
9+
boolean[] vis = new boolean[n];
10+
return dfs(0, g, vis);
11+
}
12+
13+
private int dfs(int u, Map<Integer, List<Pair<Integer, Boolean>>> g, boolean[] vis) {
14+
vis[u] = true;
15+
int ans = 0;
16+
for (Pair<Integer, Boolean> e : g.getOrDefault(u, Collections.emptyList())) {
17+
int v = e.getKey();
18+
boolean exist = e.getValue();
19+
if (!vis[v]) {
20+
if (exist) {
21+
++ans;
22+
}
23+
ans += dfs(v, g, vis);
24+
}
25+
}
26+
return ans;
27+
}
28+
}

‎solution/1400-1499/1466.Reorder Routes to Make All Paths Lead to the City Zero/Solution.py

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
class Solution:
2+
def minReorder(self, n: int, connections: List[List[int]]) -> int:
3+
def dfs(u):
4+
vis[u] = True
5+
ans = 0
6+
for v in g[u]:
7+
if not vis[v]:
8+
if (u, v) in s:
9+
ans += 1
10+
ans += dfs(v)
11+
return ans
12+
13+
g = defaultdict(list)
14+
s = set()
15+
for a, b in connections:
16+
g[a].append(b)
17+
g[b].append(a)
18+
s.add((a, b))
19+
vis = [False] * n
20+
return dfs(0)

0 commit comments

Comments
 (0)