Jump Game VIII

Jump Game VIII - Problem

Array Dynamic Programming Stack Graph Monotonic Stack Shortest Path Medium

Imagine you're a skilled parkour athlete navigating through a series of platforms with varying heights. You start at the first platform (index 0) and need to reach the final platform (index n-1) with minimum cost.

You are given:

A 0-indexed integer array nums representing platform heights
A costs array where costs[i] is the energy cost to land on platform i

The jumping rules are strict and based on platform heights:

Rule 1 (Ascending Jump): Jump from platform i to platform j (where i < j) if:

nums[i] ≤ nums[j] (jumping to same or higher platform)
All platforms between them are strictly lower: nums[k] < nums[i] for all i < k < j

Rule 2 (Descending Jump): Jump from platform i to platform j if:

nums[i] > nums[j] (jumping to lower platform)
All platforms between them are at same height or higher: nums[k] ≥ nums[i] for all i < k < j

Your goal is to find the minimum total cost to reach the last platform.

Input & Output

example_1.py — Basic Jump Scenario

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

› Output: 6

💡 Note: Optimal path: 0→2→4. From position 0 (height 3) jump to position 2 (height 4) since 3≤4 and position 1 (height 2) < 3. From position 2 (height 4) jump to position 4 (height 2) since 4>2 and position 3 (height 1) < 4. Total cost: 3 + 2 + 1 = 6.

example_2.py — Sequential Jumps

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

› Output: 3

💡 Note: With strictly increasing heights, we cannot jump directly to distant positions because intermediate heights violate the ascending jump rule (intermediates must be < starting height). Must go step by step: 0→1→2→3→4. Cost: 1 + 1 + 1 + 1 + 1 = 5, but we start at position 0 which costs 1, so path cost is 1 (start) + 1 (pos 1) + 1 (pos 2) + 1 (pos 3) + 1 (pos 4) = 5. Wait, let me recalculate properly: we can go 0→1→2→4. From 2 (height 3) to 4 (height 5), intermediate 3 (height 4) ≥ 3, so this is invalid for ascending. Actually optimal is 0→1→4 if valid. From 1 (height 2) to 4 (height 5), intermediates 2,3 have heights 3,4 which are ≥2, invalid. So must go 0→1→2→3→4 giving cost 5.

example_3.py — No Direct Path

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

› Output: 15

💡 Note: With strictly decreasing heights, from position 0 we can jump to any position. However, once we move forward, we need to check intermediate positions. Must visit each position: 0→1→2→3→4. Total cost: 1 + 2 + 3 + 4 + 5 = 15.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁵
costs.length == nums.length
1 ≤ costs[i] ≤ 10⁴
You must start at index 0 and reach index n-1

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 32 f Meta 28 ⊞ Microsoft 25

This problem combines dynamic programming with graph traversal. The optimal approach builds an adjacency graph of valid jumps based on height constraints, then uses DP to find the minimum cost path. Key insight: precompute valid jumps to avoid redundant validation checks during the DP phase.

Common Approaches

✓ Brute Force with Jump Validation

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

For each position, examine all future positions and check if we can make a valid jump according to the height rules. Use dynamic programming to track minimum costs.

Monotonic Stack with DP (Optimal)

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

Leverage monotonic stacks to maintain valid jump destinations for ascending and descending jumps. This eliminates the need to check all intermediate positions for each jump validation.

Brute Force with Jump Validation — Algorithm Steps

Initialize DP array where dp[i] represents minimum cost to reach position i
For each position i, check all positions j > i
Validate jump from i to j by checking all intermediate positions k
Update dp[j] with minimum cost if valid jump exists
Return dp[n-1] as the minimum cost to reach the end

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

Set dp[0] = costs[0], others to infinity

Check All Jumps

From each position i, examine all j > i

Validate Rules

Check all intermediate positions k between i and j

Update Costs

If valid jump, update dp[j] with minimum cost

Code -

solution.c — C

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

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

int solution(int* nums, int* costs, int n) {
    if (n == 1) return costs[0];
    
    int* dp = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        dp[i] = INT_MAX;
    }
    dp[0] = costs[0];
    
    for (int i = 0; i < n; i++) {
        if (dp[i] == INT_MAX) continue;
        
        for (int j = i + 1; j < n; j++) {
            int valid = 0;
            
            if (nums[i] <= nums[j]) {
                // Ascending jump: all intermediate must be < nums[i]
                valid = 1;
                for (int k = i + 1; k < j; k++) {
                    if (nums[k] >= nums[i]) {
                        valid = 0;
                        break;
                    }
                }
            } else {
                // Descending jump: all intermediate must be >= nums[i]
                valid = 1;
                for (int k = i + 1; k < j; k++) {
                    if (nums[k] < nums[i]) {
                        valid = 0;
                        break;
                    }
                }
            }
            
            if (valid) {
                dp[j] = min(dp[j], dp[i] + costs[j]);
            }
        }
    }
    
    int result = dp[n - 1];
    free(dp);
    return result;
}

int parseArray(char* line, int* arr) {
    int n = 0;
    char* token;
    char* rest = line;
    
    if (strchr(line, ',')) {
        token = strtok(rest, ",");
        while (token && n < 1000) {
            while (isspace(*token)) token++;
            if (*token) {
                arr[n++] = (int)strtol(token, NULL, 10);
            }
            token = strtok(NULL, ",");
        }
    } else {
        while (isspace(*rest)) rest++;
        if (*rest) {
            arr[n++] = (int)strtol(rest, NULL, 10);
        }
    }
    
    return n;
}

int main() {
    static char line1[10000], line2[10000];
    static int nums[1000], costs[1000];
    
    if (fgets(line1, sizeof(line1), stdin)) {
        line1[strcspn(line1, "\n")] = 0;
    } else {
        strcpy(line1, "1");
    }
    
    if (fgets(line2, sizeof(line2), stdin)) {
        line2[strcspn(line2, "\n")] = 0;
    } else {
        strcpy(line2, "1");
    }
    
    int n1 = parseArray(line1, nums);
    int n2 = parseArray(line2, costs);
    
    if (n1 > 0 && n2 > 0) {
        printf("%d\n", solution(nums, costs, n1));
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Triple nested loop: O(n) positions × O(n) destinations × O(n) validation

⚠ Quadratic Growth

Space Complexity

O(n)

DP array to store minimum costs for each position

⚡ Linearithmic Space

31.5K Views

Medium-High Frequency

~25 min Avg. Time

1.4K 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 with Jump Validation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler