[leetcode]，跳跃游戏 1-5

跳跃游戏 I

https://leetcode-cn.com/problems/jump-game/

数组的下标表示位置的编号，数组中的元素表示我们可以从当前位置向后跳多远

可以采用贪心的策略，我们从前向后遍历一遍，对于每次遍历，需要维护一个变量 (之前可以到达的最远的位置)，max (ans, i + nums[i])。

只要发现当前位置比我们维护的可到达的最大位置大，那么就说明当前位置是无法到达的，直接返回false。

跳跃游戏 II

https://leetcode-cn.com/problems/jump-game-ii/

相对之前的题来说，这里要求我们使用最少的跳跃次数，从起点到终点(0 - n-1)。（这总是可以到达的）

1. 使用深度优先搜索对所有结果进行模拟

对于每一个搜索，我们维护一个当前可到达终点的最小跳跃次数min_jump，当前可以到达的位置index，以及当前的跳跃次数now_jump

class Solution {
   
public:
    int jump(vector<int>& nums) {
   
        int len = nums.size();
        int min_jump = 0x0000ffff;
        dfs(nums,len,0,min_jump,0);
        return min_jump;
    }
    //深搜超时  [5,6,4,4,6,9,4,4,7,4,4,8,2,6,8,1,5,9,6,5,2,7,9,7,9,6,9,4,1,6,8,8,4,4,2,0,3,8,5]
    void dfs(vector<int>& nums, int& len, int index,int& min_jump,int now_jump)
    {
   
        //判断是否可以直接跳到最后一步
        if(index >= len-1)
        {
   
            min_jump = min(min_jump,now_jump);
            return ;
        }

        for(int i = nums[index]; i > 0; i--)
            dfs(nums,len,index+i,min_jump,now_jump+1);
    }
};

最后，这样直接暴力去搜索显然是超时的，他的时间复杂度也是比较高的。由于模拟的问题，我们做了很多重复的工作

2. 动态规划

第二种就是可以用动态规划的思想，当我们从位置A 跳到位置B 时，位置B的最少跳跃次数就等于min (dp[B], dp[A] + 1)。要么我自己的之前维护的次数就是最小的，要么就是从0-A跳跃的次数 + 1

dp[i] ，表示从开始位置0到位置i，所需的最小跳跃次数。

class Solution {
   
public:
    //动态规划  超时
    int jump(vector<int>& nums) {
   
        int len = nums.size();
        vector<int> dp(len,0x0000ffff);//dp[i]表示跳到当前位置最小跳跃次数
        dp[0] = 0;
        for(int i = 0; i < len; i++)
        {
   
            int jump = min(len-1,i+nums[i]);	// 可以向后跳jump个位置
            for(int j = i; j <= jump; j++)
            {
   
                dp[j] = min(dp[j],dp[i]+1);
            }
        }

        return dp[len-1];
    }
}