It expires earlier and never beats the newer larger value. Candidates have ordered expiry and dominance, allowing a deque to keep only possible future winners.

Each previous state is a job applicant with a score and expiry time. A newer, better applicant dominates an older worse one. The front is today’s winner.

What the function promises: Return the maximum score reaching the final index when jumps may advance 1..k and landing adds values[i]. Require nonempty values and positive k.

from collections import deque

def max_jump_score(values, k):
    if not values or k <= 0: raise ValueError("Invalid input")
    dp = [0] * len(values)
    dp[0] = values[0]
    useful = deque([0])
    for i in range(1, len(values)):
        while useful[0] < i-k: useful.popleft()
        dp[i] = values[i] + dp[useful[0]]
        while useful and dp[useful[-1]] <= dp[i]: useful.pop()
        useful.append(i)
    return dp[-1]

assert max_jump_score([1,-1,-2,4,-7,3], 2) == 7
assert max_jump_score([10], 3) == 10

Work and storage: O(n) time and O(n) DP storage here; the deque is O(k). DP storage can also be bounded when reconstruction is unnecessary.

When to recognize it: Candidates have ordered expiry and dominance, allowing a deque to keep only possible future winners.

Check before applying it: The recurrence must truly depend on a contiguous index window; arbitrary predecessor sets need another structure.

A simple maximum of dp[j] no longer captures the transition; find a transform or use a suitable range structure.