LeetCode 5631. 跳躍遊戲 VI（優先佇列 / 單調佇列）

阿新 • • 發佈：2020-12-29

技術標籤：LeetCode

文章目錄

1. 題目

給你一個下標從 0 開始的整數陣列 nums 和一個整數 k 。

一開始你在下標 0 處。每一步，你最多可以往前跳 k 步，但你不能跳出陣列的邊界。
也就是說，你可以從下標 i 跳到 [i + 1， min(n - 1, i + k)] 包含兩個端點的任意位置。

你的目標是到達陣列最後一個位置（下標為 n - 1 ），你的得分為經過的所有數字之和。

請你返回你能得到的 最大得分 。

示例 1：
輸入：nums = [1,-1,-2,4,-7,3], k = 2 

輸出：7
解釋：你可以選擇子序列 [1,-1,4,3] （上面加粗的數字），和為 7 。

示例 2：
輸入：nums = [10,-5,-2,4,0,3], k = 3
輸出：17
解釋：你可以選擇子序列 [10,4,3] （上面加粗數字），和為 17 。

示例 3：
輸入：nums = [1,-5,-20,4,-1,3,-6,-3], k = 2
輸出：0
 
提示：
 1 <= nums.length, k <= 10^5
-104 <= nums[i] <= 10^4

來源：力扣（LeetCode）連結：https://leetcode-cn.com/problems/jump-game-vi

著作權歸領釦網路所有。商業轉載請聯絡官方授權，非商業轉載請註明出處。

2. 解題

類似題目：
LeetCode 45. 跳躍遊戲 II（貪心/BFS，難）
LeetCode 1306. 跳躍遊戲 III（廣度優先搜尋BFS）
LeetCode 1345. 跳躍遊戲 IV（BFS）
LeetCode 1340. 跳躍遊戲 V（DP）
LeetCode LCP 09. 最小跳躍次數

2.1 貪心錯誤解

k 步以內遇到正的，跳過去
沒有遇到正的，跳到最大的負數上，LC測試例子弱 [-1,-1,-4,-5,-4,-4,-4] k=2，這個例子不能通過，下面程式輸出 -14，正解 -13

class Solution 
 {
public:
    int maxResult(vector<int>& nums, int k) {
    	int n = nums.size(), ans = nums[0], maxNegative = INT_MIN, idx = -1;
    	for(int i = 1; i < n; ++i) 
    	{
    		int step = k;
    		bool inNegativePos = true;
    		bool reachEnd = false;
            maxNegative = INT_MIN;
    		for( ; i < n && step--; i++)
    		{
    			if(nums[i] >= 0)
    			{
    				ans += nums[i];
    				inNegativePos = false;
    				break;
    			}
    			else
    			{
    				if(i == n-1)
    					reachEnd = true;
    				if(nums[i] >= maxNegative)
    				{
    					maxNegative = nums[i];
    					idx = i;
    				}
    			}
    		}
    		if(inNegativePos)
    		{
    			if(reachEnd)
    			{
    				ans += nums[n-1];
    				break;
    			}
    			else
    			{
	    			ans += nums[idx];
	    			i = idx;
	    		}
    		}
    	}
    	return ans;
    }
};

2.2 優先佇列/單調佇列

優先佇列，維護 i 之前的位置獲得的最大和
跟當前的位置距離超過 K 的，pop掉，堆頂的位置跳到 i 是 i 處的最優值，存入堆中
時間複雜度 O ( n l o g n ) O(nlogn) O(nlogn)

class Solution {
public:
    int maxResult(vector<int>& nums, int k) {
        int n = nums.size(), ans = nums[0];
        priority_queue<pair<int,int>> q;// sum. idx
        q.push({nums[0], 0});
        for(int i = 1; i < n; ++i) 
        {
            while(i-q.top().second > k)//這些位置，不能跳到 i 位置
                q.pop();
            //能調過來的位置，選最大的，跳到 i
            ans = q.top().first + nums[i];// 到 i位置的最優選擇
            q.push({ans, i});//存入優先佇列
        }
        return ans;
    }
};

848 ms 64.4 MB C++

單調佇列，越靠後的點 j ，如果其位置的最大和不比前面 i 的小，那麼 i 的值一定不是更優的選擇，可以刪掉，維護一個單調遞減佇列
時間複雜度 O ( n ) O(n) O(n)

class Solution {
public:
    int maxResult(vector<int>& nums, int k) {
        int n = nums.size(), ans = nums[0];
        deque<pair<int,int>> q;// sum. idx
        q.push_back({nums[0], 0});
        for(int i = 1; i < n; ++i) 
        {
            while(i-q.front().second > k)//這些位置，不能跳到 i 位置
                q.pop_front();
            ans = q.front().first + nums[i];// 到 i位置的最優選擇
            while(!q.empty() && q.back().first <= ans)
                q.pop_back();
            q.push_back({ans, i});//存入佇列
        }
        return ans;
    }
};