Maximum Array Hopping Score II

Maximum Array Hopping Score II - Problem

Given an array nums, you have to get the maximum score starting from index 0 and hopping until you reach the last element of the array.

In each hop, you can jump from index i to any index j where j > i, and you get a score of (j - i) * nums[j].

Return the maximum score you can get.

Input & Output

Example 1 — Basic Hopping

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

› Output: 22

💡 Note: Optimal path: 0→2→4. Jump from index 0 to 2: (2-0)*6=12. Jump from index 2 to 4: (4-2)*5=10. Total score: 12+10=22.

Example 2 — Simple Case

$ Input: nums = [2,5,3]

› Output: 8

💡 Note: We can jump 0→1→2 for score (1-0)*5+(2-1)*3 = 5+3 = 8, or jump 0→2 directly for score (2-0)*3 = 6. The maximum is 8.

Example 3 — Two Elements

$ Input: nums = [7,2]

› Output: 2

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

Constraints

2 ≤ nums.length ≤ 1000
-1000 ≤ nums[i] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 f Meta 18

The key insight is that this is a dynamic programming problem where we need to find the optimal sequence of jumps. The best approach uses bottom-up DP to compute maximum scores from each position. Time: O(n²), Space: O(n). For optimization, a monotonic stack can reduce time complexity to O(n).

Common Approaches

✓ Binary Search Answer

⏱️ Time: N/A Space: N/A

Bottom-Up Dynamic Programming

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

Start from the last position and work backwards, computing the maximum score for each position based on previously computed results.

Dynamic Programming (Memoization)

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

Same recursive approach as brute force but cache the results of each subproblem to avoid redundant calculations.

Monotonic Stack Optimization

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

For each position, we only need to consider jumps to positions with better value-to-distance ratios. Use a monotonic decreasing stack to efficiently find the best jumps.

Recursive Brute Force

⏱️ Time: O(2ⁿ) Space: O(n)

For each position, try jumping to every possible future position and recursively calculate the maximum score from there.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int parseArray(char* input, int* nums) {
    int n = 0;
    int i = 0;
    int len = strlen(input);
    
    while (i < len) {
        if (input[i] == '-' || (input[i] >= '0' && input[i] <= '9')) {
            int num = 0;
            int negative = 0;
            if (input[i] == '-') {
                negative = 1;
                i++;
            }
            while (i < len && input[i] >= '0' && input[i] <= '9') {
                num = num * 10 + (input[i] - '0');
                i++;
            }
            if (negative) num = -num;
            nums[n++] = num;
        } else {
            i++;
        }
    }
    return n;
}

long long maxHoppingScore(int* nums, int n) {
    if (n <= 1) return 0;
    
    long long* dp = (long long*)malloc(n * sizeof(long long));
    for (int i = 0; i < n; i++) {
        dp[i] = LLONG_MIN;
    }
    dp[0] = 0;
    
    for (int i = 0; i < n - 1; i++) {
        if (dp[i] == LLONG_MIN) continue;
        for (int j = i + 1; j < n; j++) {
            long long score = (long long)(j - i) * nums[j];
            if (dp[i] + score > dp[j]) {
                dp[j] = dp[i] + score;
            }
        }
    }
    
    long long result = dp[n-1];
    free(dp);
    return result;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int nums[200];
    int n = parseArray(input, nums);
    
    long long result = maxHoppingScore(nums, n);
    printf("%lld\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

856 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