Shortest Path with Alternating Colors

Shortest Path with Alternating Colors - Problem

You are given an integer n, the number of nodes in a directed graph where the nodes are labeled from 0 to n - 1. Each edge is red or blue in this graph, and there could be self-edges and parallel edges.

You are given two arrays redEdges and blueEdges where:

redEdges[i] = [a_i, b_i] indicates that there is a directed red edge from node a_i to node b_i in the graph
blueEdges[j] = [u_j, v_j] indicates that there is a directed blue edge from node u_j to node v_j in the graph

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 does not exist.

Input & Output

Example 1 — Basic Alternating Path

$ Input: n = 3, redEdges = [[0,1],[1,2]], blueEdges = []

› Output: [0,1,-1]

💡 Note: From node 0: reach node 1 via red edge (distance 1), cannot reach node 2 (would need blue edge after red, but no blue edges exist)

Example 2 — Multiple Alternating Paths

$ Input: n = 3, redEdges = [[0,1]], blueEdges = [[1,2]]

› Output: [0,1,2]

💡 Note: From node 0: reach node 1 via red edge (distance 1), reach node 2 via red then blue edge (distance 2, colors alternate properly)

Example 3 — Complex Graph with Multiple Options

$ Input: n = 3, redEdges = [[0,1],[0,2]], blueEdges = [[1,0]]

› Output: [0,1,1]

💡 Note: From node 0: direct red edges to nodes 1 and 2 (both distance 1). Node 1 can be reached via 0→1 (red), and node 2 can be reached via 0→2 (red). The blue edge from 1 to 0 creates a cycle but doesn't provide shorter paths to new nodes.

Constraints

1 ≤ n ≤ 100
0 ≤ redEdges.length, blueEdges.length ≤ 400
redEdges[i].length == blueEdges[j].length == 2
0 ≤ a_i, b_i, u_j, v_j < n

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to use BFS with state tracking where each state represents (node, last_edge_color) to ensure alternating colors. Best approach is BFS with State Tracking for guaranteed shortest paths. Time: O(V+E), Space: O(V)

Common Approaches

✓ BFS with State Tracking

⏱️ Time: O(V + E) Space: O(V)

Breadth-first search naturally finds shortest paths. Track states as (node, last_color) to ensure alternation. Each state represents being at a node after using a specific color edge.

DFS with Backtracking

⏱️ Time: O(2^(E+V)) Space: O(V)

Use depth-first search to explore all possible paths from node 0 to each target node, ensuring edge colors alternate. Track the minimum path length found for each destination.

BFS with State Tracking — Algorithm Steps

Start BFS from node 0 with both red and blue initial states
For each state, explore neighbors using opposite color edges
Track minimum distance to reach each node
Return distances array

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start BFS queue with node 0, track (node, lastColor)

Explore Level

For each state, try edges of opposite color

Update Distances

First time reaching a node gives shortest distance

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#define MAX_N 100
#define MAX_QUEUE 10000
#define MAX_EDGES 400
#define INF 1000000

typedef struct {
    int node;
    int lastColor;
    int dist;
} State;

static int redGraph[MAX_N][MAX_EDGES], blueGraph[MAX_N][MAX_EDGES];
static int redCount[MAX_N], blueCount[MAX_N];
static int distTable[MAX_N][3]; // [node][color] where color: 0=red, 1=blue, 2=start

int parseEdges(const char* str, int edges[][2]) {
    int count = 0;
    if (strcmp(str, "[]") == 0) return 0;
    
    int len = strlen(str);
    int i = 1; // Skip opening '['
    
    while (i < len - 1) { // Skip closing ']'
        if (str[i] == '[') {
            int a = 0, b = 0;
            i++; // Skip '['
            
            // Parse first number
            while (str[i] >= '0' && str[i] <= '9') {
                a = a * 10 + (str[i] - '0');
                i++;
            }
            i++; // Skip ','
            
            // Parse second number
            while (str[i] >= '0' && str[i] <= '9') {
                b = b * 10 + (str[i] - '0');
                i++;
            }
            
            edges[count][0] = a;
            edges[count][1] = b;
            count++;
            
            i++; // Skip ']'
            if (str[i] == ',') i++; // Skip comma between pairs
        } else {
            i++;
        }
    }
    
    return count;
}

int* solution(int n, int redEdges[][2], int redEdgesSize, int blueEdges[][2], int blueEdgesSize) {
    // Initialize
    memset(redCount, 0, sizeof(redCount));
    memset(blueCount, 0, sizeof(blueCount));
    
    // Initialize distance table
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < 3; j++) {
            distTable[i][j] = INF;
        }
    }
    
    // Build graphs
    for (int i = 0; i < redEdgesSize; i++) {
        int u = redEdges[i][0];
        int v = redEdges[i][1];
        redGraph[u][redCount[u]++] = v;
    }
    
    for (int i = 0; i < blueEdgesSize; i++) {
        int u = blueEdges[i][0];
        int v = blueEdges[i][1];
        blueGraph[u][blueCount[u]++] = v;
    }
    
    // BFS
    State queue[MAX_QUEUE];
    int front = 0, rear = 0;
    
    queue[rear++] = (State){0, 2, 0}; // Use 2 for start state
    distTable[0][2] = 0;
    
    int* result = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        result[i] = -1;
    }
    result[0] = 0;
    
    while (front < rear) {
        State current = queue[front++];
        
        // Skip if we've found a shorter path to this state
        if (current.dist > distTable[current.node][current.lastColor]) {
            continue;
        }
        
        // Try red edges (color 0)
        if (current.lastColor != 0) {
            for (int i = 0; i < redCount[current.node]; i++) {
                int neighbor = redGraph[current.node][i];
                int newDist = current.dist + 1;
                if (newDist < distTable[neighbor][0]) {
                    distTable[neighbor][0] = newDist;
                    if (result[neighbor] == -1 || newDist < result[neighbor]) {
                        result[neighbor] = newDist;
                    }
                    queue[rear++] = (State){neighbor, 0, newDist};
                }
            }
        }
        
        // Try blue edges (color 1)
        if (current.lastColor != 1) {
            for (int i = 0; i < blueCount[current.node]; i++) {
                int neighbor = blueGraph[current.node][i];
                int newDist = current.dist + 1;
                if (newDist < distTable[neighbor][1]) {
                    distTable[neighbor][1] = newDist;
                    if (result[neighbor] == -1 || newDist < result[neighbor]) {
                        result[neighbor] = newDist;
                    }
                    queue[rear++] = (State){neighbor, 1, newDist};
                }
            }
        }
    }
    
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    getchar(); // consume newline
    
    char line[10000];
    
    // Read red edges
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0; // remove newline
    int redEdges[MAX_EDGES][2];
    int redEdgesSize = parseEdges(line, redEdges);
    
    // Read blue edges
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0; // remove newline
    int blueEdges[MAX_EDGES][2];
    int blueEdgesSize = parseEdges(line, blueEdges);
    
    int* result = solution(n, redEdges, redEdgesSize, blueEdges, blueEdgesSize);
    
    printf("[");
    for (int i = 0; i < n; i++) {
        printf("%d", result[i]);
        if (i < n - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

BFS visits each node-color state at most once, processes each edge once

✓ Linear Growth

Space Complexity

O(V)

Queue stores at most O(V) states, visited array and result array each O(V)

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

856 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

BFS with State Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler