[LintCode] Jump Game II

最小跳跃次数算法

最新推荐文章于 2025-12-11 20:33:03 发布

转载最新推荐文章于 2025-12-11 20:33:03 发布 · 110 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/lz87/p/7057588.html

文章标签：

#runtime

本文探讨了如何找到非负整数数组中从起始位置到达最后一个元素所需的最少跳跃次数。介绍了四种解决方案：递归、带备忘录的递归、自底向上的动态规划及贪婪算法，并对比了它们的时间复杂度。

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

Given array A = [2,3,1,1,4]

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.)

Solution 1. Recursion without memoization

Similarly with Jump Game, we can use solve this problem recursively with the following formula.

f(n) = min(1 + f(i)) for i satisfies in range [0, n - 1], i + A[i] >= n, f(i) is reachable from A[0];

For f(i) that can't be reached from A[0], it does not update the min.

 1 public class Solution {
 2     private int min;
 3     public int jump(int[] A) {
 4         if(A == null || A.length == 0){
 5             return Integer.MAX_VALUE;
 6         }
 7         min = Integer.MAX_VALUE;
 8         helper(A, A.length - 1, 0);
 9         return min;
10     }
11     private void helper(int[] A, int idx, int jumps){
12         if(idx == 0){
13             min = Math.min(min, jumps);
14             return;
15         }
16         for(int i = 0; i < idx; i++){
17             if(i + A[i] >= idx){
18                 helper(A, i, jumps + 1);            
19             }
20         }
21     }
22 }

Solution 2. Top Down Recursion with Memoization, O(n^2) runtime, O(n) space

 1 public class Solution {
 2     private int[] T;
 3     public int jump(int[] A) {
 4         if(A == null || A.length == 0){
 5             return Integer.MAX_VALUE;
 6         }
 7         T = new int[A.length];
 8         T[0] = 0;
 9         for(int i = 1; i < A.length; i++){
10             T[i] = Integer.MAX_VALUE;
11         }
12         return helper(A, A.length - 1);
13     }
14     private int helper(int[] A, int idx){
15         if(T[idx] != Integer.MAX_VALUE){
16             return T[idx];
17         }
18         for(int i = 0; i < idx; i++){
19             if(i + A[i] >= idx){
20                 int ret = helper(A, i);
21                 if(ret != Integer.MAX_VALUE){
22                     T[idx] = Math.min(T[idx], ret + 1);
23                     break;
24                 }
25             }
26         }
27         return T[idx];
28     }
29 }

Solution 3. Bottom Up Dynamic Programming

 1 public class Solution {
 2     public int jump(int[] A) {
 3         if(A == null || A.length == 0){
 4             return Integer.MAX_VALUE;
 5         }
 6         int[] steps = new int[A.length];
 7         steps[0] = 0;
 8         for (int i = 1; i < A.length; i++) {
 9             steps[i] = Integer.MAX_VALUE;
10         }
11         for (int i = 1; i < A.length; i++) {
12             for (int j = 0; j < i; j++) {
13                 if (steps[j] != Integer.MAX_VALUE && j + A[j] >= i) {
14                     steps[i] = Math.min(steps[i], steps[j] + 1);
15                     break;
16                 }
17             }
18         }
19         return steps[A.length - 1];
20     }
21 }