Alternating colors shortest path 5132.

In the drawing, the nodes are labeled as a  0, 1, ..., n-1. Each edge in this figure is not red blue, and there is loopback or parallel sides.

red_edges Each  [i, j] slave node indicating  i the node  j red directed edge. Similarly, blue_edges each of which  [i, j] representing from node  i to node  j blue directed edges.

Returns the length of  n the array  answer, which  answer[X] is from node  0 to node  X length of the shortest path, the path and alternating red and blue side edges. If such a path does not exist, then  answer[x] = -1.

 

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]

 

prompt:

• 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

 

/**
 * @param {number} n
 * @param {number[][]} red_edges
 * @param {number[][]} blue_edges
 * @return {number[]}
 */
var shortestAlternatingPaths = function(n, red_edges, blue_edges) {
    let blueDP = new Array(n+1).fill(0);
    let redDp = new Array(n+1).fill(0);
    
    let redMap = new Map(),blueMap = new Map();
    for(let [k,v] of red_edges){
        let arr = redMap.get(k)||[];
        arr.push(v);
        redMap.set(k,arr);
    }
    for(let [k,v] of blue_edges){
        let arr = blueMap.get(k)||[];
        arr.push(v);
        blueMap.set(k,arr);
    }
    
    let stack = [[0,0,"b"],[0,0,"r"]];
    let ans = new Array(n).fill(Infinity);
    let visitedRed=new Set();
    let visitedBlue=new Set();
    visitedRed.add(0)
    visitedBlue.add(0)
    while(stack.length>0){
        let [node,level,color] = stack.shift();
        ans[node]=Math.min(level,ans[node]);
        if(color==='r'){
            let nextColor = blueMap.get(node)||[];
            for(let c of nextColor){
                if(!visitedRed.has(c)){
                    visitedRed.add(c);
                    stack.push([c,level+1,'b']);
                }
            }
        }else{
            let nextColor = redMap.get(node)||[];
            for(let c of nextColor){
                if(!visitedBlue.has(c)){
                    visitedBlue.add(c);
                    stack.push([c,level+1,'r']);
                }
                
            }
        }
    }
    return ans.map(i=>i===Infinity?-1:i);
};

/**
 * @param {number} n
 * @param {number[][]} red_edges
 * @param {number[][]} blue_edges
 * @return {number[]}
 */
var shortestAlternatingPaths = function(n, red_edges, blue_edges) {
  let graph=Array(n).fill().map(()=>Array(n).fill(null))
  let dis=Array(n).fill().map(()=>({r:Infinity,b:Infinity}))
  dis[0].r=0
  dis[0].b=0
  for(let i=0;i<red_edges.length;i++){
    let [from,to]=red_edges[i]
    if(!graph[from][to])graph[from][to]={}
    graph[from][to].r=true
  }
  for(let i=0;i<blue_edges.length;i++){
    let [from,to]=blue_edges[i]
    if(!graph[from][to])graph[from][to]={}
    graph[from][to].b=true
  }
  
  let arr=[0]
  while(arr.length>0){
    let len=arr.length
    for(let i=0;i<len;i++){
      let from=arr.shift()
      for(let j=0;j<graph[from].length;j++){
        let to=j
        if(!graph[from][to])continue
        let {r,b}=graph[from][to]
        let needPush=false
        if(r){
          if(dis[from].b+1<dis[to].r){
            dis[to].r=dis[from].b+1
            needPush=true
          }
        }
        if(b){
          if(dis[from].r+1<dis[to].b){
            dis[to].b=dis[from].r+1
            needPush=true
          }
        }
        if(needPush){
          arr.push(to)
        }
      }
    }
  }
  let res=[]
  for(let i=0;i<dis.length;i++){
    let min=Math.min(dis[i].r,dis[i].b)
    if(min===Infinity)min=-1
    res[i]=min
  }
  // console.log(dis)
  return res
};