Reach End of Array With Max Score - Practice Coding Problems

Reach End of Array With Max Score - Problem

Array Greedy Medium

Array Jumping Challenge: Maximize Your Score!

You're given an integer array nums of length n, and you need to traverse from the first index (0) to the last index (n-1) by making strategic jumps. Here's the twist: you can only jump forward to indices greater than your current position!

🎯 Scoring System: Each jump from index i to index j earns you (j - i) × nums[i] points. The longer your jump and the higher the value at your starting position, the more points you earn!

Goal: Find the maximum possible total score you can achieve by the time you reach the final index.

Example: If nums = [1, 3, 1, 5], jumping from index 1 (value=3) to index 3 (value=5) would score (3-1) × 3 = 6 points.

Input & Output

example_1.py — Basic Case

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

› Output: 7

💡 Note: Optimal path: 0→1 (score: 1×1=1), then 1→3 (score: 2×3=6). Total: 1+6=7. This beats jumping 0→2→3 (1×2 + 1×1 = 3) or 0→3 directly (3×1 = 3).

example_2.py — Decreasing Array

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

› Output: 15

💡 Note: Since values only decrease, we jump directly from start to end: (3-0) × 5 = 15 points. No benefit in stopping at intermediate positions.

example_3.py — Single Element

$ Input: nums = [7]

› Output: 0

💡 Note: With only one element, we're already at the end, so no jumps are needed and score is 0.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
You must start at index 0 and reach index n-1
You can only jump to indices greater than your current index

Visualization

Tap to expand

Understanding the Visualization

Scan Forward

From current position, look for the next platform with a higher value

Strategic Jump

Jump to that higher-value platform to maximize future scoring potential

Calculate Score

Add (jump_distance × starting_platform_value) to total score

Repeat or Finish

Continue strategy or jump directly to end if no higher values remain

Key Takeaway

🎯 Key Insight: The greedy approach works because higher starting values multiply distance gains, so we should always prioritize reaching and staying at high-value positions before making longer jumps.

Asked in

G Google 25 f Meta 18 a Amazon 15 ⊞ Microsoft 12

The optimal greedy approach achieves O(n) time complexity by recognizing that we should always jump to the next higher value position when possible, as higher starting values multiply our distance gains. This strategy ensures maximum score by staying at advantageous positions as long as possible before making the final jump to the end.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Recursive with Memoization)	O(n²)	O(n)	Try all possible jump sequences and pick the maximum score
Greedy Algorithm (Optimal)	O(n)	O(1)	Always jump to the next higher value or make the longest jump possible

Dynamic Programming (Recursive with Memoization) — Algorithm Steps

Define a recursive function that returns max score from current position to end
For each position i, try jumping to all positions j where j > i
Calculate score for jump i→j as (j-i) * nums[i] + maxScore(j)
Use memoization to avoid recalculating the same subproblems
Return the maximum score among all possible jumps

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at index 0

Begin recursive exploration from the first position

Try all forward jumps

For each position, try jumping to every valid future position

Calculate and memoize

Compute maximum score for each position and store results

Code -

solution.c — C

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

#define MAX_N 1000
long long memo[MAX_N];
int nums[MAX_N];
int n;
int memo_set[MAX_N];

long long dp(int i) {
    if (i == n - 1) return 0;
    if (memo_set[i]) return memo[i];
    
    long long maxScore = 0;
    for (int j = i + 1; j < n; j++) {
        long long score = (long long)(j - i) * nums[i] + dp(j);
        if (score > maxScore) maxScore = score;
    }
    
    memo[i] = maxScore;
    memo_set[i] = 1;
    return maxScore;
}

long long maxScore(int* array, int size) {
    memcpy(nums, array, size * sizeof(int));
    n = size;
    memset(memo_set, 0, sizeof(memo_set));
    return dp(0);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we try jumping to up to n positions, leading to n² combinations with memoization

⚠ Quadratic Growth

Space Complexity

O(n)

Space for memoization array plus recursion stack depth of up to n

⚡ Linearithmic Space

38.0K Views

Medium 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

Dynamic Programming (Recursive with Memoization) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler