我的方法一：分治法（O(n2)超时）

步骤

一看题目，首先想到的是分治法，即

为了到达最后一个位置，那么看前面一共几个位置可以跳依次到达最后一个位置，这几个位置记为locations；
如果locations有至少一个点可以跳到最后一个位置，所以就表示可以跳到最后一个位置；否则不能；
所以问题又分成了是否可以跳到locations为结尾的点；

初始条件

locations加入最后一个点

边界条件

输入的nums为空或者长度为1，返回true
locations为空，表示不能跳到最后一个点
如果搜索到了第一个点，那么停止，表示可以跳到这个点

数据结构

locations可以使用queue，这样每找到一个可能到达最后一个位置的点就push进去；但是注意的是有可能同一个位置的点会被push多次；这个可以用O(n)的空间保存下该点是否已经push过了。

复杂度

时间复杂度：O(N2)，因为两层循环，第一层循环，遍历所有可以到达最后一个点的队列；第二层循环，遍历所有当前点前面的点，判断是否可以到当前点
空间复杂度：O(n)：存储是否某个点已经被遍历过了

代码

class Solution {
public:
    bool canJump(vector<int>& nums) {
        if(nums.size() <= 1){
            return true;
        }

        int n = nums.size();
        queue<int> q;
        q.push(n-1);
        vector<bool> walked;
        for(int i = 0; i<n; i++){
            walked.push_back(false);
        }

        int cur = 0;
        while(!q.empty()){
            cur = q.front();
            q.pop();
            
            for(int i = cur -1; i>=0; i--){
                if(walked[i]){
                    continue;
                }

                if(nums[i] + i >= cur){
                    if(i == 0){
                        return true;
                    }
                    q.push(i);
                    walked[i] = true;
                }
            }
        }

        return false;
    }
};

我的方法二：动态规划

由于分治法超时，所以O(n2)的复杂度无法达到需求，很容易想到了O(n)复杂度的动态规划；动态规划的4个步骤：

步骤

1. 确认状态
1.1 最后一步：s(n)最后一个点可以通过前一个点跳到，或者不能通过前一个点跳到；
1.2 子问题：s(n-1)倒数第二个点能否从第0个跳到。
2. 转移方程
2.1 f[i]：能否到达第i个点
2.2 g[i]: 表示第i个点可以跳跃的步数
2.3 s[i]：表示第i个点前面的点可以跳到第i个点后，还能往前跳多少
2.3 转移方程：
2.3.1 f[i] = f[i-1] && (g[i-1]>0 || s[i-1]>0)
2.3.2 s[i] = max(s[i-1], g[i-1]) - 1
3. 初始条件和边界情况
3.1 f[0] = true
3.2 s[0] = 0
4. 计算顺序
4.1 f[0],f[1],...,f[n]

复杂度

时间复杂度：O(n)
空间复杂度：O(n)，因为f、s都是n的长度

代码

class Solution {
public:
    bool canJump(vector<int>& nums) {
        if(nums.size() <= 1){
            return true;
        }
        int n = nums.size();
        vector<bool> f;
        vector<int> s;
        for(int i = 0;i<n;i++){
            f.push_back(false);
            s.push_back(0);
        }
        f[0] = true;
        s[0] = 0;

        for(int i = 1; i<n; i++){
            //2.3.1 f[i] = f[i-1] && (g[i-1]>0 || s[i-1]>0)
            f[i] = f[i-1] && (nums[i-1]>0 || s[i-1]>0);
            //2.3.2 s[i] = max(s[i-1], g[i-1]) - 1
            if(s[i-1] > nums[i-1]){
                s[i] = s[i-1] - 1;
            }else{
                s[i] = nums[i-1] - 1;
            }
            if(!f[i]){
                break;
            }
        }
        return f[n-1];
    }
};

其他人更好的方法

贪心算法

官方解法：https://leetcode-cn.com/problems/jump-game/solution/tiao-yue-you-xi-by-leetcode-solution/

我的理解和解法

从第0个开始，看最远能跳到什么地方设A，然后再看0-A之间的其他位置能否跳到更远的地方，如果都不比A远，那么说明最远只能到A，如果能够超过A到B，那再接着看A-B之间的位置能否跳过B，如果最后到达或者超过最后一个元素，那么说明能够跳到最后一个元素，否则不能；

步骤：

cur记录当前遍历的位置，highest记录当前跳到的最远位置
遍历cur-highest之间的最远位置，如果超过highest则更新highest

初始条件和边界条件

cur=0，highest=nums[0]
cur==highest，则停止，返回false
highest>=n-1，则返回true
当nums长度为0或者1时，直接返回true

代码

class Solution {
public:
    bool canJump(vector<int>& nums) {
        if(nums.size() <= 1){
            return true;
        }
        int n = nums.size();
        int cur = 0;
        int highest = 0;
        int jump_count = 0;
        while(cur<=highest){
            jump_count = nums[cur]+cur;
            if(jump_count>highest){
                highest = jump_count;
                    if(highest>=n-1){
                    return true;
                }
            }
            cur++;
        }

        return false;
    }
};

最后编辑于：2020.06.17 23:15:36