zoukankan html css js c++ java

[LintCode] Jump Game

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.

Determine if you are able to reach the last index.

This problem have two method which is Greedy and Dynamic Programming.

The time complexity of Greedy method is O(n).

The time complexity of Dynamic Programming method is O(n^2).

We manually set the small data set to allow you pass the test in both ways. This is just to let you learn how to use this problem in dynamic programming ways. If you finish it in dynamic programming ways, you can try greedy method to make it accept again.

Example

A = [2,3,1,1,4], return true.

A = [3,2,1,0,4], return false.

Solution 1. Recursion without memoization

Recursive formula: f(n) = true if there is at least one i (from 0 to n - 1) that satisfies i + A[i] >= n and f(i) = true.

　　　　　　　　 f(n) = false if there is no such i.

This solution is not efficient as it does duplicate work to compute the same subproblems over and over.

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

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

The natural way of optimizing solution 1 is to avoid duplicated work by using memoization.

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

Solution 3. Bottom up dynamic programming, O(n^2) runtime, O(n) space.

An equivalent iterative bottom up dp solution is implemented as follows.

Both solution 2 and 3 can't be optimized further more on extra space usage as calculating a subproblem

possibly requires the results of all smaller subproblems.

However, runtime can be further optimized to O(n) using Greedy algorithm.

 1 public class Solution {
 2     public boolean canJump(int[] A) {
 3         if(A == null || A.length == 0){
 4             return false;
 5         }
 6         int n = A.length;
 7         boolean f[] = new boolean[n];
 8         f[0] = true;
 9         
10         for(int i = 1; i < n; i++){
11             for(int j = 0; j < i; j++){
12                 if(j + A[j] >= i){
13                     f[i] = f[i] || f[j];                 
14                 }
15             }
16             if(!f[i]){
17                 return false;
18             }
19         }
20         return true;
21     }
22 }

Solution 4. Greedy Algorithm, O(n)

Stay tuned...