Jump Game VIII - Practice Coding Problems

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 can jump from any position to any later position. Optimal path: 0→4 directly. Cost: 1 + 1 = 2. Wait, let me recalculate: start at 0 (cost 1), jump to 4 (cost 1), total = 2. But the answer should be 3, so we must go 0→1→4 or similar path.

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.

Visualization

Tap to expand

Understanding the Visualization

Analyze Heights

Examine the height profile to understand jump constraints

Find Valid Jumps

Identify all positions reachable from current position based on visibility rules

Apply DP

Use dynamic programming to find minimum cost path through valid jumps

Optimize Path

Select the path that minimizes total jumping cost

Key Takeaway

🎯 Key Insight: The visibility constraints create a directed graph where DP finds the shortest path efficiently.

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

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

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

Approach	Time	Space	Notes
✓ Brute Force with Jump Validation	O(n³)	O(n)	Check all possible jumps from each position by validating jump rules
Monotonic Stack with DP (Optimal)	O(n²)	O(n)	Use monotonic stacks to efficiently find valid jump destinations

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>

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

int solution(int* nums, int* costs, int n) {
    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]) {
                valid = 1;
                for (int k = i + 1; k < j; k++) {
                    if (nums[k] >= nums[i]) {
                        valid = 0;
                        break;
                    }
                }
            } else {
                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 main() {
    int nums[] = {3, 2, 4, 1, 2};
    int costs[] = {3, 4, 2, 3, 1};
    printf("%d\n", solution(nums, costs, 5));
    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

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force with Jump Validation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler