Shortest Path with Alternating Colors - Practice Coding Problems

Shortest Path with Alternating Colors - Problem

Imagine you're navigating through a city where every street is painted either red or blue, and you must follow a special traffic rule: you can only alternate between red and blue streets!

Given a directed graph with n nodes (labeled 0 to n-1), you have two types of edges:

Red edges: represented by redEdges[i] = [from, to]
Blue edges: represented by blueEdges[i] = [from, to]

Your mission is to find the shortest alternating path from node 0 to every other node. An alternating path means you must switch between red and blue edges at each step.

Goal: Return an array where answer[i] is the shortest path length from node 0 to node i following the alternating color rule, or -1 if impossible.

Input & Output

example_1.py — Basic Alternating Path

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

› Output: [0,1,-1]

💡 Note: Node 0 is at distance 0. We can reach node 1 via red edge (distance 1). Node 2 cannot be reached because we need a blue edge from node 1, but none exists.

example_2.py — Multiple Paths Available

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

› Output: [0,-1,-1]

💡 Note: Only node 0 is reachable. Node 1 requires alternating colors but we can't reach it from 0 with proper alternation. Node 2 has no incoming edges from reachable nodes.

example_3.py — Complex Graph with Alternating Paths

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

› Output: [0,1,2]

💡 Note: Node 0 at distance 0. Reach node 1 via red edge (distance 1). Then reach node 2 via blue edge from node 1 (distance 2). Perfect alternating pattern: red → blue.

Constraints

1 ≤ n ≤ 100
0 ≤ redEdges.length, blueEdges.length ≤ 400
redEdges[i].length == blueEdges[i].length == 2
0 ≤ a_i, b_i, u_j, v_j < n
Self-loops and parallel edges are allowed

Visualization

Tap to expand

0 (start)🏬 Node 1: 1 (red street)🏪 Node 2: 1 (blue street)🏛️ Node 3: 2 (alternating)🏨 Node 4: 3 (alternating)⚡ Algorithm1. BFS from node 02. Track (node, color)3. Alternate edge colors4. Level-by-level search⏱️ O(V + E) time

Understanding the Visualization

Start Your Journey

Begin at city center (node 0) with option to take either red or blue street first

Follow Alternating Pattern

From each intersection, you can only take streets of opposite color to the one you just used

BFS Exploration

Like spreading ripples, explore all reachable intersections level by level

Track Shortest Routes

Record the shortest path to each destination following the alternating rule

Key Takeaway

🎯 Key Insight: By treating (node, last_edge_color) as our state space, we transform the alternating constraint into a standard shortest path problem that BFS can solve optimally in O(V + E) time.

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 18

The optimal solution uses BFS with state tracking to find shortest alternating paths. Key insight: track both the current node and the color of the last edge used as state, ensuring we explore paths level-by-level while maintaining the alternating color constraint. Time complexity: O(V + E).

Common Approaches

Approach	Time	Space	Notes
✓ BFS with State Tracking (Optimal)	O(V + E)	O(V + E)	Use BFS to find shortest alternating paths by tracking node and last edge color
DFS with State Tracking (Brute Force)	O(2^(E+V))	O(V)	Use DFS to explore all possible alternating paths

BFS with State Tracking (Optimal) — Algorithm Steps

Build separate adjacency lists for red and blue edges
Initialize BFS queue with starting states: (node=0, lastColor=RED) and (node=0, lastColor=BLUE)
Use visited set to track (node, color) pairs to avoid revisiting same state
For each state, explore neighbors using only edges of opposite color
Update result array when reaching a node for the first time
Continue until queue is empty

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Start with node 0 in both red and blue states

Level 1

Explore immediate neighbors, alternating colors

Level 2

Continue to next level, maintaining color alternation

Track Visited States

Remember (node, color) to avoid revisiting

Code -

solution.c — C

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

#define MAX_NODES 100
#define MAX_QUEUE 10000

typedef struct {
    int nodes[MAX_NODES];
    int size;
} AdjList;

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

int* shortestAlternatingPaths(int n, int** redEdges, int redEdgesSize, int* redEdgesColSize, int** blueEdges, int blueEdgesSize, int* blueEdgesColSize, int* returnSize) {
    *returnSize = n;
    
    // Build adjacency lists
    AdjList redGraph[MAX_NODES], blueGraph[MAX_NODES];
    for (int i = 0; i < n; i++) {
        redGraph[i].size = 0;
        blueGraph[i].size = 0;
    }
    
    for (int i = 0; i < redEdgesSize; i++) {
        int u = redEdges[i][0], v = redEdges[i][1];
        redGraph[u].nodes[redGraph[u].size++] = v;
    }
    
    for (int i = 0; i < blueEdgesSize; i++) {
        int u = blueEdges[i][0], v = blueEdges[i][1];
        blueGraph[u].nodes[blueGraph[u].size++] = v;
    }
    
    // Initialize result
    int* result = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        result[i] = -1;
    }
    result[0] = 0;
    
    // BFS queue
    State queue[MAX_QUEUE];
    int front = 0, rear = 0;
    
    queue[rear++] = (State){0, 0, 0};
    queue[rear++] = (State){0, 1, 0};
    
    // Visited array: [node][color]
    int visited[MAX_NODES][2] = {0};
    visited[0][0] = visited[0][1] = 1;
    
    while (front < rear) {
        State current = queue[front++];
        int node = current.node;
        int lastColor = current.lastColor;
        int dist = current.dist;
        
        if (result[node] == -1 || dist < result[node]) {
            result[node] = dist;
        }
        
        // Try red edges if last wasn't red
        if (lastColor != 0) {
            for (int i = 0; i < redGraph[node].size; i++) {
                int neighbor = redGraph[node].nodes[i];
                if (!visited[neighbor][0]) {
                    visited[neighbor][0] = 1;
                    queue[rear++] = (State){neighbor, 0, dist + 1};
                }
            }
        }
        
        // Try blue edges if last wasn't blue
        if (lastColor != 1) {
            for (int i = 0; i < blueGraph[node].size; i++) {
                int neighbor = blueGraph[node].nodes[i];
                if (!visited[neighbor][1]) {
                    visited[neighbor][1] = 1;
                    queue[rear++] = (State){neighbor, 1, dist + 1};
                }
            }
        }
    }
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

We visit each edge at most twice (once for each color state) and each vertex at most twice

✓ Linear Growth

Space Complexity

O(V + E)

Space for adjacency lists, BFS queue, and visited set storing (node, color) pairs

✓ Linear Space

23.5K Views

Medium Frequency

~18 min Avg. Time

892 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 (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler