Jump Game IV - Practice Coding Problems

Jump Game IV - Problem

Jump Game IV presents an exciting array traversal challenge! You start at the first index of an integer array and need to reach the last index in the minimum number of steps.

From any position i, you have three movement options:
• Forward: Jump to i + 1 (if within bounds)
• Backward: Jump to i - 1 (if within bounds)
• Teleport: Jump to any index j where arr[i] == arr[j] and i != j

The teleportation ability makes this problem particularly interesting - you can instantly jump to any position with the same value! Your goal is to find the minimum number of steps to reach the final index.

Example: In array [100,-23,-23,404,100,23,23,23,3,404], you can reach the end in just 3 steps by strategically using teleportation!

Input & Output

example_1.py — Basic teleportation

$ Input: [100,-23,-23,404,100,23,23,23,3,404]

› Output: 3

💡 Note: Start at index 0 (value=100). Step 1: Teleport to index 4 (value=100). Step 2: Move to index 5 (value=23). Step 3: Teleport to index 7 (value=23). Step 4: Move to index 8 (value=3). Step 5: Move to index 9 (target). Actually, we can do better: Step 1: Teleport to index 4. Step 2: Move to index 3. Step 3: Teleport to index 9. Total: 3 steps.

example_2.py — Simple adjacent moves

$ Input: [7]

› Output: 0

💡 Note: Already at the target position (single element array), so 0 steps needed.

example_3.py — No teleportation needed

$ Input: [7,6,9,6,9,6,9,7]

› Output: 1

💡 Note: Start at index 0 (value=7). We can teleport directly to index 7 (the last index) since arr[0] == arr[7] == 7. This takes just 1 step.

Constraints

1 ≤ arr.length ≤ 5 × 10⁴
-10⁸ ≤ arr[i] ≤ 10⁸
All elements in the array are distinct OR there are many duplicates

Visualization

Tap to expand

Understanding the Visualization

Build Teleportation Map

Create a hash map where each value points to all its positions in the array

Start BFS from Position 0

Use a queue to explore positions level by level, guaranteeing minimum steps

Explore All Move Options

For each position, try: move left, move right, and teleport to same values

Prune Teleportation Options

After using all teleportation options for a value, clear the list to avoid cycles

Return When Target Reached

BFS guarantees the first time we reach the target is with minimum steps

Key Takeaway

🎯 Key Insight: BFS with teleportation pruning ensures O(n) complexity by visiting each position at most once!

Asked in

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

The optimal solution uses BFS with smart teleportation pruning. Key insight: after exploring all teleportation options for a value, clear that value's list to prevent revisiting. This achieves O(n) time complexity by ensuring each position is visited at most once, making it significantly faster than naive approaches.

Common Approaches

Approach	Time	Space	Notes
✓ BFS with Optimized Teleportation (Optimal)	O(n)	O(n)	Use BFS to find shortest path with smart teleportation pruning
Brute Force (DFS with Memoization)	O(n²)	O(n²)	Recursively try all possible moves with memoization to avoid recomputing

BFS with Optimized Teleportation (Optimal) — Algorithm Steps

Build a hash map of value -> list of indices for teleportation
Use BFS starting from index 0 with a queue of (position, steps)
For each position, try moving left, right, and teleporting
After exploring all teleportation options for a value, clear that value's list
Continue until reaching the last index

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize BFS

Start with queue containing position 0

Process level

For each position in current level, try all moves

Prune teleportation

Clear teleportation options after using them

Continue BFS

Move to next level until target is reached

Code -

solution.c — C

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

#define MAX_N 50000
#define MAX_VAL 100000

typedef struct {
    int data[MAX_N];
    int front, rear, size;
} Queue;

void initQueue(Queue* q) {
    q->front = 0;
    q->rear = -1;
    q->size = 0;
}

void enqueue(Queue* q, int val) {
    q->rear = (q->rear + 1) % MAX_N;
    q->data[q->rear] = val;
    q->size++;
}

int dequeue(Queue* q) {
    int val = q->data[q->front];
    q->front = (q->front + 1) % MAX_N;
    q->size--;
    return val;
}

typedef struct {
    int indices[MAX_N];
    int count;
} ValueGroup;

int minJumps(int* arr, int arrSize) {
    if (arrSize <= 1) return 0;
    if (arrSize == 2) return 1;
    
    int n = arrSize;
    ValueGroup graph[MAX_VAL * 2]; // Handle negative values
    memset(graph, 0, sizeof(graph));
    
    // Build graph
    for (int i = 0; i < n; i++) {
        int idx = arr[i] + MAX_VAL; // Offset for negative values
        graph[idx].indices[graph[idx].count++] = i;
    }
    
    // BFS
    Queue queue;
    initQueue(&queue);
    bool visited[MAX_N] = {false};
    
    enqueue(&queue, 0);
    visited[0] = true;
    int steps = 0;
    
    while (queue.size > 0) {
        int levelSize = queue.size;
        steps++;
        
        for (int i = 0; i < levelSize; i++) {
            int pos = dequeue(&queue);
            
            // Try adjacent moves
            int candidates[MAX_N];
            int candidateCount = 0;
            
            if (pos - 1 >= 0) candidates[candidateCount++] = pos - 1;
            if (pos + 1 < n) candidates[candidateCount++] = pos + 1;
            
            // Add teleportation options
            int valIdx = arr[pos] + MAX_VAL;
            for (int j = 0; j < graph[valIdx].count; j++) {
                candidates[candidateCount++] = graph[valIdx].indices[j];
            }
            
            // Process candidates
            for (int j = 0; j < candidateCount; j++) {
                int nextPos = candidates[j];
                if (nextPos == n - 1) {
                    return steps;
                }
                if (nextPos >= 0 && nextPos < n && !visited[nextPos]) {
                    visited[nextPos] = true;
                    enqueue(&queue, nextPos);
                }
            }
            
            // Clear teleportation options
            graph[valIdx].count = 0;
        }
    }
    
    return -1;
}

int main() {
    int nums[] = {100, -23, -23, 404, 100, 23, 23, 23, 3, 404};
    int size = sizeof(nums) / sizeof(nums[0]);
    
    printf("%d\n", minJumps(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each position is visited at most once due to BFS nature and teleportation pruning

✓ Linear Growth

Space Complexity

O(n)

Hash map stores indices and BFS queue stores at most O(n) positions

⚡ Linearithmic Space

38.2K Views

High Frequency

~25 min Avg. Time

1.5K 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 Optimized Teleportation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler