Minimum Sideway Jumps

Minimum Sideway Jumps - Problem

Imagine a 3-lane highway stretching from point 0 to point n, where a clever frog needs to navigate from the starting position to the end while avoiding obstacles!

🐸 The Setup: Our frog begins at point 0 in lane 2 (the middle lane) and wants to reach point n. The road has obstacles scattered along the way - but here's the catch: the frog can jump sideways to any other lane at the same point to avoid obstacles!

The Rules:

The frog moves forward one point at a time in the same lane
If there's an obstacle ahead, the frog can perform a sideways jump to switch lanes
Sideways jumps can go to any available lane (even non-adjacent ones!)
Each sideways jump costs 1 point

Your Mission: Find the minimum number of sideways jumps needed to reach the destination!

obstacles[i] tells you which lane (1, 2, or 3) has an obstacle at point i, or 0 if no obstacles exist at that point.

Input & Output

example_1.py — Basic Path Navigation

$ Input: obstacles = [0,1,2,3,0]

› Output: 2

💡 Note: The frog starts at lane 2. At point 1 there's an obstacle in lane 1, at point 2 obstacle in lane 2, at point 3 obstacle in lane 3. Optimal path: Stay in lane 2 → Jump to lane 3 (1st jump) → Jump to lane 2 (2nd jump) → Reach end. Total: 2 jumps.

example_2.py — Minimal Jumps

$ Input: obstacles = [0,1,1,3,3,0]

› Output: 0

💡 Note: The frog can stay in lane 2 throughout the entire journey without any sideways jumps, as lane 2 never has obstacles in this configuration.

example_3.py — Strategic Planning

$ Input: obstacles = [0,2,1,0,3,0]

› Output: 2

💡 Note: Starting in lane 2, there's an obstacle at point 1. Jump to lane 1 or 3 (1st jump). At point 2, obstacle in lane 1, so if we were in lane 1, jump to lane 2 or 3 (2nd jump). Optimal strategy requires 2 total jumps.

Constraints

obstacles.length == n + 1
1 ≤ n ≤ 5 × 10⁵
0 ≤ obstacles[i] ≤ 3
obstacles[0] == obstacles[n] == 0 (no obstacles at start and end)

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal approach uses bottom-up dynamic programming with O(n) time and O(1) space complexity. We maintain the minimum jumps needed to reach each lane at the current position, updating these values as we progress through each point while considering staying in the same lane versus jumping to avoid obstacles.

Common Approaches

✓ Bottom-Up Dynamic Programming (Optimal)

⏱️ Time: O(n) Space: O(1)

Use iterative dynamic programming where dp[i][j] represents minimum jumps to reach lane j at position i. Build solution progressively from position 0 to n.

Brute Force Recursion

⏱️ Time: O(3^n) Space: O(n)

Explore every possible combination of staying in current lane or jumping to other lanes at each point. This creates a tree of possibilities where we recursively try all valid moves.

Memoized Dynamic Programming

⏱️ Time: O(n) Space: O(n)

Enhance the recursive approach by storing results of subproblems. Use a 2D memoization table where memo[pos][lane] stores the minimum jumps needed from position pos in lane.

Bottom-Up Dynamic Programming (Optimal) — Algorithm Steps

Initialize dp array where dp[0][2] = 0 (start at lane 2)
For each position, calculate minimum jumps for each lane
Consider staying in same lane (if no obstacle)
Consider jumping from other lanes (with +1 jump cost)
Take minimum among all valid options

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set initial state: dp = [1, 0, 1]

Forward Pass

For each position, update DP values based on obstacles

Final Answer

Return minimum value from final DP state

Code -

solution.c — C

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

int minSideJumps(int* obstacles, int size) {
    int n = size - 1;
    
    int dp[3] = {1, 0, 1};
    
    for (int i = 1; i <= n; i++) {
        int new_dp[3] = {1000000, 1000000, 1000000};
        
        for (int lane = 0; lane < 3; lane++) {
            if (obstacles[i] != lane + 1) {
                // Try coming from same lane (if no obstacle at previous position)
                if (obstacles[i-1] != lane + 1) {
                    if (dp[lane] < new_dp[lane]) {
                        new_dp[lane] = dp[lane];
                    }
                }
                
                // Try jumping from other lanes (cost +1)
                for (int from_lane = 0; from_lane < 3; from_lane++) {
                    if (from_lane != lane && obstacles[i-1] != from_lane + 1) {
                        if (dp[from_lane] + 1 < new_dp[lane]) {
                            new_dp[lane] = dp[from_lane] + 1;
                        }
                    }
                }
            }
        }
        
        memcpy(dp, new_dp, sizeof(dp));
    }
    
    int minVal = dp[0];
    if (dp[1] < minVal) minVal = dp[1];
    if (dp[2] < minVal) minVal = dp[2];
    return minVal;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int obstacles[500];
    int size = 0;
    parseArray(line, obstacles, &size);
    
    printf("%d\n", minSideJumps(obstacles, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through n positions, constant work per position (3 lanes)

✓ Linear Growth

Space Complexity

O(1)

Only need current and previous position states (can optimize to O(1))

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

1.2K 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

Bottom-Up Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler