# Just reverse the problem and it's simple

Education

## Introduction

When faced with the "jump game" problem, you're given a list of integers representing how far you can jump from each position. The objective is to determine whether you can reach the last position starting from the first.

Take for example an initial list `[2, 3, 1, 1, 4]`

. At each position, the number represents how far forward you can potentially jump. For instance, if you're on the first position with a value of 2, you can jump to the second or third position.

A clever approach utilizes a greedy strategy by starting from the end of the list and working backwards. This way:

**Identify the End Target:**Begin by setting the target initially as the last position in the list.**Iterate in Reverse Order:**Loop through the array in reversed order. For each index, check if you can jump to the current target.**Update the Target:**If you can reach the current target from this index (i.e., current index + max jump ≥ target), update the target to be this current position.**Check for Success:**If at any point the target becomes zero, it means you can reach the end from the start.

### Example:

Imagine the problem:
List: `[2, 3, 1, 1, 4]`

- Start with the target at the last position.
- Loop backwards:
- Can we reach the target from index 4? Yes, so update the target to index 4.
- Can we reach the target from index 3? Yes, so update the target to index 3.
- Continue this logic...

- When you get to the beginning and the target is zero, you know you can jump from start to end.

Here's a possible implementation in code:

```
def can_jump(nums):
target = len(nums) - 1
for i in range(len(nums) - 2, -1, -1):
if i + nums[i] >= target:
target = i
return target == 0
```

This technique ensures an optimal solution with a linear traversal of the array, making it efficient and effective.

## Keyword

- Jump game
- Greedy strategy
- Reverse iteration
- Target update
- Reachability

## FAQ

**Q: What is the "jump game" problem?**
A: It's a problem where you are given a list of integers, and each integer represents how far you can jump forward from that position. The objective is to determine whether you can reach the last position starting from the first.

**Q: How does the greedy strategy work in solving the jump game?**
A: By starting at the end of the list and iterating backwards, you continuously update the target to the current position if you can jump to the current target. If the target becomes zero, you have successfully determined that you can reach the end from the start.

**Q: What does updating the target achieve in the context of this problem?**
A: Updating the target helps track the minimum index from which you need to reach the end. Starting from the end and going in reverse ensures you only update the target position when it's reachable from the current index.

**Q: Why is this solution considered optimal?**
A: This solution is optimal because it only requires a single pass through the array (O(n) time complexity) and doesn't require additional data structures, making it space-efficient as well.