> For the complete documentation index, see [llms.txt](https://wentao-shao.gitbook.io/leetcode/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://wentao-shao.gitbook.io/leetcode/dynamic-programming/1.position/45.jump-game-ii.md).

# 45.Jump-Game-II

## 45. Jump Game II

## 题目地址

<https://leetcode.com/problems/jump-game-ii/solution/>

<https://www.jiuzhang.com/solutions/jump-game-ii>

## 题目描述

```
Given an array of non-negative integers, you are initially positioned at the first index of the array.

Each element in the array represents your maximum jump length at that position.

Your goal is to reach the last index in the minimum number of jumps.

Example:
Input: [2,3,1,1,4]
Output: 2
Explanation: The minimum number of jumps to reach the last index is 2.
    Jump 1 step from index 0 to 1, then 3 steps to the last index.

Note:
You can assume that you can always reach the last index.
```

## 代码

### Approach #1 Greedy

```java
public class Solution {
  public int jump(int[] A) {
    if (A == null || A.length == 0) return -1;
    int start = 0, end = 0, jumps = 0;
    while (end < A.length - 1) {
      jumps++;
      int farthest = end;
      for (int i = start; i <= end; i++) {
        if (A[i] + i > farthest) {
          farthest = A[i] + i;
        }
      }
      start = end + 1;
      end = farthest;
    }
    return jumps;
  }
}
```

### Approach #2 Greedy - 2

**Complexity Analysis**

* Time complexity : O(*N*), it's one pass along the input array.
* Space complexity : O(1) since it's a constant space solution.

```java
class Solution {
  public int jump(int[] nums) {
    int n = nums.length;
    if (n < 2) return 0;

    // max position one could reach 
    // starting from index <= i 
    int maxPos = nums[0];
    // max number of steps one could do
    // inside this jump
    int maxSteps = nums[0];

    int jumps = 1;
    for (int i = 1; i < n; ++i) {
      // if to reach this point 
      // one needs one more jump
      if (maxSteps < i) {
        ++jumps;
        maxSteps = maxPos;
      }
      maxPos = Math.max(maxPos, nums[i] + i);
    }
    return jumps;
  }
}
```

### Approach #1: Dynamic Programming (Time Limit Exceeded)

```java
public class Solution {
    public int jump(int[] A) {
    // state
    int[] dp = new int[A.length];

    // initislize
    dp[0] = 0;
    for (int i = 1; i < A.length; i++){
      dp[i] = Integer.MAX_VALUE;
    }

    // function
    for (int i = 1; i < A.length; i++) {
      for (int j = 0; j < i; j++) {
        if (dp[j] != Integer.MAX_VALUE && j + A[j] >= i) {
          dp[i] = Math.min(dp[i], dp[j] + 1);
        }
      }
    }

    // answer
    return dp[A.length - 1];
  }
}
```