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

Solution: DP + Monotonic Queue

dp[i] = nums[i] + max(dp[j]) i – k <= j < i

Brute force time complexity: O(n*k) => TLE

# Author: Huahua 52/58 Passed (TLE)
class Solution:  
  def maxResult(self, nums: List[int], k: int) -> int:
    @lru_cache(None)
    def dp(i: int) -> int:
      return nums[0] if i == 0 else nums[i] + max(dp(j) for j in range(max(0, i - k), i))
    return dp(len(nums) - 1)

This problem can be reduced to find the maximum for a sliding window that can be solved by monotonic queue.

Time complexity: O(n)
Space complexity: O(n+k) -> O(k)

// Author: Huahua
class Solution {
public:
  int maxResult(vector<int>& nums, int k) {
    const int n = nums.size();
    vector<int> dp(n);
    deque<int> q{{0}};
    dp[0] = nums[0];    
    for (int i = 1; i < n; ++i) {
      dp[i] = nums[i] + dp[q.front()];
      while (!q.empty() && dp[i] >= dp[q.back()]) q.pop_back();
      while (!q.empty() && i - q.front() >= k) q.pop_front();      
      q.push_back(i);      
    }
    return dp[n - 1];
  }
};

// Author: Huahua
class Solution {
public:
  int maxResult(vector<int>& nums, int k) {
    const int n = nums.size();
    deque<pair<int, int>> q{{nums[0], 0}};
    for (int i = 1; i < n; ++i) {      
      const int cur = nums[i] + q.front().first;      
      while (!q.empty() && cur >= q.back().first) 
        q.pop_back();
      while (!q.empty() && i - q.front().second >= k) 
        q.pop_front();      
      q.emplace_back(cur, i);
    }
    for (const auto& [v, i] : q)
      if (i == n - 1) return v;
    return 0;
  }
};

The post 花花酱 LeetCode 1696. Jump Game VI appeared first on Huahua's Tech Road.

Given an array points containing the coordinates of points on a 2D plane, sorted by the x-values, where points[i] = [xi, yi] such that xi < xj for all 1 <= i < j <= points.length. You are also given an integer k.

Find the maximum value of the equation yi + yj + |xi - xj| where |xi - xj| <= k and 1 <= i < j <= points.length. It is guaranteed that there exists at least one pair of points that satisfy the constraint |xi - xj| <= k.

Example 1:

Input: points = [[1,3],[2,0],[5,10],[6,-10]], k = 1
Output: 4
Explanation: The first two points satisfy the condition |xi - xj| <= 1 and if we calculate the equation we get 3 + 0 + |1 - 2| = 4. Third and fourth points also satisfy the condition and give a value of 10 + -10 + |5 - 6| = 1.
No other pairs satisfy the condition, so we return the max of 4 and 1.

Example 2:

Input: points = [[0,0],[3,0],[9,2]], k = 3
Output: 3
Explanation: Only the first two points have an absolute difference of 3 or less in the x-values, and give the value of 0 + 0 + |0 - 3| = 3.

Constraints:

• 2 <= points.length <= 10^5
• points[i].length == 2
• -10^8 <= points[i][0], points[i][1] <= 10^8
• 0 <= k <= 2 * 10^8
• points[i][0] < points[j][0] for all 1 <= i < j <= points.length
• xi form a strictly increasing sequence.

Observation

Since xj > xi, so |xi – xj| + yi + yj => xj + yj + (yi – xi)
We want to have yi – xi as large as possible while need to make sure xj – xi <= k.

Solution 1: Priority Queue / Heap

Put all the points processed so far onto the heap as (y-x, x) sorted by y-x in descending order.
Each new point (x_j, y_j), find the largest y-x such that x_j – x <= k.

Time complexity: O(nlogn)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int findMaxValueOfEquation(vector<vector<int>>& points, int k) {
    priority_queue<pair<int, int>> q; // {y - x, x}    
    q.emplace(0, -1e9);
    int ans = INT_MIN;
    for (const auto& p : points) {
      const int x = p[0], y = p[1];
      while (!q.empty() && x - q.top().second > k) q.pop();
      if (!q.empty())
        ans = max(ans, x + y + q.top().first);
      q.emplace(y - x, x);
    }
    return ans;
  }
};

