貪心——55. 跳躍遊戲 && 45.跳躍遊戲II

Mirror559發表於2021-12-24

給定一個非負整數陣列,你最初位於陣列的第一個位置。

陣列中的每個元素代表你在該位置可以跳躍的最大長度。

判斷你是否能夠到達最後一個位置。

示例 1:

  • 輸入: [2,3,1,1,4]
  • 輸出: true
  • 解釋: 我們可以先跳 1 步,從位置 0 到達 位置 1, 然後再從位置 1 跳 3 步到達最後一個位置。

示例 2:

  • 輸入: [3,2,1,0,4]
  • 輸出: false
  • 解釋: 無論怎樣,你總會到達索引為 3 的位置。但該位置的最大跳躍長度是 0 , 所以你永遠不可能到達最後一個位置。

 

這是55,我剛拿到的時候,是完全想不到貪心的,因為如果每一步都走最長的步數,是不一定能到達n-1的,這樣會錯過必經之路。

在之後,我就想到的回溯,如果從下標0開始遍歷,不好控制回溯的思路,也不好構造回溯的記錄,因此我選擇:

  • 用visited記錄:
    • 0: 沒到過
    • -1:到不了
    • 1: 到得了
  • 從後往前回溯,當前位置為currIndex,如果currIndex前的點i沒訪問到,且能到currIndex,visited[i]為1,否則為0
    • 能到:i + nums[i] >= currIndex
    • currIndex前的點i沒訪問到:visited[i] == 0

程式碼如下:

class Solution {
    //0: 沒到過
    //-1:到不了
    //1: 到得了
    int[] visited = null;
    public boolean canJump(int[] nums) {
        if (nums.length == 1) {
            return true;
        }
        int n = nums.length;
        visited = new int[n];

        function(n-1, nums);

        return visited[0] == 1;
    }

    public void function(int currIndex, int[] nums) {
        for (int i = currIndex-1; i >= 0; --i) {
            if (visited[i] == 0) {
                if (i + nums[i] >= currIndex) {
                    visited[i] = 1;
                    function(i, nums);
                } else {
                    visited[i] = -1;
                }
            }
        }
    }
}

 

看了題解,貪心的思路用一句話就可以總結:

每次走遍當前cover到的所有點,根據i + nums[i]的值更新cover,直到:

  • 到達n-1
  • 沒有新的點加入,即cover不能更新

 

    public boolean canJump(int[] nums) {
        int cover = nums[0], n = nums.length, i = 0;

        while (i <= cover) {
            cover = cover >= i + nums[i] ? cover : i + nums[i];
            if (cover >= n-1) {
                return true;
            }
            ++i;
        }

        return cover >= n-1;
    }

 

到跳躍2,條件變成:

  • 肯定能到n-1
  • 跳躍次數min

 

因此貪心的思路變成:

  • 每次在cover中,尋找能讓cover增加最多的點i,走到那兒
  • count++

 

程式碼如下:

    public int jump(int[] nums) {
        int cover = 0, count = 0, n = nums.length, i = 0, max = 0;
        while (i < n-1) {
            ++count;
            cover = nums[i];
            max = i+1;
            for (int j = i+1; j < n && j <= i+cover; ++j) {
                if (j >= n-1) {
                    return count;
                }
                //讓cover變的最大的點
                max = max + nums[max] >= j + nums[j] ? max : j;
            }
            i = max;
        }
        return count;
    }

 

相關文章