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