Maximum Number of Jumps to Reach the Last Index

Maximum Number of Jumps to Reach the Last Index - Problem

Imagine you're on a magical stepping stone path across a river! 🌊 You start at the first stone (index 0) and need to reach the last stone (index n-1) to complete your journey.

Here's the twist: each stone has a magical number on it, and you can only jump from stone i to stone j if:

You're jumping forward: i < j
The magical numbers are similar enough: |nums[j] - nums[i]| <= target

Your goal is to find the maximum number of jumps you can make to reach the final stone. If it's impossible to reach the end, return -1.

Example: With stones [1, 3, 6, 4, 1, 2] and target = 2, you could jump: 0→1→3→5 (3 jumps) or 0→2→4→5 (3 jumps).

Input & Output

example_1.py — Basic Path Finding

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

› Output: 3

💡 Note: One optimal path is 0→1→3→5: jump from index 0 to 1 (|3-1|=2≤2), then 1 to 3 (|4-3|=1≤2), then 3 to 5 (|2-4|=2≤2). This gives us 3 jumps total.

example_2.py — No Valid Path

$ Input: nums = [1, 0, 2], target = 0

› Output: -1

💡 Note: From index 0 (value=1), we cannot jump to index 1 (value=0) because |0-1|=1 > 0. We also cannot jump to index 2 (value=2) because |2-1|=1 > 0. No path exists.

example_3.py — Single Jump

$ Input: nums = [1, 3], target = 5

› Output: 1

💡 Note: We can jump directly from index 0 to index 1 because |3-1|=2≤5. This requires exactly 1 jump, which is optimal since we need to reach the last index.

Constraints

1 ≤ nums.length ≤ 1000
0 ≤ nums[i] ≤ 10⁵
0 ≤ target ≤ 2 × 10⁵
Must jump forward only: i < j for valid jumps
Jump constraint: |nums[j] - nums[i]| ≤ target

Visualization

Tap to expand

Understanding the Visualization

Start at first stone

Begin your journey at stone 0 with nums[0] = 1

Find valid jumps

Look for stones you can jump to: |destination_value - current_value| ≤ target

Choose optimal path

Instead of the shortest path, choose the path with maximum jumps

Reach the end

Successfully arrive at the final stone with maximum scenic stops

Key Takeaway

🎯 Key Insight: This problem asks for the *maximum* number of jumps (longest path), not the minimum. We use DP to track the maximum jumps to reach each position, building up the solution iteratively.

Asked in

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

This problem is optimally solved using Dynamic Programming in O(n²) time. We maintain a DP array where dp[i] represents the maximum jumps to reach position i. For each reachable position, we try jumping to all valid future positions and update their maximum jump counts. The key insight is that we want to maximize jumps rather than minimize them, making this a longest path problem in a directed graph.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Bottom-Up)	O(n²)	O(n)	Build solution iteratively using dynamic programming table

Dynamic Programming (Bottom-Up) — Algorithm Steps

Initialize DP array with -1 (unreachable) and dp[0] = 0
For each position i from 0 to n-2
If position i is reachable (dp[i] != -1)
Try jumping to all valid positions j > i
Update dp[j] = max(dp[j], dp[i] + 1)
Return dp[n-1]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP array

Set dp[0] = 0, all others to -1 (unreachable)

Process each position

For each reachable position, update all valid jump destinations

Update maximum jumps

dp[j] = max(dp[j], dp[i] + 1) for valid jumps from i to j

Return final result

dp[n-1] contains the maximum jumps to reach the end

Code -

solution.c — C

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

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int max(int a, int b) {
    return a > b ? a : b;
}

int maximumJumps(int* nums, int numsSize, int target) {
    int* dp = (int*)malloc(numsSize * sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        dp[i] = -1;
    }
    dp[0] = 0; // Starting position requires 0 jumps
    
    for (int i = 0; i < numsSize - 1; i++) {
        if (dp[i] == -1) { // Position i is not reachable
            continue;
        }
        
        for (int j = i + 1; j < numsSize; j++) {
            if (abs_val(nums[j] - nums[i]) <= target) {
                dp[j] = max(dp[j], dp[i] + 1);
            }
        }
    }
    
    int result = dp[numsSize - 1];
    free(dp);
    return result;
}

int main() {
    int nums[] = {1, 3, 6, 4, 1, 2};
    int target = 2;
    int n = sizeof(nums) / sizeof(nums[0]);
    printf("%d\n", maximumJumps(nums, n, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops: outer loop O(n), inner loop O(n) in worst case

⚠ Quadratic Growth

Space Complexity

O(n)

DP array to store maximum jumps for each position

⚡ Linearithmic Space

42.8K Views

Medium Frequency

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

Dynamic Programming (Bottom-Up) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler