human
Solve in Python:
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
assistant
#Here is the Python program you requested.

from collections import defaultdict, deque
class Solution:
    def shortestAlternatingPaths(self, n: int, red_edges: List[List[int]], blue_edges: List[List[int]]) -> List[int]:
        # we can create a directed graph with 1 as red and 0 as blue
        graph = defaultdict(list)
        for to, frm in red_edges:
            graph[to] += [[frm,1]]
        for to, frm in blue_edges:
            graph[to] += [[frm,0]]
        
        # bfs to find shortest path to each node
        paths = [-1]*n
        visited = set()
        queue = deque()
        queue.append((0, None, 0))
        
        while queue:
            curr, color, path = queue.popleft()
            if paths[curr] == -1:
                paths[curr] = path
            
            for v, c in graph[curr]:
                # if we havent visited a specific weighted edge and color is alternating allow it
                if (v, c) not in visited and (color==None or c != color):
                    queue.append((v, c, path+1))
                    visited.add((v, c))
        return paths