1129. Shortest Path with Alternating Colors

原题链接在这里：https://leetcode.com/problems/shortest-path-with-alternating-colors/

题目：

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

题解：

To calculate the shortest path, use BFS.

Construct the graph, for each node, put its neighbors into 2 different sets based on edge colors.

res array also have 2 rows, shortest paths from different edges.

Add {0, 0}, {1, 0} into queue representing starting node with different colored edges.

When pulling out cur. cur[0] is the color going out, cur[1] is the node i. find it neighbor by graph[cur[0]][cur[1]].

For each neighbor, it needs to spread out with different color 1- cur[0]. Thus check res[1-cur[0]][nei]. 

If it has been visited before, it should still be Integer.MAX_VALUE, update it with current step res[cur[0]][cur[1]] + 1. And add it to queue.

Finally get the smallest steps for each of the nodes.

Note: Set<Integer> [][] graph = new Set[2][n]. Declared type must include type Integer. Constructor can't put <Integer> after Set.

Time Complexity: O(n+E). Perform 2 BFS iterations. E = red_edges.length + blue_edges.length.

Space: O(n). 

AC Java:

class Solution {
    public int[] shortestAlternatingPaths(int n, int[][] red_edges, int[][] blue_edges) {
        Set<Integer> [][] graph = new Set[2][n];
        for(int i = 0; i<n; i++){
            graph[0][i] = new HashSet<>();
            graph[1][i] = new HashSet<>();
        }
        
        for(int [] red : red_edges){
            graph[0][red[0]].add(red[1]);
        }
        
        for(int [] blue : blue_edges){
            graph[1][blue[0]].add(blue[1]);
        }
        
        int [][] res = new int[2][n];
        for(int i = 1; i<n; i++){
            res[0][i] = Integer.MAX_VALUE;
            res[1][i] = Integer.MAX_VALUE;
        }
        
        LinkedList<int []> que = new LinkedList<int []>();
        que.add(new int[] {0, 0});
        que.add(new int[] {1, 0});
        while(!que.isEmpty()){
            int [] cur = que.poll();
            int row = cur[0];
            int i = cur[1];
            for(int nei : graph[row][i]){
                if(res[1-row][nei] == Integer.MAX_VALUE){
                    res[1-row][nei] = res[row][i]+1;
                    que.add(new int[]{1-row, nei});
                }
            }
        }
        
        int [] resArr = new int[n];
        for(int i = 0; i<n; i++){
            int min = Math.min(res[0][i], res[1][i]);
            resArr[i] = min == Integer.MAX_VALUE ? -1 : min;
        }
        
        return resArr;
    }
}