Jump Game V - Practice Coding Problems

Jump Game V - Problem

Welcome to the Mountain Hopping Challenge! 🏔️

You are a skilled mountain climber standing on an array of peaks, where each element arr[i] represents the height of the i-th mountain. You have a special jumping ability that allows you to leap up to d positions in either direction.

The Rules:

You can jump from index i to any index j where |i - j| ≤ d
You can only jump downward: arr[i] > arr[j]
Your path must be clear: all peaks between your starting and landing positions must be shorter than your starting peak

Your goal is to find the maximum number of peaks you can visit by choosing any starting position and making optimal jumps. Each position can only be visited once during your journey.

Example: Given arr = [6,4,14,6,8,13,9,7,10,6,12] and d = 2, you might start at the tallest peak (height 14) and visit multiple shorter peaks, maximizing your journey length.

Input & Output

basic_case.py — Python

$ Input: arr = [6,4,14,6,8,13,9,7,10,6,12], d = 2

› Output: 4

💡 Note: Starting from index 2 (height=14), we can visit: 14→6→4→6, giving us 4 total positions visited. This is optimal since we start from the highest peak and jump to progressively lower peaks within the jump distance.

small_array.py — Python

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

› Output: 1

💡 Note: All elements have the same height (3), so we can't make any jumps since we can only jump to strictly lower peaks. We can only visit 1 position (wherever we start).

limited_distance.py — Python

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

› Output: 7

💡 Note: Perfect descending sequence with d=1. Starting from index 0 (height=7), we can jump to each adjacent lower element: 7→6→5→4→3→2→1, visiting all 7 positions.

Constraints

1 ≤ arr.length ≤ 1000
1 ≤ arr[i] ≤ 10⁵
1 ≤ d ≤ arr.length
You can only jump to strictly lower positions
All peaks between start and end must be lower than start

Visualization

Tap to expand

Understanding the Visualization

Survey the Landscape

Look at all the peaks and identify the tallest ones - these are your best starting points

Plan Your Route

From each tall peak, identify which shorter peaks you can reach within your jump distance

Execute Optimal Path

Start from the tallest accessible peak and follow the path that visits the most peaks

Key Takeaway

🎯 Key Insight: Process peaks from tallest to shortest using topological sorting. When we compute the optimal path from any peak, all reachable destinations have already been solved!

Asked in

G Google 47 a Amazon 32 f Meta 28 ⊞ Microsoft 23

The optimal solution uses topological sorting with dynamic programming. By processing peaks from tallest to shortest, we ensure that when computing the maximum path from any peak, all reachable shorter peaks have already been processed. This gives us O(n log n + nd) time complexity - the sorting step plus checking valid destinations for each position.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force DFS from Every Position	O(n * d^n)	O(n)	Try every starting position and use DFS to explore all valid downhill paths
Dynamic Programming with Memoization	O(n²d)	O(n)	Use memoization to avoid recomputing the same subproblems multiple times
Topological Sort + Dynamic Programming (Optimal)	O(n log n + nd)	O(n)	Process positions by height order using topological sorting for optimal efficiency

Brute Force DFS from Every Position — Algorithm Steps

Iterate through each index as a potential starting position
For each starting position, perform DFS to explore all valid jumps
Check if jump is valid: within distance d, target is lower, path is clear
Recursively explore from each valid landing position
Track the maximum path length across all explorations

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Position 0

Start DFS from index 0, explore all valid downhill jumps

Try Position 1

Start DFS from index 1, explore all valid downhill jumps

Continue for All

Repeat for every position, tracking maximum path length

Code -

solution.c — C

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

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

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

bool canJump(int* arr, int d, int start, int end, int n) {
    if (start == end) return false;
    if (abs(start - end) > d) return false;
    if (arr[start] <= arr[end]) return false;
    
    int left = min(start, end);
    int right = max(start, end);
    for (int k = left + 1; k < right; k++) {
        if (arr[k] >= arr[start]) return false;
    }
    return true;
}

int dfs(int* arr, int d, int pos, bool* visited, int n) {
    visited[pos] = true;
    int maxLength = 1;
    
    for (int nextPos = 0; nextPos < n; nextPos++) {
        if (!visited[nextPos] && canJump(arr, d, pos, nextPos, n)) {
            int length = 1 + dfs(arr, d, nextPos, visited, n);
            maxLength = max(maxLength, length);
        }
    }
    
    visited[pos] = false;
    return maxLength;
}

int maxJumps(int* arr, int n, int d) {
    int result = 0;
    bool* visited = (bool*)calloc(n, sizeof(bool));
    
    for (int start = 0; start < n; start++) {
        memset(visited, false, n * sizeof(bool));
        int length = dfs(arr, d, start, visited, n);
        result = max(result, length);
    }
    
    free(visited);
    return result;
}

int main() {
    int arr[] = {6,4,14,6,8,13,9,7,10,6,12};
    int n = 11;
    int d = 2;
    printf("%d\n", maxJumps(arr, n, d));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * d^n)

For each starting position (n), we might explore up to d branches at each level, with maximum depth of n

✓ Linear Growth

Space Complexity

O(n)

Recursion stack can go up to n levels deep in the worst case

⚡ Linearithmic Space

43.2K Views

Medium-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 DFS from Every Position — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler