Comment on page

# 45.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

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.
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;
// max number of steps one could do
// inside this jump
int maxSteps = nums;
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)

public class Solution {
public int jump(int[] A) {
// state
int[] dp = new int[A.length];
// initislize
dp = 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);
}
}
}