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;    }};