Maximum Array Hopping Score II - Practice Coding Problems

Maximum Array Hopping Score II - Problem

You're given an array of integers nums and need to find the maximum score by hopping through the array from start to finish. Starting at index 0, you can jump to any index j where j > i (current position).

Each jump from index i to index j gives you a score of (j - i) * nums[j]. The longer the jump and the larger the destination value, the higher your score!

Goal: Find the maximum total score you can achieve by making optimal jumps until you reach the last element.

Example: For array [1, 5, 2, 3], jumping from index 0 directly to index 1 gives score (1-0) * 5 = 5, then from index 1 to index 3 gives score (3-1) * 3 = 6, for a total of 11.

Input & Output

example_1.py — Basic Case

$ Input: [1, 5, 2, 3]

› Output: 11

💡 Note: Optimal path: 0→1→3. Jump from index 0 to 1 gives score (1-0)*5=5. Jump from index 1 to 3 gives score (3-1)*3=6. Total: 5+6=11.

example_2.py — Long Jump Better

$ Input: [1, 2, 3, 10]

› Output: 30

💡 Note: Better to jump directly from index 0 to index 3: (3-0)*10=30, rather than making smaller jumps with lower total score.

example_3.py — Minimum Array

$ Input: [5, 2]

› Output: 2

💡 Note: Only one possible jump from index 0 to 1: (1-0)*2=2.

Visualization

Tap to expand

Understanding the Visualization

Survey the landscape

Look at all peaks ahead and identify which ones are worth considering

Build the skyline

Only peaks that aren't blocked by taller ones closer to you matter

Plan optimal jumps

For each position, calculate the best score among all skyline peaks

Update the skyline

As you process each position, update which peaks remain optimal

Key Takeaway

🎯 Key Insight: Like a smart mountain climber, we only need to consider peaks in our 'line of sight' - those that aren't blocked by taller peaks closer to us. This skyline approach reduces our search space dramatically!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is pushed and popped from stack at most once

✓ Linear Growth

Space Complexity

O(n)

Stack can contain up to n elements in worst case

⚡ Linearithmic Space

Constraints

2 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
You must start at index 0 and can only jump forward
You must reach the last index of the array

Asked in

G Google 45 a Amazon 38 f Meta 28 ⊞ Microsoft 22

The optimal solution uses a monotonic stack to identify the 'skyline' of optimal jump destinations in O(n) time. The key insight is that we only need to consider jumping to positions that aren't blocked by taller values closer to us. This creates a decreasing sequence of potential targets that can be efficiently maintained with a stack.

Common Approaches

Approach	Time	Space	Notes
✓ Monotonic Stack (Optimal)	O(n)	O(n)	Use a monotonic stack to efficiently find the best next jump for each position
Brute Force (Dynamic Programming)	O(n²)	O(n)	Try all possible paths using recursive DP with memoization

Monotonic Stack (Optimal) — Algorithm Steps

Traverse the array from right to left
Maintain a monotonic decreasing stack of (index, value) pairs
For each position, the stack contains all potentially optimal jump targets
Calculate the maximum score by considering jumps to all positions in the stack
Update the stack by removing elements that are no longer optimal

Visualization

Tap to expand

Step-by-Step Walkthrough

Build decreasing stack

Maintain stack of positions with decreasing values

Calculate optimal jumps

For each position, consider all stack elements as jump targets

Update stack

Remove elements that are no longer optimal

Code -

solution.c — C

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

#define MAX_N 1000

typedef struct {
    int index;
    int value;
} Pair;

long long maxScore(int* nums, int n) {
    if (n <= 1) return 0;
    
    long long* dp = (long long*)calloc(n, sizeof(long long));
    Pair* stack = (Pair*)malloc(n * sizeof(Pair));
    int stackSize = 1;
    stack[0] = (Pair){n-1, nums[n-1]};
    
    for (int i = n-2; i >= 0; i--) {
        long long maxScore = 0;
        for (int k = 0; k < stackSize; k++) {
            int j = stack[k].index;
            int val = stack[k].value;
            long long score = (long long)(j - i) * val + dp[j];
            if (score > maxScore) {
                maxScore = score;
            }
        }
        
        dp[i] = maxScore;
        
        while (stackSize > 0 && stack[stackSize-1].value <= nums[i]) {
            stackSize--;
        }
        stack[stackSize++] = (Pair){i, nums[i]};
    }
    
    long long result = dp[0];
    free(dp);
    free(stack);
    return result;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    int nums[MAX_N];
    int n = 0;
    char* token = strtok(input, "[],\n");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%lld\n", maxScore(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is pushed and popped from stack at most once

✓ Linear Growth

Space Complexity

O(n)

Stack can contain up to n elements in worst case

⚡ Linearithmic Space

Constraints

2 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
You must start at index 0 and can only jump forward
You must reach the last index of the array

58.0K Views

High Frequency

~25 min Avg. Time

1.3K 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

Monotonic Stack (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler