Leetcode 45. Jump Game II dp优化 （给出了5种思路）

题意

• 给你一个n长的数组a，a[i]表示从i跳一步，最远距离
• 问你，从0出发跳到n-1的位置最少需要几步

思路

• 这题挺有意思的，我想了5个思路，2个T了，1个实现起来比较麻烦。。就记录下几个思路，感觉都是经典思路。。
• 思路1：这题很容易就能想到个dp的思路，dp[i]表示跳到i的最短距离，dp[i] = min(dp[j] + 1) if j + nums[j] >= i，一维dp加遍历，O(n^2)的复杂度，T了
• 思路2：想了个A*搜索，如果i能到j，我们认为i，j之前有条边，然后用优先队列，维护到第i个节点的最短距离；好久没用这种搜索了，脑子抽了，觉得是O(nlogn)复杂度就写了。。。其实是O(mlogn)的m是边数，在这个问题里很明显m是有可能达到n^2级别的。
• 思路3：优化dp，一种经典思路，把原问题转换成它的对偶问题，dp(i)表示最多走i步时，可以达到的最远位置，这样递推公式是dp(i) = max(nums[j]+j), i-1<= j <= dp(i-1)，这样就把问题转换为快速求nums[j]+j的区间最大值，也就是RMQ问题，可以用线段树，st算法之类的维护，O(nlogn)的复杂度，但是感觉写起来好麻烦。。就没写。。
• 思路4：结合思路2和思路3，想了个思路。。可以说是一种dp加优先队列优化。就还是思路3的递推形式，并在每次更新完dp(i)后，用优先队列维护变量nums[j]+j，即能在i步走到的位置j，从j出发能到的最远距离，写起来比较简单O(nlogn)
• 思路5：在思路4的基础上再优化下，其实优先队列也没必要，在插入优先队列时，也需要遍历元素，所以可以直接维护最大值，这样就把复杂度降到了O(n)

实现

O(n)算法

class Solution {
public:
    int jump(vector<int>& nums) {
        int n = nums.size();
        if (n == 1)
            return 0;
        for (int i=0;i<n;i++){
            nums[i] = i + nums[i];
        }
        int pre = 0;
        int pos = 0;
        for (int i=1;i<n;i++){
            int p = nums[pos];
            if (p >= n-1)
                return i;
            int tmp = 0;
            for (int j=pre+1; j<=p;j++){
                if (nums[j] > tmp){
                    tmp = nums[j];
                    pos = j;
                }
            }
            pre = p;
        }
        return -1;
    }
};

优先队列优化dp

class Solution {
public:
    int jump(vector<int>& nums) {
        priority_queue<int> q;
        int n = nums.size();
        if (n == 1)
            return 0;
        for (int i=0;i<n;i++){
            nums[i] = i + nums[i];
        }
        q.push(nums[0]);
        int pre = 0;
        for (int i=0;i<n;i++){
            auto tmp = q.top();
            q.pop();
            if (tmp >= n-1)
                return i+1;
            for (int j=pre+1;j<=tmp;j++){
                q.push(nums[j]);
            }
            pre = tmp;
        }
        return -1;
    }
};

普通dp(T了。。)

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

    }
};

A*搜索(T了。。)

class Solution {
public:
    int jump(vector<int>& nums) {
        priority_queue<pair<int,int>, vector<pair<int,int> >, greater<pair<int,int> > > q;
        int n = nums.size();
        if (n == 1)
            return 0;
        vector<bool> mark(n, 0);
        q.push(make_pair(0, 0));
        mark[0] = 1;
        while (q.size()){
            auto tmp = q.top();
            q.pop();
            int pos = tmp.second;
            for (int i=1;i<=nums[pos];i++){
                if (i+pos == n-1)
                    return tmp.first + 1;
                if (mark[i+pos])
                    continue;
                q.push(make_pair(tmp.first+1, i+pos));
                mark[i+pos] = 1;
            }
        }
        return -2;
    }
};