动态规划之跳跃游戏

跳跃游戏

给出一个非负整数数组，你最初定位在数组的第一个位置,数组中的每个元素代表你在那个位置可以跳跃的最大长度,判断你是否能到达数组的最后一个位置。

注意事项：
数组A的长度不超过5000，每个元素的大小不超过5000

 样例 1：
 输入:
 	[2,3,1,1,4]
 输出:
 	true
 
 样例 2：
 输入:
 	[3,2,1,0,4]
 输出:
 	false

解答：
定义dp[i][j]为数组长度为i时，以第j个位置为最后一个跳点时是否能到达最后一个位置。
则有状态转换方程：
dp[i][j] = dp[j][j] && (j+A[j] >= i)
当i==j时，dp[i][j] = dp[i][0] || dp[i][1] || … || dp[i][j-1]{终点前任意一点能到达终点即表示可到达}

class Solution {
public:
    /**
     * @param A: A list of integers
     * @return: A boolean
     */
    bool canJump(vector<int> &A) {
        // write your code here
        if(A.empty()){
            return true;
        }
        /*
        if(A.size() > 1 && A[0] == 0){
            return false;
        }
        
        // 贪心策略下取当前点n往后跳的范围内能使下一次跳跃的范围最大的那个点
        // 即 n + A[k] + k 最大
        int next = -1;
        int Max = 0;
        for (int i = 0; i < A.size();) {
            for (int j = i + 1; j < A.size() && j-i <= A[i]; j++) {
                if(A[j] + j > Max){
                    next = j;
                    Max = A[j] + j;
                }
            }
            if(next >= A.size() - 1){
                return true;
            }
            if(next != -1 && A[next] == 0){
                return false;
            }
            i = next;
            next = -1;
            Max = 0;
        }
        
        return true;*/
        
        
        /*
        定义dp[i][j]为数组长度为i时，以第j个位置为最后一个跳点时是否能到达最后一个位置。
        则有状态转换方程：
        dp[i][j] = dp[j][j] && (j+A[j] >= i)
        当i==j时，dp[i][j] = dp[i][0] || dp[i][1] || ... || dp[i][j-1]{终点前任意一点能到达终点即表示可到达}
        */
        
        const int M = 5001;
        const int N = 5001;
        
        bool dp[M][N];
        for (int i = 0; i < M; i++) {
            for (int j = 0; j < N; j++) {
                dp[i][j] = false;
            }
        }
        dp[0][0] = true;
        dp[1][1] = true;
        
        for (int i = 1; i <= A.size(); i++) {
            for (int j = 1; j < i; j++) {
                dp[i][j] = dp[j][j] && (j+A[j-1] >= i);
                dp[i][i] = dp[i][i] || dp[i][j];
            }
        }
        
        return dp[A.size()][A.size()];
    }
};