Minimum Jumps to Reach Home

Minimum Jumps to Reach Home - Problem

A bug starts at position 0 on the x-axis and wants to reach its home at position x.

The bug can move according to these rules:

Jump exactly a positions forward (to the right)
Jump exactly b positions backward (to the left)
Cannot jump backward twice in a row
Cannot jump to any forbidden positions
Cannot jump to negative positions

The bug may jump forward beyond its home, but it cannot go to negative positions.

Given an array forbidden where forbidden[i] means the bug cannot jump to position forbidden[i], and integers a, b, and x, return the minimum number of jumps needed for the bug to reach its home at position x. If impossible, return -1.

Input & Output

Example 1 — Basic Case

$ Input: forbidden = [14,4,18,1,15], a = 3, b = 15, x = 9

› Output: 3

💡 Note: Bug jumps: 0 → 3 → 6 → 9. Three forward jumps of size 3 each reach position 9.

Example 2 — Impossible Case

$ Input: forbidden = [8,3,16,6,12,20], a = 15, b = 13, x = 11

› Output: -1

💡 Note: Position 11 cannot be reached due to forbidden positions and jump constraints.

Example 3 — Single Jump

$ Input: forbidden = [1,6,2,14,5,17,4], a = 16, b = 9, x = 7

› Output: 2

💡 Note: Bug can jump: 0 → 16 → 7 (forward jump to 16, then backward jump to 7).

Constraints

1 ≤ forbidden.length ≤ 1000
1 ≤ a, b, forbidden[i] ≤ 2000
0 ≤ x ≤ 2000
All values in forbidden are distinct
Position x is not forbidden

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to use BFS while tracking both position and last move direction to enforce the consecutive backward jump rule. The optimal approach uses BFS with state (position, last_backward_flag) and bounds checking to find minimum jumps. Time: O(n), Space: O(n).

Common Approaches

✓ Breadth-First Search

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

Use BFS to explore all reachable positions level by level, ensuring we find the minimum number of jumps. Track both position and whether the last move was backward to enforce the consecutive backward jump rule.

Recursive Backtracking

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

Recursively explore all valid moves from current position, tracking whether the last move was backward to enforce the consecutive backward jump rule. Use memoization to avoid recomputing the same states.

Breadth-First Search — Algorithm Steps

Start BFS from position 0
For each position, try forward and backward jumps if valid
Track visited states as (position, last_backward_flag)
Return jumps when target is reached

Visualization

Tap to expand

Step-by-Step Walkthrough

Level 0

Start at position 0

Level 1

Explore all positions reachable in 1 jump

Level 2

Explore all positions reachable in 2 jumps

Code -

solution.c — C

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

#define MAX_QUEUE 100000
#define MAX_POS 6001
#define MAX_HASH 10007

typedef struct {
    int pos, lastBackward, jumps;
} State;

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

HashNode* hashTable[MAX_HASH];
int forbiddenSet[MAX_POS];

unsigned int hash(const char* str) {
    unsigned int hash = 5381;
    while (*str) hash = ((hash << 5) + hash) + *str++;
    return hash % MAX_HASH;
}

int isVisited(int pos, int lastBackward) {
    char key[20];
    sprintf(key, "%d,%d", pos, lastBackward);
    unsigned int h = hash(key);
    
    HashNode* node = hashTable[h];
    while (node) {
        if (strcmp(node->key, key) == 0) return 1;
        node = node->next;
    }
    return 0;
}

void addVisited(int pos, int lastBackward) {
    char key[20];
    sprintf(key, "%d,%d", pos, lastBackward);
    unsigned int h = hash(key);
    
    HashNode* node = malloc(sizeof(HashNode));
    strcpy(node->key, key);
    node->next = hashTable[h];
    hashTable[h] = node;
}

int solution(int* forbidden, int forbiddenSize, int a, int b, int x) {
    memset(forbiddenSet, 0, sizeof(forbiddenSet));
    memset(hashTable, 0, sizeof(hashTable));
    
    for (int i = 0; i < forbiddenSize; i++) {
        if (forbidden[i] < MAX_POS) forbiddenSet[forbidden[i]] = 1;
    }
    
    State queue[MAX_QUEUE];
    int front = 0, rear = 0;
    
    queue[rear++] = (State){0, 0, 0};
    addVisited(0, 0);
    
    while (front < rear) {
        State curr = queue[front++];
        
        if (curr.pos == x) return curr.jumps;
        
        // Forward jump
        int nextPos = curr.pos + a;
        if (nextPos <= 6000 && !forbiddenSet[nextPos] && !isVisited(nextPos, 0)) {
            addVisited(nextPos, 0);
            queue[rear++] = (State){nextPos, 0, curr.jumps + 1};
        }
        
        // Backward jump
        if (curr.lastBackward == 0) {
            nextPos = curr.pos - b;
            if (nextPos >= 0 && !forbiddenSet[nextPos] && !isVisited(nextPos, 1)) {
                addVisited(nextPos, 1);
                queue[rear++] = (State){nextPos, 1, curr.jumps + 1};
            }
        }
    }
    
    return -1;
}

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[10000];
    fgets(line, sizeof(line), stdin);
    
    int forbidden[1000];
    int forbiddenSize = 0;
    
    char* ptr = strchr(line, '[');
    if (ptr && ptr[1] != ']') {
        ptr++;
        char* token = strtok(ptr, ",]");
        while (token && forbiddenSize < 1000) {
            forbidden[forbiddenSize++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    int a, b, x;
    scanf("%d %d %d", &a, &b, &x);
    
    printf("%d\n", solution(forbidden, forbiddenSize, a, b, x));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each position is visited at most twice (with different last move states), bounded by maximum reachable position

✓ Linear Growth

Space Complexity

O(n)

Queue and visited set store positions and states up to the maximum bound

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~35 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

Breadth-First Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler