Consider a directed graph, with nodes labelled 0, 1, ..., n-1
. In this graph, each edge is either red or blue, and there could be self-edges or parallel edges.
Each [i, j]
in red_edges
denotes a red directed edge from node i
to node j
. Similarly, each [i, j]
in blue_edges
denotes a blue directed edge from node i
to node j
.
Return an array answer
of length n
, where each answer[X]
is the length of the shortest path from node 0
to node X
such that the edge colors alternate along the path (or -1
if such a path doesn't exist).
Example 1:
Input: n = 3, red_edges = [[0,1],[1,2]], blue_edges = [] Output: [0,1,-1]
Example 2:
Input: n = 3, red_edges = [[0,1]], blue_edges = [[2,1]] Output: [0,1,-1]
Example 3:
Input: n = 3, red_edges = [[1,0]], blue_edges = [[2,1]] Output: [0,-1,-1]
Example 4:
Input: n = 3, red_edges = [[0,1]], blue_edges = [[1,2]] Output: [0,1,2]
Example 5:
Input: n = 3, red_edges = [[0,1],[0,2]], blue_edges = [[1,0]] Output: [0,1,1]
Constraints:
1 <= n <= 100
red_edges.length <= 400
blue_edges.length <= 400
red_edges[i].length == blue_edges[i].length == 2
0 <= red_edges[i][j], blue_edges[i][j] < n
思路:BFS
class Solution(object):
def shortestAlternatingPaths(self, n, red_edges, blue_edges):
"""
:type n: int
:type red_edges: List[List[int]]
:type blue_edges: List[List[int]]
:rtype: List[int]
"""
adj_red={}
for s,t in red_edges:
if s not in adj_red: adj_red[s]=set()
adj_red[s].add(t)
adj_blue={}
for s,t in blue_edges:
if s not in adj_blue: adj_blue[s]=set()
adj_blue[s].add(t)
res={0:0}
q=[(0,0),(0,1)]
vis=set(q)
qq=[]
step=1
while q:
while q:
s,f=q.pop()
target=adj_red if f==0 else adj_blue
for t in target.get(s,[]):
if (t,1-f) in vis: continue
qq.append((t,1-f))
vis.add((t,1-f))
if t not in res: res[t]=step
q,qq=qq,q
step+=1
return [res[i] if i in res else -1 for i in range(n)]