Welcome to Subscribe On Youtube

Question

Formatted question description: https://leetcode.ca/all/55.html

You are given an integer array nums. You are initially positioned at the array's first index, and each element in the array represents your maximum jump length at that position.

Return true if you can reach the last index, or false otherwise.

 

Example 1:

Input: nums = [2,3,1,1,4]
Output: true
Explanation: Jump 1 step from index 0 to 1, then 3 steps to the last index.

Example 2:

Input: nums = [3,2,1,0,4]
Output: false
Explanation: You will always arrive at index 3 no matter what. Its maximum jump length is 0, which makes it impossible to reach the last index.

 

Constraints:

• 1 <= nums.length <= 104
• 0 <= nums[i] <= 105

Algorithm

Greedy Algorithm, because here is not very concerned about the number of remaining steps at each position, but only want to know whether we can reach the end, that is to say we are only interested in the farthest reachable position.

So we maintain a variable reach, represents the farthest reachable position, initialized to 0. Traverse each number in the array,

• if the current coordinate is greater than reach or reach has reached the last position, then jump out of the loop,
• otherwise update the value of reach to the larger value of i + nums[i], where i + nums[i] indicates the maximum position that the current position can reach.

Code

• Java
• C++
• Python
• Go
• Javascript
• C#
• TypeScript

• 
  public class Jump_Game {
  
  
      class Solution {
          public boolean canJump(int[] nums) {
  
              if (nums == null || nums.length == 0) {
                  return false;
              }
  
              int reach = 0;
              for (int i = 0; i < nums.length; i++) {
                  // first judge, whether the last reach can reach the new i
                  if (reach >= nums.length - 1 || reach < i) { // i > reach, meaning cannot reach
                      break;
                  }
  
                  reach = Math.max(reach, i + nums[i]);
              }
  
              return reach >= nums.length - 1;
  
          }
      }
  
  
      class Solution_dp {
          public boolean canJump(int[] nums) {
  
              if (nums == null || nums.length == 0) {
                  return false;
              }
  
              // 其中 dp[i] 表示达到i位置时剩余的跳力，若到达某个位置时跳力为负了，说明无法到达该位置
              int[] dp = new int[nums.length];
  
              for (int i = 1; i < nums.length; i++) { // @note: start from 1, because already at index=0
                  dp[i] = Math.max(dp[i - 1], nums[i - 1]) - 1;
  
                  if (dp[i] < 0) {
                      return false;
                  }
              }
  
              return true;
  
          }
      }
  
  }
  
  ############
  
  class Solution {
      public boolean canJump(int[] nums) {
          int mx = 0;
          for (int i = 0; i < nums.length; ++i) {
              if (i > mx) {
                  return false;
              }
              mx = Math.max(mx, i + nums[i]);
          }
          return true;
      }
  }
  

• // OJ: https://leetcode.com/problems/jump-game/
  // Time: O(N)
  // Space: O(1)
  class Solution {
  public:
      bool canJump(vector<int>& A) {
          for (int i = 0, last = 0; i <= last; ++i) {
              last = max(last, i + A[i]);
              if (last >= A.size() - 1) return true;
          }
          return false;
      }
  };
  

• class Solution:
      def canJump(self, nums: List[int]) -> bool:
          mx = 0
          for i, num in enumerate(nums):
              if i > mx:
                  return False
              mx = max(mx, i + num)
          return True
  
  ############
  
  class Solution(object):
    def canJump(self, nums):
      """
      :type nums: List[int]
      :rtype: int
      """
      pos = 0
      bound = len(nums)
      while pos < len(nums) - 1:
        dis = nums[pos]
        if dis == 0:
          return False
        farthest = posToFarthest = 0
        for i in range(pos + 1, min(pos + dis + 1, bound)):
          canReach = i + nums[i]
          if i == len(nums) - 1:
            return True
          if canReach > farthest:
            farthest = canReach
            posToFarthest = i
        pos = posToFarthest
      return True if pos >= len(nums) - 1 else False
  
  

• func canJump(nums []int) bool {
  	mx := 0
  	for i, num := range nums {
  		if i > mx {
  			return false
  		}
  		mx = max(mx, i+num)
  	}
  	return true
  }
  
  func max(a, b int) int {
  	if a > b {
  		return a
  	}
  	return b
  }
  

• /**
   * @param {number[]} nums
   * @return {boolean}
   */
  var canJump = function (nums) {
      let mx = 0;
      for (let i = 0; i < nums.length; ++i) {
          if (i > mx) {
              return false;
          }
          mx = Math.max(mx, i + nums[i]);
      }
      return true;
  };
  
  

• public class Solution {
      public bool CanJump(int[] nums) {
          int mx = 0;
          for (int i = 0; i < nums.Length; ++i) {
              if (i > mx) {
                  return false;
              }
              mx = Math.Max(mx, i + nums[i]);
          }
          return true;
      }
  }
  

• function canJump(nums: number[]): boolean {
      let mx: number = 0;
      for (let i = 0; i < nums.length; ++i) {
          if (mx < i) {
              return false;
          }
          mx = Math.max(mx, i + nums[i]);
      }
      return true;
  }
  
  

All Problems

All Solutions