Solution 2: Monotonic Queue

Maintain a monotonic queue:
1. The queue is sorted by y – x in descending order.
2. Pop then front element when xj – x_front > k, they can’t be used anymore.
3. Record the max of {xj + yj + (y_front – x_front)}
4. Pop the back element when yj – xj > y_back – x_back, they are smaller and lefter. Won’t be useful anymore.
5. Finally, push the j-th element onto the queue.

Time complexity: O(n)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int findMaxValueOfEquation(vector<vector<int>>& points, int k) {    
    deque<pair<int, int>> q; // {y - x, x} Sort by y - x.
    int ans = INT_MIN;
    for (const auto& p : points) {
      const int xj = p[0];
      const int yj = p[1];
      // Remove invalid points, e.g. xj - xi > k
      while (!q.empty() && xj - q.front().second > k)
        q.pop_front();
      if (!q.empty())
        ans = max(ans, xj + yj + q.front().first);      
      while (!q.empty() && yj - xj >= q.back().first) 
        q.pop_back();
      q.emplace_back(yj - xj, xj);
    }
    return ans;
  }
};

class Solution {
  public int findMaxValueOfEquation(int[][] points, int k) {
    var q = new ArrayDeque<Integer>();
    int ans = Integer.MIN_VALUE;
    for (int i = 0; i < points.length; ++i) {
      int xj = points[i][0];
      int yj = points[i][1];
      
      while (!q.isEmpty() && xj - points[q.getFirst()][0] > k) {
        q.removeFirst();
      }
      
      if (!q.isEmpty()) {
        ans = Math.max(ans, xj + yj 
                + points[q.getFirst()][1] - points[q.getFirst()][0]);
      }
      
      while (!q.isEmpty() && yj - xj 
                >= points[q.getLast()][1] - points[q.getLast()][0]) {
        q.removeLast();
      }
      
      q.offer(i);
    }
    return ans;
  }
}

# Author: Huahua
class Solution:
  def findMaxValueOfEquation(self, points: List[List[int]], k: int) -> int:
    ans = float('-inf')
    q = deque() # {(y - x, x)}
    for x, y in points:
      while q and x - q[0][1] > k: q.popleft()
      if q: ans = max(ans, x + y + q[0][0])
      while q and y - x >= q[-1][0]: q.pop()
      q.append((y - x, x))
    return ans

The post 花花酱 LeetCode 1499. Max Value of Equation appeared first on Huahua's Tech Road.

Given an array of integers nums and an integer limit, return the size of the longest continuous subarray such that the absolute difference between any two elements is less than or equal to limit.

In case there is no subarray satisfying the given condition return 0.

Example 1:

Input: nums = [8,2,4,7], limit = 4
Output: 2 
Explanation: All subarrays are: 
[8] with maximum absolute diff |8-8| = 0 <= 4.
[8,2] with maximum absolute diff |8-2| = 6 > 4. 
[8,2,4] with maximum absolute diff |8-2| = 6 > 4.
[8,2,4,7] with maximum absolute diff |8-2| = 6 > 4.
[2] with maximum absolute diff |2-2| = 0 <= 4.
[2,4] with maximum absolute diff |2-4| = 2 <= 4.
[2,4,7] with maximum absolute diff |2-7| = 5 > 4.
[4] with maximum absolute diff |4-4| = 0 <= 4.
[4,7] with maximum absolute diff |4-7| = 3 <= 4.
[7] with maximum absolute diff |7-7| = 0 <= 4. 
Therefore, the size of the longest subarray is 2.

Example 2:

Input: nums = [10,1,2,4,7,2], limit = 5
Output: 4 
Explanation: The subarray [2,4,7,2] is the longest since the maximum absolute diff is |2-7| = 5 <= 5.

Example 3:

Input: nums = [4,2,2,2,4,4,2,2], limit = 0
Output: 3

Constraints:

• 1 <= nums.length <= 10^5
• 1 <= nums[i] <= 10^9
• 0 <= limit <= 10^9

Solution 1: Sliding Window + TreeSet

Use a treeset to maintain a range of [l, r] such that max(nums[l~r]) – min(nums[l~r]) <= limit.
Every time, we add nums[r] into the tree, and move l towards r to keep the max diff under limit.

