[LeetCode] 45. 跳躍遊戲 II

題目連接 : https://leetcode-cn.com/problems/jump-game-ii/

題目描述:

給定一個非負整數數組，你最初位於數組的第一個位置。

數組中的每一個元素表明你在該位置能夠跳躍的最大長度。

你的目標是使用最少的跳躍次數到達數組的最後一個位置。

示例:

輸入: [2,3,1,1,4]
輸出: 2
解釋: 跳到最後一個位置的最小跳躍數是 2。
     從下標爲 0 跳到下標爲 1 的位置，跳 1 步，而後跳 3 步到達數組的最後一個位置。

思路:

思路一:

剛開始,我想用動態規劃,用dp[i]表示到i位置的最少步數

動態方程爲:dp[i] = min(dp[i], dp[j] + 1),j位置能夠到達i 的位置,代碼以下:

class Solution:
    def jump(self, nums: List[int]) -> int:
        n = len(nums)
        dp = [float("inf")] * n
        dp[0] = 0
        for i in range(1, len(nums)):
            for j in range(i):
                if nums[j] >= i - j:
                    dp[i] = min(dp[i], dp[j] + 1)
        #print(dp)
        return dp[-1]

public class JumpGameII {
    public int jump(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        int[] dp = new int[nums.length];
        dp[0] = 0;
        for (int i = 1; i < nums.length; i++) {
            dp[i] = Integer.MAX_VALUE;
            for (int j = 0; j < i; j++) {
                if (nums[j] >= i - j) {
                    dp[i] = Math.min(dp[i], dp[j] + 1);
                }
            }
        }
        return dp[nums.length - 1];
    }
}

可是, 這是$O(n^2)$算法,若是數據超過$10^4$就過不了,沒想到真的過不了,哈哈!

思路2: 貪心算法

相似與BFS

一句話解釋: 從一個位置跳到它能跳到的最遠位置之間的都只須要一步!

因此,若是一開始都能跳到,後面再跳到的確定步數要變多!

時間複雜度:$O(n)$

---

關注個人知乎專欄,瞭解更多的解題技巧,共同進步!

代碼:

python

class Solution:
    def jump(self, nums: List[int]) -> int:
        n = len(nums)
        if n == 1 : return 0
        dp = [0] * n
        for i in range(n):
            for j in range(nums[i], 0, -1):
                if i + j >= n - 1 : return dp[i] + 1
                elif dp[i + j] == 0:
                    dp[i + j] = dp[i] + 1
                else:
                    break
        return "到底不了最後"

java

class Solution {
    public int jump(int[] nums) {
        if (nums.length == 1) return 0;
        int[] dp = new int[nums.length];
        for (int i = 0; i < nums.length; i++) {
            for (int j = nums[i]; j > 0; j--) {
                if (i + j >= nums.length - 1) {
                    return dp[i] + 1;
                } else if (dp[i + j] == 0) {
                    dp[i + j] = dp[i] + 1;
                } else {
                    break;
                }
            }
        }
        return 0;
    }
}