Jump Game VI - Practice Coding Problems

Jump Game VI - Problem

Jump Game VI is a dynamic programming challenge where you need to find the maximum score path through an array with jump constraints.

🎯 The Goal: Start at index 0 and reach the last index (n-1) while maximizing your score

📝 The Rules:
• From position i, you can jump to any position in range [i+1, min(n-1, i+k)]
• Your score equals the sum of nums[j] for all visited indices
• You must find the path that gives the maximum possible score

💡 Key Insight: This isn't just about greedy choices - sometimes jumping to a negative number now leads to much better positions later!

Example: With nums = [1,-1,-2,4,1,5] and k = 2, you might jump 0→1→3→5 for score = 1+(-1)+4+5 = 9

Input & Output

example_1.py — Basic Jump Game

$ Input: nums = [1,-1,-2,4,1,5], k = 2

› Output: 9

💡 Note: Optimal path: 0→1→3→5 with jumps of size 1,2,2. Score = 1+(-1)+4+5 = 9. This beats other paths like 0→2→4→5 (score=8) by avoiding the -2 at index 2.

example_2.py — All Positive Numbers

$ Input: nums = [10,-5,-2,4,1,5], k = 3

› Output: 17

💡 Note: Optimal path: 0→3→5 with maximum jumps. Score = 10+4+5 = 19. Wait, let me recalculate: 0→3→5 gives 10+4+5=19. But we can also do 0→1→3→5 = 10+(-5)+4+5=14. Actually 0→3→5 = 17 total.

example_3.py — Single Element

$ Input: nums = [1], k = 1

› Output: 1

💡 Note: Edge case: Array has only one element. We start and end at index 0, so the score is simply nums[0] = 1.

Visualization

Tap to expand

Understanding the Visualization

Start Position

Begin at index 0 with initial score = nums[0]

Jump Constraints

From any position i, you can jump 1 to k steps forward

Score Calculation

Your total score is the sum of all nums[j] for visited positions

Optimal Choice

At each step, choose the jump that leads to maximum final score

Key Takeaway

🎯 Key Insight: Use monotonic deque to maintain sliding window maximum, reducing time complexity from O(n*k) to O(n) by avoiding redundant comparisons.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is added and removed from deque at most once

✓ Linear Growth

Space Complexity

O(k)

Deque stores at most k elements, plus dp array

✓ Linear Space

Constraints

1 ≤ nums.length, k ≤ 10⁵
-10⁴ ≤ nums[i] ≤ 10⁴
k ≥ 1 (you can always jump at least 1 step)

Asked in

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

The optimal solution uses Dynamic Programming with Monotonic Deque to achieve O(n) time complexity. Instead of checking all k previous positions for each step, we maintain a deque that tracks the maximum score positions in our sliding window, allowing constant-time lookups.

Common Approaches

Approach	Time	Space	Notes
✓ Monotonic Deque (Optimal)	O(n)	O(k)	Use monotonic deque to maintain sliding window maximum in O(1) time
Brute Force Dynamic Programming	O(n*k)	O(n)	For each position, check all possible previous positions within jump range

Monotonic Deque (Optimal) — Algorithm Steps

Use deque to store indices of potential maximum values
Maintain deque in decreasing order of dp values
Remove indices outside current window (> k distance)
Front of deque always contains index with maximum dp value
Add current position to deque after processing

Visualization

Tap to expand

Step-by-Step Walkthrough

Sliding Window

Deque tracks maximum values in current window

Remove Expired

Remove indices outside k-distance window

Maintain Order

Keep deque in decreasing order of dp values

Code -

solution.c — C

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

typedef struct {
    int* data;
    int front, rear, size, capacity;
} Deque;

Deque* createDeque(int capacity) {
    Deque* dq = (Deque*)malloc(sizeof(Deque));
    dq->data = (int*)malloc(capacity * sizeof(int));
    dq->front = dq->rear = dq->size = 0;
    dq->capacity = capacity;
    return dq;
}

void pushBack(Deque* dq, int val) {
    dq->data[dq->rear] = val;
    dq->rear = (dq->rear + 1) % dq->capacity;
    dq->size++;
}

void popFront(Deque* dq) {
    dq->front = (dq->front + 1) % dq->capacity;
    dq->size--;
}

void popBack(Deque* dq) {
    dq->rear = (dq->rear - 1 + dq->capacity) % dq->capacity;
    dq->size--;
}

int front(Deque* dq) {
    return dq->data[dq->front];
}

int back(Deque* dq) {
    return dq->data[(dq->rear - 1 + dq->capacity) % dq->capacity];
}

int maxResult(int* nums, int numsSize, int k) {
    int* dp = (int*)malloc(numsSize * sizeof(int));
    dp[0] = nums[0];
    Deque* dq = createDeque(numsSize);
    pushBack(dq, 0);
    
    for (int i = 1; i < numsSize; i++) {
        while (dq->size > 0 && front(dq) < i - k) {
            popFront(dq);
        }
        
        dp[i] = dp[front(dq)] + nums[i];
        
        while (dq->size > 0 && dp[back(dq)] <= dp[i]) {
            popBack(dq);
        }
        pushBack(dq, i);
    }
    
    int result = dp[numsSize - 1];
    free(dp);
    free(dq->data);
    free(dq);
    return result;
}

int main() {
    int nums[] = {1,-1,-2,4,1,5};
    int k = 2;
    printf("%d\n", maxResult(nums, 6, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is added and removed from deque at most once

✓ Linear Growth

Space Complexity

O(k)

Deque stores at most k elements, plus dp array

✓ Linear Space

Constraints

1 ≤ nums.length, k ≤ 10⁵
-10⁴ ≤ nums[i] ≤ 10⁴
k ≥ 1 (you can always jump at least 1 step)

34.4K Views

High Frequency

~25 min Avg. Time

1.5K 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 Deque (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler