lintcode-116-跳跃游戏

116-跳跃游戏

给出一个非负整数数组，你最初定位在数组的第一个位置。　　　

数组中的每个元素代表你在那个位置可以跳跃的最大长度。　　　　

判断你是否能到达数组的最后一个位置。

注意事项

这个问题有两个方法，一个是贪心和 动态规划。

贪心方法时间复杂度为O（N）。

动态规划方法的时间复杂度为为O（n^2）。

我们手动设置小型数据集，使大家阔以通过测试的两种方式。这仅仅是为了让大家学会如何使用动态规划的方式解决此问题。如果您用动态规划的方式完成它，你可以尝试贪心法，以使其再次通过一次。

样例

A = [2,3,1,1,4]，返回 true.

A = [3,2,1,0,4]，返回 false.

标签

动态规划 贪心 数组

方法一（动态规划）

使用动态规划，用一维数组 dp[i] 表示假设位置 i 能够跳跃的最大长度

动态转移方程为：dp[i] = max(A[i]+i, dp[i−1]) [ if dp[i−1]≥i ]

code

class Solution {
public:
    /**
     * @param A: A list of integers
     * @return: The boolean answer
     */
    bool canJump(vector<int> A) {
        // write you code here
        int size = A.size();
        if (size == 1) {
            return true;
        }

        vector<int> dp(size, 0);
        dp[0] = A[0];
        for(int i=1; i<size; i++) {
            if (dp[i-1] >= i) {
                dp[i] = (A[i]+i > dp[i-1]) ? A[i]+i : dp[i-1];
            }
            else {
                dp[i] = 0;
            }
        }
        return dp[size-1] >= size-1;
    }
};

方法二（贪心）

用一个变量代替 dp 数组

code

class Solution {
public:
    /**
     * @param A: A list of integers
     * @return: The boolean answer
     */
    bool canJump(vector<int> A) {
        // write you code here
        int size = A.size();
        if (size == 1) {
            return true;
        }
        int currMaxStep = A[0];
        int step = 0;
        for (int i=1; i<size; i++) {
            if(i > currMaxStep) {
                return false;
            }
            currMaxStep = (i+A[i] > currMaxStep) ? i+A[i] : currMaxStep;
            if(currMaxStep >= size-1) {
                return true;
            }
        }
        return currMaxStep >= size-1;
    }
};