Jump Game IV

Jump Game IV - Problem

Given an array of integers arr, you are initially positioned at the first index of the array.

In one step you can jump from index i to index:

i + 1 where: i + 1 < arr.length.
i - 1 where: i - 1 >= 0.
j where: arr[i] == arr[j] and i != j.

Return the minimum number of steps to reach the last index of the array.

Notice that you can not jump outside of the array at any time.

Input & Output

Example 1 — Basic Teleportation

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

› Output: 3

💡 Note: Start at index 0 (100) → Jump to index 4 (same value 100) → Jump to index 5 (23) → Jump to index 9 (404, last index). Total: 3 steps.

Example 2 — Adjacent Jumps

$ Input: arr = [7]

› Output: 0

💡 Note: Already at the last index, so 0 steps needed.

Example 3 — Mixed Strategy

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

› Output: 1

💡 Note: Start at index 0 (7) → Jump directly to index 7 (same value 7, which is the last index). Total: 1 step.

Constraints

1 ≤ arr.length ≤ 5 × 10⁴
-10⁸ ≤ arr[i] ≤ 10⁸

Visualization

Tap to expand

Asked in

f Facebook 15 a Amazon 12 G Google 8 M Microsoft 6

The key insight is to use BFS for guaranteed minimum steps while preprocessing values into a map for O(1) teleportation lookups. The optimal approach uses BFS with value mapping achieving O(n) time and O(n) space complexity.

Common Approaches

✓ BFS with Value Mapping

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

Optimize BFS by preprocessing the array to create a map from values to their indices. This eliminates the need to scan the entire array for same-value indices during BFS traversal.

Breadth-First Search

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

Use BFS to explore positions level by level, ensuring we find the minimum number of steps. For each position, try all possible jumps and add unvisited positions to the queue.

DFS with Memoization

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

Use depth-first search to explore all possible paths from current index to the end. Try jumping left, right, or to any index with the same value. Memoize results to avoid recomputation.

BFS with Value Mapping — Algorithm Steps

Build map from values to indices
Use BFS with the value map
Clear mapped indices after first use to prevent cycles
Return minimum steps to reach last index

Visualization

Tap to expand

Step-by-Step Walkthrough

Preprocess

Map each value to all its indices

BFS with Map

Use map for instant same-value jumps

Clear Used

Prevent revisiting same-value groups

Code -

solution.c — C

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

#define MAX_SIZE 50000
#define HASH_SIZE 10007

struct QueueNode {
    int idx;
    int steps;
};

struct HashNode {
    int value;
    int indices[MAX_SIZE];
    int count;
    int used;
    struct HashNode* next;
};

static struct HashNode* hashTable[HASH_SIZE];
static struct QueueNode queue[MAX_SIZE];
static int visited[MAX_SIZE];

int hash(int val) {
    long long v = (long long)val;
    if (v < 0) v = -v;
    return (int)(v % HASH_SIZE);
}

void addToHash(int val, int idx) {
    int h = hash(val);
    struct HashNode* node = hashTable[h];
    
    while (node) {
        if (node->value == val) {
            node->indices[node->count++] = idx;
            return;
        }
        node = node->next;
    }
    
    node = (struct HashNode*)malloc(sizeof(struct HashNode));
    node->value = val;
    node->indices[0] = idx;
    node->count = 1;
    node->used = 0;
    node->next = hashTable[h];
    hashTable[h] = node;
}

struct HashNode* findHash(int val) {
    int h = hash(val);
    struct HashNode* node = hashTable[h];
    
    while (node) {
        if (node->value == val && !node->used) {
            return node;
        }
        node = node->next;
    }
    return NULL;
}

int solution(int* arr, int n) {
    if (n <= 1) return 0;
    
    // Initialize hash table and visited array
    for (int i = 0; i < HASH_SIZE; i++) {
        hashTable[i] = NULL;
    }
    for (int i = 0; i < n; i++) {
        visited[i] = 0;
    }
    
    // Build value to indices mapping
    for (int i = 0; i < n; i++) {
        addToHash(arr[i], i);
    }
    
    int front = 0, rear = 0;
    
    queue[rear].idx = 0;
    queue[rear].steps = 0;
    rear++;
    visited[0] = 1;
    
    while (front < rear) {
        struct QueueNode curr = queue[front++];
        int idx = curr.idx;
        int steps = curr.steps;
        
        if (idx == n - 1) {
            return steps;
        }
        
        // Try adjacent moves
        int adjacent[] = {idx - 1, idx + 1};
        for (int i = 0; i < 2; i++) {
            int nextIdx = adjacent[i];
            if (nextIdx >= 0 && nextIdx < n && !visited[nextIdx]) {
                visited[nextIdx] = 1;
                queue[rear].idx = nextIdx;
                queue[rear].steps = steps + 1;
                rear++;
            }
        }
        
        // Try same value jumps
        struct HashNode* node = findHash(arr[idx]);
        if (node) {
            for (int i = 0; i < node->count; i++) {
                int nextIdx = node->indices[i];
                if (!visited[nextIdx]) {
                    visited[nextIdx] = 1;
                    queue[rear].idx = nextIdx;
                    queue[rear].steps = steps + 1;
                    rear++;
                }
            }
            node->used = 1; // Mark as used to avoid revisiting
        }
    }
    
    return -1;
}

int main() {
    char line[200000];
    if (fgets(line, sizeof(line), stdin) == NULL) {
        return 1;
    }
    
    // Remove newline
    int len = strlen(line);
    if (len > 0 && line[len-1] == '\n') {
        line[len-1] = '\0';
        len--;
    }
    
    // Handle empty array
    if (strcmp(line, "[]") == 0) {
        printf("0\n");
        return 0;
    }
    
    // Parse array manually
    int arr[MAX_SIZE];
    int n = 0;
    int i = 0;
    int num = 0;
    int negative = 0;
    int in_number = 0;
    
    while (i < len) {
        char c = line[i];
        if (c >= '0' && c <= '9') {
            if (!in_number) {
                in_number = 1;
                num = 0;
            }
            num = num * 10 + (c - '0');
        } else if (c == '-') {
            negative = 1;
            in_number = 1;
            num = 0;
        } else if ((c == ',' || c == ']') && in_number) {
            if (negative) {
                num = -num;
                negative = 0;
            }
            arr[n++] = num;
            in_number = 0;
        }
        i++;
    }
    
    int result = solution(arr, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each index is visited at most once, and value lookups are O(1) amortized

⚠ Quadratic Growth

Space Complexity

O(n)

Value-to-indices map, queue, and visited set each store up to n elements

⚡ Linearithmic Space

67.0K Views

Medium 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 Value Mapping — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler