Skip to content

Commit 7ab0db1

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1129
No.1129.Shortest Path with Alternating Colors
1 parent d820a44 commit 7ab0db1

File tree

6 files changed

+517
-2
lines changed

6 files changed

+517
-2
lines changed

‎solution/1100-1199/1129.Shortest Path with Alternating Colors/README.md

Lines changed: 176 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -65,22 +65,197 @@
6565

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

68+
**方法一：BFS**
69+
6870
<!-- tabs:start -->
6971

7072
### **Python3**
7173

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

7476
```python
75-
77+
class Solution:
78+
def shortestAlternatingPaths(self, n: int, redEdges: List[List[int]], blueEdges: List[List[int]]) -> List[int]:
79+
red = defaultdict(list)
80+
blue = defaultdict(list)
81+
for i, j in redEdges:
82+
red[i].append(j)
83+
for i, j in blueEdges:
84+
blue[i].append(j)
85+
vis_blue = [False] * n
86+
vis_red = [False] * n
87+
q = deque([(0, True), (0, False)])
88+
ans = [-1] * n
89+
d = -1
90+
while q:
91+
d += 1
92+
for _ in range(len(q)):
93+
i, b = q.popleft()
94+
if ans[i] == -1 or ans[i] > d:
95+
ans[i] = d
96+
vis = vis_blue if b else vis_red
97+
vis[i] = True
98+
ne = red[i] if b else blue[i]
99+
v = vis_red if b else vis_blue
100+
for j in ne:
101+
if not v[j]:
102+
v[j] = True
103+
q.append((j, not b))
104+
return ans
76105
```
77106

78107
### **Java**
79108

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

82111
```java
112+
class Solution {
113+
public int[] shortestAlternatingPaths(int n, int[][] redEdges, int[][] blueEdges) {
114+
List<Integer>[] red = get(n, redEdges);
115+
List<Integer>[] blue = get(n, blueEdges);
116+
boolean[] visBlue = new boolean[n];
117+
boolean[] visRed = new boolean[n];
118+
Deque<int[]> q = new ArrayDeque<>();
119+
q.offer(new int[]{0, 1});
120+
q.offer(new int[]{0, 0});
121+
int d = -1;
122+
int[] ans = new int[n];
123+
Arrays.fill(ans, -1);
124+
while (!q.isEmpty()) {
125+
++d;
126+
for (int t = q.size(); t > 0; --t) {
127+
int[] p = q.poll();
128+
int i = p[0];
129+
boolean b = p[1] == 1;
130+
if (ans[i] == -1 || ans[i] > d) {
131+
ans[i] = d;
132+
}
133+
boolean[] vis = b ? visBlue : visRed;
134+
vis[i] = true;
135+
List<Integer> ne = b ? red[i] : blue[i];
136+
boolean[] v = b ? visRed : visBlue;
137+
for (int j : ne) {
138+
if (!v[j]) {
139+
v[j] = true;
140+
q.offer(new int[]{j, 1 - p[1]});
141+
}
142+
}
143+
}
144+
}
145+
return ans;
146+
}
147+
148+
private List<Integer>[] get(int n, int[][] edges) {
149+
List<Integer>[] res = new List[n];
150+
for (int i = 0; i < n; ++i) {
151+
res[i] = new ArrayList<>();
152+
}
153+
for (int[] e : edges) {
154+
res[e[0]].add(e[1]);
155+
}
156+
return res;
157+
}
158+
}
159+
```
160+
161+
### **C++**
162+
163+
```cpp
164+
class Solution {
165+
public:
166+
vector<int> shortestAlternatingPaths(int n, vector<vector<int>>& redEdges, vector<vector<int>>& blueEdges) {
167+
vector<vector<int>> red = get(n, redEdges);
168+
vector<vector<int>> blue = get(n, blueEdges);
169+
vector<bool> visBlue(n);
170+
vector<bool> visRed(n);
171+
queue<pair<int, bool>> q;
172+
q.push({0, true});
173+
q.push({0, false});
174+
int d = -1;
175+
vector<int> ans(n, -1);
176+
while (!q.empty())
177+
{
178+
++d;
179+
for (int t = q.size(); t > 0; --t)
180+
{
181+
auto p = q.front();
182+
q.pop();
183+
int i = p.first;
184+
bool b = p.second;
185+
if (ans[i] == -1 || ans[i] > d) ans[i] = d;
186+
vector<bool>& vis = b ? visBlue : visRed;
187+
vis[i] = true;
188+
vector<int>& ne = b ? red[i] : blue[i];
189+
vector<bool>& v = b ? visRed : visBlue;
190+
for (int j : ne)
191+
{
192+
if (v[j]) continue;
193+
v[j] = true;
194+
q.push({j, !b});
195+
}
196+
}
197+
}
198+
return ans;
199+
}
200+
201+
vector<vector<int>> get(int n, vector<vector<int>>& edges) {
202+
vector<vector<int>> res(n);
203+
for (auto& e : edges) res[e[0]].push_back(e[1]);
204+
return res;
205+
}
206+
};
207+
```
83208

209+
### **Go**
210+
211+
```go
212+
func shortestAlternatingPaths(n int, redEdges [][]int, blueEdges [][]int) []int {
213+
get := func(edges [][]int) [][]int {
214+
res := make([][]int, n)
215+
for _, e := range edges {
216+
res[e[0]] = append(res[e[0]], e[1])
217+
}
218+
return res
219+
}
220+
red := get(redEdges)
221+
blue := get(blueEdges)
222+
visBlue := make([]bool, n)
223+
visRed := make([]bool, n)
224+
q := [][]int{{0, 1}, {0, 0}}
225+
ans := make([]int, n)
226+
for i := range ans {
227+
ans[i] = -1
228+
}
229+
d := -1
230+
for len(q) > 0 {
231+
d++
232+
for t := len(q); t > 0; t-- {
233+
p := q[0]
234+
q = q[1:]
235+
i := p[0]
236+
b := p[1] == 1
237+
if ans[i] == -1 || ans[i] > d {
238+
ans[i] = d
239+
}
240+
vis := visRed
241+
ne := blue[i]
242+
v := visBlue
243+
if b {
244+
vis = visBlue
245+
ne = red[i]
246+
v = visRed
247+
}
248+
vis[i] = true
249+
for _, j := range ne {
250+
if !v[j] {
251+
v[j] = true
252+
q = append(q, []int{j, 1 - p[1]})
253+
}
254+
}
255+
}
256+
}
257+
return ans
258+
}
84259
```
85260

86261
### **...**

‎solution/1100-1199/1129.Shortest Path with Alternating Colors/README_EN.md

Lines changed: 176 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -42,18 +42,193 @@
4242

4343
## Solutions
4444

45+
BFS.
46+
4547
<!-- tabs:start -->
4648

4749
### **Python3**
4850

4951
```python
50-
52+
class Solution:
53+
def shortestAlternatingPaths(self, n: int, redEdges: List[List[int]], blueEdges: List[List[int]]) -> List[int]:
54+
red = defaultdict(list)
55+
blue = defaultdict(list)
56+
for i, j in redEdges:
57+
red[i].append(j)
58+
for i, j in blueEdges:
59+
blue[i].append(j)
60+
vis_blue = [False] * n
61+
vis_red = [False] * n
62+
q = deque([(0, True), (0, False)])
63+
ans = [-1] * n
64+
d = -1
65+
while q:
66+
d += 1
67+
for _ in range(len(q)):
68+
i, b = q.popleft()
69+
if ans[i] == -1 or ans[i] > d:
70+
ans[i] = d
71+
vis = vis_blue if b else vis_red
72+
vis[i] = True
73+
ne = red[i] if b else blue[i]
74+
v = vis_red if b else vis_blue
75+
for j in ne:
76+
if not v[j]:
77+
v[j] = True
78+
q.append((j, not b))
79+
return ans
5180
```
5281

5382
### **Java**
5483

