Codestin Search App

Jump Game II - Problem

Imagine you're playing a platformer game where you need to reach the end of a level in the minimum number of jumps! 🎮

You start at position 0 of an array nums with n elements. Each element nums[i] represents the maximum jump distance you can make from that position. From index i, you can jump to any index j where i < j ≤ i + nums[i].

Your mission: Find the minimum number of jumps needed to reach the last index (n-1).

Example: If nums = [2,3,1,1,4], you can jump from index 0 to index 1 (jump distance 1), then from index 1 to index 4 (jump distance 3). That's just 2 jumps to reach the end!

⚡ Good news: The test cases guarantee that you can always reach the end, so focus on finding the optimal path!

Input & Output

example_1.py — Python

$ Input: nums = [2,3,1,1,4]

› Output: 2

💡 Note: The minimum number of jumps to reach the last index is 2. Jump 1 step from index 0 to 1, then 3 steps to the last index. Path: 0 → 1 → 4

example_2.py — Python

$ Input: nums = [2,3,0,1,4]

› Output: 2

💡 Note: Still need 2 jumps. From index 0, jump 2 steps to index 2, then jump 2 steps to reach index 4 (the last index). Path: 0 → 2 → 4

example_3.py — Python

$ Input: nums = [1,1,1,1]

› Output: 3

💡 Note: Each element only allows 1 step jumps, so we need 3 jumps to go from index 0 to index 3. Path: 0 → 1 → 2 → 3

Constraints

1 ≤ nums.length ≤ 10⁴
0 ≤ nums[i] ≤ 1000
It's guaranteed that you can reach nums[n - 1]

Visualization

Tap to expand

Understanding the Visualization

Level 0: Starting Island

Begin at island 0, can reach islands within range of current launcher

Level 1: First Jump

After 1 jump, determine all islands reachable. Track the farthest possible.

Level 2: Second Jump

When we must make a second jump, update our reachable range again

Optimal Path Found

Continue until treasure island is within reach

Key Takeaway

🎯 Key Insight: Instead of exploring every possible jump path, the greedy approach tracks reachable boundaries level by level, guaranteeing the minimum number of jumps!

Asked in

G Google 67 a Amazon 54 f Meta 43 ⊞ Microsoft 38 Apple 29

The optimal solution uses a greedy BFS-like approach that processes the array in "jump levels". Instead of trying every possible jump, we track the farthest reachable position at each level and only increment the jump count when we must move to the next level. This achieves O(n) time complexity with O(1) space - much better than the recursive approach!

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Recursion with Memoization	O(n²)	O(n)	Try all possible jumps from each position recursively
Greedy BFS Approach (Optimal)	O(n)	O(1)	Use BFS-like greedy strategy to find minimum jumps level by level

Brute Force Recursion with Memoization — Algorithm Steps

Start from position 0 with 0 jumps
For each position, try all possible jump distances (1 to nums[i])
Recursively calculate minimum jumps for each reachable position
Use memoization to store results for visited positions
Return the minimum jumps among all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at index 0

Begin with position 0 and explore all possible jumps

Try all jump sizes

For each position, try jumping 1, 2, ... up to nums[i] steps

Recursive exploration

Recursively solve subproblems for each reachable position

Memoization

Store results to avoid recalculating the same position

Code -

solution.c — C

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

#define MAX_SIZE 10000

int memo[MAX_SIZE];
int* nums_global;
int n_global;

int dfs(int pos) {
    if (pos >= n_global - 1) return 0;
    if (memo[pos] != -1) return memo[pos];
    
    int minJumps = INT_MAX;
    for (int jumpSize = 1; jumpSize <= nums_global[pos]; jumpSize++) {
        int nextPos = pos + jumpSize;
        if (nextPos < n_global) {
            int jumps = 1 + dfs(nextPos);
            if (jumps < minJumps) {
                minJumps = jumps;
            }
        }
    }
    
    return memo[pos] = minJumps;
}

int jump(int* nums, int numsSize) {
    if (numsSize <= 1) return 0;
    
    nums_global = nums;
    n_global = numsSize;
    memset(memo, -1, sizeof(memo));
    
    return dfs(0);
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int nums[MAX_SIZE];
    int count = 0;
    char* token = strtok(input, "[],\n ");
    while (token != NULL && count < MAX_SIZE) {
        nums[count++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", jump(nums, count));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we might visit each position multiple times, and for each position we try up to n jumps

⚠ Quadratic Growth

Space Complexity

O(n)

Space for memoization array and recursion stack depth

⚡ Linearithmic Space

42.5K Views

High Frequency

~25 min Avg. Time

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

Brute Force Recursion with Memoization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler