You are given a 0-indexed integer array nums and an integer k.
You are initially standing at index 0. In one move, you can jump at most k steps forward without going outside the boundaries of the array. That is, you can jump from index i to any index in the range [i + 1, min(n - 1, i + k)] inclusive.
You want to reach the last index of the array (index n - 1). Your score is the sum of all nums[j] for each index j you visited in the array.
Return the maximum score you can get.
Example 1:
Input: nums = [1,-1,-2,4,-7,3], k = 2 Output: 7 Explanation: You can choose your jumps forming the subsequence [1,-1,4,3] (underlined above). The sum is 7.
Example 2:
Input: nums = [10,-5,-2,4,0,3], k = 3 Output: 17 Explanation: You can choose your jumps forming the subsequence [10,4,3] (underlined above). The sum is 17.
Example 3:
Input: nums = [1,-5,-20,4,-1,3,-6,-3], k = 2 Output: 0
Constraints:
1 <= nums.length, k <= 105-104 <= nums[i] <= 104
Companies: MathWorks, Apple, Amazon
Related Topics:
Array, Dynamic Programming, Queue, Sliding Window, Heap (Priority Queue), Monotonic Queue
Similar Questions:
Let dp[i] be the greatest score we can get using A[0 .. i].
To get dp[i], we pick the greatest dp[j] (i - k <= j < i) and add A[i] to it.
dp[i] = A[i] + max( dp[j] | max(0, i - k) <= j < i )
dp[0] = A[0]
For the part calculating max value, doing it in a brute force manner will take O(K) time and result in TLE. We can use mono-queue to reduce the time complexity to amortized O(1).
Since we are looking for the maximum value in a range, we can use a decreasing mono-queue.
// OJ: https://leetcode.com/problems/jump-game-vi/
// Author: github.com/lzl124631x
// Time: O(N)
// Space: O(N)
class Solution {
public:
int maxResult(vector<int>& A, int k) {
int N = A.size();
vector<int> dp(N);
dp[0] = A[0];
deque<int> q{0};
for (int i = 1; i < N; ++i) {
if (q.front() < i - k) q.pop_front(); // pop the front element if it goes out of range
dp[i] = A[i] + dp[q.front()]; // dp[q.front()] is the maximum dp value in range.
while (q.size() && dp[q.back()] <= dp[i]) q.pop_back(); // pop the elements that are smaller than or equal to dp[i] out of the queue.
q.push_back(i);
}
return dp[N - 1];
}
};Or store the scores in the mono-queue to reduce space complexity to O(K).
// OJ: https://leetcode.com/problems/jump-game-vi
// Author: github.com/lzl124631x
// Time: O(N)
// Space: O(K)
class Solution {
public:
int maxResult(vector<int>& A, int k) {
deque<pair<int, int>> q; // index, score
int N = A.size();
for (int i = 0; i < N; ++i) {
if (i - k - 1 >= 0 && q.front().first == i - k - 1) q.pop_front();
int score = A[i];
if (q.size()) score += q.front().second;
while (q.size() && q.back().second <= score) q.pop_back();
q.emplace_back(i, score);
}
return q.back().second;
}
};