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;iint pre = 0;
        int pos = 0;
        for (int i=1;iint 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;i0]);
        int pre = 0;
        for (int i=0;iauto 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;ifor (int j=0;jif (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_queueint,int>, vectorint,int> >, greaterint,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;
    }
};

你可能感兴趣的:(ACM_DP,ACM_优先队列,&,堆,leetcode,dp,算法题,优先队列)