补LeetCode动态规划专题：第四天

跳跃游戏

思路：贪心

每一次保存跳得最远的格子，如果遍历到不能到的格子返回$false$，否则更新跳的最远的距离，如果最远距离已经超过数组长度返回$true$

class Solution {
public:
    bool canJump(vector<int>& nums) {
        int maxn = 0;
        for (int i = 0; i < nums.size(); i ++ ) {
            if (i <= maxn) {
                maxn = max(maxn, nums[i] + i);
            if (maxn >= nums.size() - 1)
                return true;
            }
        }
        return false;
    }
};

跳跃游戏二

思路一：动态规划

class Solution {
public:
    int jump(vector<int>& nums) {
        int n = nums.size();
        vector<int> f(n, n);
        f[0] = 0;
        for (int i = 0; i < n - 1; i ++ )
            for (int j = i + 1; j < n && j <= nums[i] + i; j ++ )
                f[j] = min(f[j], f[i] + 1);
        
        return f[n - 1];
    }
};

思路二：贪心

由动态规划发现，每一次只需要保留跳最远的距离那个格子下标，因此一遍循环，每一次更新最远的距离，如果说当前格子走到上一次走的最远距离，step++

class Solution {
public:
    int jump(vector<int>& nums) {
        int n = nums.size();
        int ans = 0, maxn = 0, pre = 0;
        for (int i = 0; i < n - 1; i ++ ) {
            maxn = max(maxn, nums[i] + i);
            if (i == pre) {
                pre = maxn;
                ans ++ ;
            }
        }
        return ans;
    }
};