55. Jump Game

Problem Statement

You’re given an array nums where nums[i] tells you the farthest you’re allowed to jump forward from index i. Starting at index $0$, determine whether there exists some sequence of jumps that lets you land on the final index.

Constraints:

• $1 \leq$ nums.length $\leq 10^{4}$
• $0 \leq$ nums[i] $\leq 10^{5}$

Examples

Brute Force: Too Many Possibilities

A naive approach tries all possible jumps from each index (like exploring a decision tree). That quickly becomes expensive because from many indices you can branch to multiple next positions. Even with memoization, you may still scan many reachable edges repeatedly, and in the worst case it can degrade toward quadratic behavior for large arrays.

The overlapping work comes from re-evaluating reachability of the same suffixes: different jump sequences can land you on the same index, and brute force tends to “rediscover” those states.

Optimized Approach Using Greedy Algorithm

Instead of choosing specific jumps, track a single evolving fact: the farthest index you can reach so far. When you stand at index i, if i is already beyond your farthest reachable index, then you can’t even get to i, so the answer is immediately false. Otherwise, you can update your farthest reach using i + nums[i].

This makes the logic easy to follow: if at every reachable index you extend the boundary of what’s reachable, then reachability of the end is exactly the question “does this boundary ever cover the last index?”

Solution Steps

Below are the step-by-step instructions to implement the greedy solution:

1. Initialize farthest = 0 and last = len(nums)-1.
2. Iterate i from 0 to len(nums) - 1:
   1. If i is greater than farthest, return False (this index is unreachable).
   2. Update farthest = max(farthest, i + nums[i]).
   3. If farthest is at least the last index (farthest >= last), return True.
3. After processing all elements , return whether farthest reaches the last index.

Take a look at the illustration below to understand the solution more clearly.

1 / 8

Python Implementation

Let’s look at the code for the solution we just discussed.

def canJump(nums):
    # Tracks the farthest index we can reach so far
    farthest = 0

    # The index we want to reach (last position in the array)
    last = len(nums) - 1

    # Iterate through each index and its jump value
    for i, jump in enumerate(nums):

        # If current index is beyond the farthest reachable index,
        # then we cannot reach this position -> return False
        if i > farthest:
            return False

        # Update farthest reachable index from current position
        farthest = max(farthest, i + jump)

        # If we can reach or go beyond the last index, return True early
        if farthest >= last:
            return True

    # After the loop, check if we ended up being able to reach the last index
    return farthest >= last
    
def main():
    test_cases = [
        [2, 3, 1, 1, 4],        
        [3, 2, 1, 0, 4],        
        [1, 2, 0, 1],           
        [2, 0, 2, 0, 1, 0],     
        [0, 2, 3],
    ]

    for idx, nums in enumerate(test_cases, start=1):
        result = canJump(nums)
        print(f"Test case {idx}")
        print("\tnums:", nums)
        print("\tResult:", result)
        print("-"*75)


if __name__ == "__main__":
    main()

Time Complexity

The time complexity is $O(n)$ because you scan the array once and do constant work per index while maintaining the farthest reachable position.

Space Complexity

The space complexity is $O(1)$ because the algorithm only stores a few integers regardless of input size.

Jump Game: Edge Cases

Handle special inputs like single-element arrays, early zeros, and barriers that stop progress.

• Single element array (already at the end)
  Input: [0]
  Why the solution handles it: last = 0, so farthest >= last is true immediately.
• Early zero but still reachable past it
  Input: [2,0,1]
  Why the solution handles it: from index 0, farthest becomes 2, so index 1 being zero doesn’t block reaching index 2.
• Zero creates a hard barrier
  Input: [1,0,2]
  Why the solution handles it: after index 1, farthest is still 1, so when i = 2, i > farthest triggers False.
• Large jump from early index
  Input: [10,0,0,0]
  Why the solution handles it: farthest quickly covers the last index and returns True.

Common Pitfalls

Avoid mistakes like updating reachability from unreachable indices or relying on “always jump max” logic.

• Trying to pick a “best next jump” explicitly: choosing locally largest jumps can miss cases where a smaller jump leads to a better launch point later.
• Not checking reachability before updating: if you update farthest for unreachable indices, you can incorrectly return True.
• Off-by-one errors with the last index: ensure you compare against len(nums) - 1, not len(nums).
• Overcomplicating with DP: it’s correct, but often slower and more code than needed in interviews.