Formatted question description: https://leetcode.ca/all/1696.html
1696. Jump Game VI (Medium)
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
Related Topics:
Dequeue
Similar Questions:
Solution 1. Mono-queue + DP
For A[i]
, we can choose the greatest value we can get among A[j]
where max(0, i - k) <= j < i
.
So we can memoize the results using a dp
array where dp[i]
is the maximum score we can get jumping from A[0]
to A[i]
.
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/
// Time: O(N)
// Space: O(N)
class Solution {
public:
int maxResult(vector<int>& A, int k) {
int N = A.size();
vector<long> dp(N, INT_MIN);
dp[0] = A[0];
deque<int> q;
q.push_back(0);
for (int i = 1; i < N; ++i) {
dp[i] = A[i] + dp[q.front()]; // dp[q.front()] is the maximum dp value in range.
if (q.size() && q.front() <= i - k) q.pop_front(); // pop the front element because it goes out of 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];
}
};
Java
class Solution {
public int maxResult(int[] nums, int k) {
int length = nums.length;
int[] dp = new int[length];
dp[0] = nums[0];
int max = nums[0];
int firstMaxIndex = Math.min(length - 1, k);
for (int i = 1; i <= firstMaxIndex; i++) {
dp[i] = max + nums[i];
max = Math.max(max, dp[i]);
}
Deque<Integer> deque = new LinkedList<Integer>();
for (int i = 1; i <= firstMaxIndex; i++) {
int sum = dp[i];
while (!deque.isEmpty() && dp[deque.getLast()] < sum)
deque.removeLast();
deque.offerLast(i);
}
for (int i = firstMaxIndex + 1; i < length; i++) {
if (!deque.isEmpty() && deque.getFirst() == i - k - 1)
deque.pollFirst();
int num = nums[i];
int sum = dp[deque.peekFirst()] + num;
dp[i] = sum;
while (!deque.isEmpty() && dp[deque.peekLast()] < sum)
deque.pollLast();
deque.offerLast(i);
}
return dp[length - 1];
}
}