5584
```java
85+
class Solution {
86+
public int[] shortestAlternatingPaths(int n, int[][] redEdges, int[][] blueEdges) {
87+
List<Integer>[] red = get(n, redEdges);
88+
List<Integer>[] blue = get(n, blueEdges);
89+
boolean[] visBlue = new boolean[n];
90+
boolean[] visRed = new boolean[n];
91+
Deque<int[]> q = new ArrayDeque<>();
92+
q.offer(new int[]{0, 1});
93+
q.offer(new int[]{0, 0});
94+
int d = -1;
95+
int[] ans = new int[n];
96+
Arrays.fill(ans, -1);
97+
while (!q.isEmpty()) {
98+
++d;
99+
for (int t = q.size(); t > 0; --t) {
100+
int[] p = q.poll();
101+
int i = p[0];
102+
boolean b = p[1] == 1;
103+
if (ans[i] == -1 || ans[i] > d) {
104+
ans[i] = d;
105+
}
106+
boolean[] vis = b ? visBlue : visRed;
107+
vis[i] = true;
108+
List<Integer> ne = b ? red[i] : blue[i];
109+
boolean[] v = b ? visRed : visBlue;
110+
for (int j : ne) {
111+
if (!v[j]) {
112+
v[j] = true;
113+
q.offer(new int[]{j, 1 - p[1]});
114+
}
115+
}
116+
}
117+
}
118+
return ans;
119+
}
120+
121+
private List<Integer>[] get(int n, int[][] edges) {
122+
List<Integer>[] res = new List[n];
123+
for (int i = 0; i < n; ++i) {
124+
res[i] = new ArrayList<>();
125+
}
126+
for (int[] e : edges) {
127+
res[e[0]].add(e[1]);
128+
}
129+
return res;
130+
}
131+
}
132+
```
133+
134+
### **C++**
135+
136+
```cpp
137+
class Solution {
138+
public:
139+
vector<int> shortestAlternatingPaths(int n, vector<vector<int>>& redEdges, vector<vector<int>>& blueEdges) {
140+
vector<vector<int>> red = get(n, redEdges);
141+
vector<vector<int>> blue = get(n, blueEdges);
142+
vector<bool> visBlue(n);
143+
vector<bool> visRed(n);
144+
queue<pair<int, bool>> q;
145+
q.push({0, true});
146+
q.push({0, false});
147+
int d = -1;
148+
vector<int> ans(n, -1);
149+
while (!q.empty())
150+
{
151+
++d;
152+
for (int t = q.size(); t > 0; --t)
153+
{
154+
auto p = q.front();
155+
q.pop();
156+
int i = p.first;
157+
bool b = p.second;
158+
if (ans[i] == -1 || ans[i] > d) ans[i] = d;
159+
vector<bool>& vis = b ? visBlue : visRed;
160+
vis[i] = true;
161+
vector<int>& ne = b ? red[i] : blue[i];
162+
vector<bool>& v = b ? visRed : visBlue;
163+
for (int j : ne)
164+
{
165+
if (v[j]) continue;
166+
v[j] = true;
167+
q.push({j, !b});
168+
}
169+
}
170+
}
171+
return ans;
172+
}
173+
174+
vector<vector<int>> get(int n, vector<vector<int>>& edges) {
175+
vector<vector<int>> res(n);
176+
for (auto& e : edges) res[e[0]].push_back(e[1]);
177+
return res;
178+
}
179+
};
180+
```
56181

182+
### **Go**
183+
184+
```go
185+
func shortestAlternatingPaths(n int, redEdges [][]int, blueEdges [][]int) []int {
186+
get := func(edges [][]int) [][]int {
187+
res := make([][]int, n)
188+
for _, e := range edges {
189+
res[e[0]] = append(res[e[0]], e[1])
190+
}
191+
return res
192+
}
193+
red := get(redEdges)
194+
blue := get(blueEdges)
195+
visBlue := make([]bool, n)
196+
visRed := make([]bool, n)
197+
q := [][]int{{0, 1}, {0, 0}}
198+
ans := make([]int, n)
199+
for i := range ans {
200+
ans[i] = -1
201+
}
202+
d := -1
203+
for len(q) > 0 {
204+
d++
205+
for t := len(q); t > 0; t-- {
206+
p := q[0]
207+
q = q[1:]
208+
i := p[0]
209+
b := p[1] == 1
210+
if ans[i] == -1 || ans[i] > d {
211+
ans[i] = d
212+
}
213+
vis := visRed
214+
ne := blue[i]
215+
v := visBlue
216+
if b {
217+
vis = visBlue
218+
ne = red[i]
219+
v = visRed
220+
}
221+
vis[i] = true
222+
for _, j := range ne {
223+
if !v[j] {
224+
v[j] = true
225+
q = append(q, []int{j, 1 - p[1]})
226+
}
227+
}
228+
}
229+
}
230+
return ans
231+
}
57232
```
58233

59234
### **...**

0 commit comments

Comments
 (0)