Time complexity: O(nlogn)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int longestSubarray(vector<int>& nums, int limit) {
    multiset<int> s;
    int l = 0;
    int ans = 0;
    for (int r = 0; r < nums.size(); ++r) {
      s.insert(nums[r]);
      while (*rbegin(s) - *begin(s) > limit)
        s.erase(s.equal_range(nums[l++]).first);
      ans = max(ans, r - l + 1);
    }
    return ans;
  }
};

Solution 2: Dual Monotonic Queue

Similar to https://zxi.mytechroad.com/blog/dynamic-programming/leetcode-1425-constrained-subset-sum/

We want to maintain a range [l, r] that max(nums[l~r]) – min(nums[l~r]) <= limit, to track the max/min of a range efficiently we could use monotonic queue. One for max and one for min.

Time complexity: O(n)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int longestSubarray(vector<int>& nums, int limit) {
    deque<int> max_q;
    deque<int> min_q;
    int ans = 0;
    int l = 0;
    for (int r = 0; r < nums.size(); ++r) {
      while (!min_q.empty() && nums[r] < min_q.back()) 
        min_q.pop_back();
      while (!max_q.empty() && nums[r] > max_q.back()) 
        max_q.pop_back();
      min_q.push_back(nums[r]);
      max_q.push_back(nums[r]);
      while (max_q.front() - min_q.front() > limit) {
        if (max_q.front() == nums[l]) max_q.pop_front();
        if (min_q.front() == nums[l]) min_q.pop_front();
        ++l;
      }
      ans = max(ans, r - l + 1);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1438. Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit appeared first on Huahua's Tech Road.

Given an integer array nums and an integer k, return the maximum sum of a non-empty subset of that array such that for every two consecutive integers in the subset, nums[i] and nums[j], where i < j, the condition j - i <= k is satisfied.

A subset of an array is obtained by deleting some number of elements (can be zero) from the array, leaving the remaining elements in their original order.

Example 1:

Input: nums = [10,2,-10,5,20], k = 2
Output: 37
Explanation: The subset is [10, 2, 5, 20].

Example 2:

Input: nums = [-1,-2,-3], k = 1
Output: -1
Explanation: The subset must be non-empty, so we choose the largest number.

Example 3:

Input: nums = [10,-2,-10,-5,20], k = 2
Output: 23
Explanation: The subset is [10, -2, -5, 20].

Constraints:

• 1 <= k <= nums.length <= 10^5
• -10^4 <= nums[i] <= 10^4

Solution: DP / Sliding window / monotonic queue

dp[i] := max sum of a subset that include nums[i]
dp[i] := max(dp[i-1], dp[i-2], …, dp[i-k-1], 0) + nums[i]

// Author: Huahua
class Solution {
public:
  int constrainedSubsetSum(vector<int>& nums, int k) {    
    const int n = nums.size();
    vector<int> dp(n);
    multiset<int> s{INT_MIN};
    int ans = INT_MIN;
    for (int i = 0; i < nums.size(); ++i) {
      if (i > k) s.erase(s.equal_range(dp[i - k - 1]).first);
      dp[i] = max(*rbegin(s), 0) + nums[i];
      s.insert(dp[i]);
      ans = max(ans, dp[i]);
    }
    return ans;
  }
};

Use a monotonic queue to track the maximum of a sliding window dp[i-k-1] ~ dp[i-1].

Time complexity: O(n)
Space complexity: O(n)

// Author: Huahua 184 ms
class Solution {
public:
  int constrainedSubsetSum(vector<int>& nums, int k) {
    const int n = nums.size();
    vector<int> dp(n);
    deque<int> q;
    int ans = INT_MIN;
    for (int i = 0; i < nums.size(); ++i) {
      if (i > k && q.front() == i - k - 1)
        q.pop_front();
      dp[i] = (q.empty() ? 0 : max(dp[q.front()], 0))
             + nums[i];
      while (!q.empty() && dp[i] >= dp[q.back()])
        q.pop_back();
      q.push_back(i);
      ans = max(ans, dp[i]);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1425. Constrained Subset Sum appeared first on Huahua's Tech Road.