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

    Related Problems 

    Jump Game II

    Frog Jump

  • 相关阅读:
    ubuntu网速慢解决方法
    SQL优化指南
    Java 并发:volatile 关键字解析
    java集成WebSocket向所有用户发送消息
    java集成WebSocket向指定用户发送消息
    windows下使用批处理脚本实现多个版本的JDK切换
    String.format()格式化日期(2)
    String.format(2)
    String.format()用法
    获得这两个时间的所有天数及其周几
  • 原文地址:https://www.cnblogs.com/lz87/p/7057585.html
Copyright © 2011-2022 走看看