Minimum Sideway Jumps - Practice Coding Problems

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

Point 0Point 1Point 2Point 3End
Point 4DP State Tracking• Track min jumps to reach each lane• Consider stay vs jump at each point🐸 Minimum Sideways Jumps = 2

Understanding the Visualization

Starting Position

Frog begins at point 0 in lane 2 (middle lane)

Obstacle Detection

At each point, check for obstacles in the next position

Decision Making

Choose to stay in current lane or jump to avoid obstacles

Optimal Path

DP ensures we always take the path with minimum jumps

Key Takeaway

🎯 Key Insight: Dynamic Programming tracks the minimum jumps needed to reach each lane at every position, making locally optimal decisions that lead to a globally optimal solution.

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

Approach	Time	Space	Notes
✓ Memoized Dynamic Programming	O(n)	O(n)	Cache results to avoid redundant calculations
Bottom-Up Dynamic Programming (Optimal)	O(n)	O(1)	Iteratively build solution from start to end using optimal substructure
Brute Force Recursion	O(3^n)	O(n)	Try all possible paths using recursion

Memoized Dynamic Programming — Algorithm Steps

Create a memoization table memo[pos][lane]
For each state (position, lane), check if already computed
If not computed, recursively solve and store result
Return cached result for future identical subproblems

Visualization

Tap to expand

Step-by-Step Walkthrough

First Computation

Calculate result for state (pos, lane)

Cache Result

Store result in memoization table

Cache Hit

Return cached result for repeated states

Code -

solution.c — C

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

#define HASH_SIZE 10007

typedef struct HashNode {
    char key[20];
    int value;
    struct HashNode* next;
} HashNode;

HashNode* hashTable[HASH_SIZE];

unsigned int hash(const char* key) {
    unsigned int hash = 5381;
    int c;
    while ((c = *key++))
        hash = ((hash << 5) + hash) + c;
    return hash % HASH_SIZE;
}

void insertHash(const char* key, int value) {
    unsigned int index = hash(key);
    HashNode* node = (HashNode*)malloc(sizeof(HashNode));
    strcpy(node->key, key);
    node->value = value;
    node->next = hashTable[index];
    hashTable[index] = node;
}

int getHash(const char* key) {
    unsigned int index = hash(key);
    HashNode* node = hashTable[index];
    while (node) {
        if (strcmp(node->key, key) == 0) {
            return node->value;
        }
        node = node->next;
    }
    return -1;
}

int dfs(int* obstacles, int pos, int lane, int n) {
    if (pos == n) return 0;
    
    char key[20];
    sprintf(key, "%d-%d", pos, lane);
    int cached = getHash(key);
    if (cached != -1) return cached;
    
    int minJumps = INT_MAX;
    
    // Try staying in current lane
    if (obstacles[pos + 1] != lane) {
        int result = dfs(obstacles, pos + 1, lane, n);
        if (result < minJumps) minJumps = result;
    }
    
    // Try jumping to other lanes
    for (int newLane = 1; newLane <= 3; newLane++) {
        if (newLane != lane && obstacles[pos] != newLane) {
            if (obstacles[pos + 1] != newLane) {
                int result = 1 + dfs(obstacles, pos + 1, newLane, n);
                if (result < minJumps) minJumps = result;
            }
        }
    }
    
    insertHash(key, minJumps);
    return minJumps;
}

int minSideJumps(int* obstacles, int size) {
    memset(hashTable, 0, sizeof(hashTable));
    int n = size - 1;
    return dfs(obstacles, 0, 2, n);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int obstacles[500];
    int size = 0;
    char* token = strtok(line, "[],");
    while (token != NULL) {
        obstacles[size++] = atoi(token);
        token = strtok(NULL, "[],");
    }
    
    printf("%d\n", minSideJumps(obstacles, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each state (pos, lane) is computed at most once, and there are 3n total states

✓ Linear Growth

Space Complexity

O(n)

Memoization table of size n×3 plus recursion stack depth n

⚡ Linearithmic 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

Memoized Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler