Jump Game V

Jump Game V - Problem

Given an array of integers arr and an integer d. In one step you can jump from index i to index:

i + x where: i + x < arr.length and 0 < x <= d.
i - x where: i - x >= 0 and 0 < x <= d.

In addition, you can only jump from index i to index j if arr[i] > arr[j] and arr[i] > arr[k] for all indices k between i and j (More formally min(i, j) < k < max(i, j)).

You can choose any index of the array and start jumping. Return the maximum number of indices you can visit.

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

Input & Output

Example 1 — Basic Case

$ Input: arr = [6,4,14,6,9], d = 2

› Output: 3

💡 Note: Start at index 2 (value 14): 14→6→4, visiting 3 indices. From 14 we can jump to positions with values 6,6,9 within distance 2. From 6 we can jump to 4.

Example 2 — Limited Jumps

$ Input: arr = [3,3,3,3,3], d = 3

› Output: 1

💡 Note: All values are equal, so no valid jumps possible since we need arr[i] > arr[j]. Can only visit 1 index.

Example 3 — Blocked Path

$ Input: arr = [2,6,4], d = 1

› Output: 2

💡 Note: From index 1 (value 6), can jump to index 0 (value 2) or index 2 (value 4). Maximum path is 2 indices.

Constraints

1 ≤ arr.length ≤ 1000
1 ≤ d ≤ arr.length
1 ≤ arr[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

f Facebook 45 G Google 38 a Amazon 32

The key insight is that this is a directed graph problem where we can only move from higher to lower values. The optimal approach uses topological sorting combined with dynamic programming, processing positions from highest to lowest value. Time: O(n × d), Space: O(n).

Common Approaches

✓ Brute Force DFS

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

For each starting position, use depth-first search to explore all valid jumping paths. A jump from i to j is valid if we can jump the distance, arr[i] > arr[j], and arr[i] is greater than all elements between i and j.

Memoized DFS

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

Same as brute force but we memoize the maximum path length from each position. This eliminates redundant calculations when multiple paths lead to the same position.

Topological Sort + DP

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

Sort positions by height in descending order and process them with dynamic programming. This ensures when we process a position, all positions we can jump to have already been computed.

Brute Force DFS — Algorithm Steps

Try starting from each index in the array
From each position, recursively try all valid jumps within distance d
For each potential jump, verify the height constraint and intermediate elements
Return the maximum path length found across all starting positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Try All Starts

Start DFS from each index

Explore Paths

For each position, try all valid jumps

Find Maximum

Return longest path found

Code -

solution.c — C

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

int arr[1000];
int dp[1000];
int indices[1000];
int n, d;

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

int min(int a, int b) {
    return a < b ? a : b;
}

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

int canJump(int i, int j) {
    if (abs(i - j) > d || arr[i] <= arr[j]) {
        return 0;
    }
    int start = min(i, j);
    int end = max(i, j);
    for (int k = start + 1; k < end; k++) {
        if (arr[k] >= arr[i]) {
            return 0;
        }
    }
    return 1;
}

int compare(const void* a, const void* b) {
    int ia = *(int*)a;
    int ib = *(int*)b;
    return arr[ib] - arr[ia];
}

int solution() {
    for (int i = 0; i < n; i++) {
        dp[i] = 1;
        indices[i] = i;
    }
    
    // Sort indices by height in descending order
    qsort(indices, n, sizeof(int), compare);
    
    // Process from highest to lowest
    for (int idx = 0; idx < n; idx++) {
        int i = indices[idx];
        for (int j = max(0, i - d); j <= min(n - 1, i + d); j++) {
            if (j != i && canJump(i, j)) {
                dp[i] = max(dp[i], 1 + dp[j]);
            }
        }
    }
    
    int result = 1;
    for (int i = 0; i < n; i++) {
        result = max(result, dp[i]);
    }
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    n = 0;
    char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        char* endp;
        arr[n++] = (int)strtol(p, &endp, 10);
        p = endp;
    }
    
    scanf("%d", &d);
    
    int result = solution();
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(d^n)

In worst case, from each position we try d jumps, leading to exponential branching

✓ Linear Growth

Space Complexity

O(n)

Recursion call stack can go up to n deep in worst case

⚡ Linearithmic Space

28.4K Views

Medium Frequency

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

Brute Force DFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler