Find the longest subsequence of nums that meets the following requirements:

• The subsequence is strictly increasing and
• The difference between adjacent elements in the subsequence is at most k.

Return the length of the longest subsequence that meets the requirements.

A subsequence is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.

Example 1:

Input: nums = [4,2,1,4,3,4,5,8,15], k = 3
Output: 5
Explanation:
The longest subsequence that meets the requirements is [1,3,4,5,8].
The subsequence has a length of 5, so we return 5.
Note that the subsequence [1,3,4,5,8,15] does not meet the requirements because 15 - 8 = 7 is larger than 3.

Example 2:

Input: nums = [7,4,5,1,8,12,4,7], k = 5
Output: 4
Explanation:
The longest subsequence that meets the requirements is [4,5,8,12].
The subsequence has a length of 4, so we return 4.

Example 3:

Input: nums = [1,5], k = 1
Output: 1
Explanation:
The longest subsequence that meets the requirements is [1].
The subsequence has a length of 1, so we return 1.

Constraints:

• 1 <= nums.length <= 105
• 1 <= nums[i], k <= 105

Solution: DP + Segment Tree | Max range query

Let dp[i] := length of LIS end with number i.
dp[i] = 1 + max(dp[i-k:i])

Naive dp takes O(n*k) time which will cause TLE.

We can use segment tree to speed up the max range query to log(m), where m is the max value of the array.

Time complexity: O(n*logm)
Space complexity: O(m)

// Author: Huahua
class Solution {
public:
  int lengthOfLIS(vector<int>& nums, int k) {
    const int n = *max_element(begin(nums), end(nums));
    vector<int> dp(2 * (n + 1));
    auto query = [&](int l, int r) -> int {
      int ans = 0;
      for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
        if (l & 1) ans = max(ans, dp[l++]);      
        if (r & 1) ans = max(ans, dp[--r]);
      }
      return ans;
    };
    auto update = [&](int i, int val) -> void {
      dp[i += n] = val;
      while (i > 1) {
        i >>= 1;
        dp[i] = max(dp[i * 2], dp[i * 2 + 1]);
      }
    };        
    int ans = 0;
    for (int x : nums) {
      int cur = 1 + query(max(1, x - k), x);
      update(x, cur);
      ans = max(ans, cur);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2407. Longest Increasing Subsequence II appeared first on Huahua's Tech Road.

Solution 1: Range sum query

Assuming we can collect fruits in range [l, r], we need a fast query to compute the sum of those fruits.

Given startPos and k, we have four options:
1. move i steps to the left
2. move i steps to the left and k – i steps to the right.
3. move i steps to the right
4. move i steps to the right and k – i steps to the left.

We enumerate i steps and calculate maximum range [l, r] covered by each option, and collect all the fruit in that range.

Time complexity: O(m + k)
Space complexity: O(m)
where m = max(max(pos), startPos)

// Author: Huahua
class Solution {
public:
  int maxTotalFruits(vector<vector<int>>& fruits, int startPos, int k) {    
    const int m = max(startPos, (*max_element(begin(fruits), end(fruits)))[0]);
    vector<int> sums(m + 2);   
    for (int i = 0, j = 0; i <= m; ++i) {
      sums[i + 1] += sums[i];
      while (j < fruits.size() && fruits[j][0] == i)        
        sums[i + 1] += fruits[j++][1];      
    }    
    int ans = 0;
    for (int s = 0; s <= k; ++s) {
      if (startPos - s >= 0) {
        int l = startPos - s;
        int r = min(max(startPos, l + (k - s)), m);        
        ans = max(ans, sums[r + 1] - sums[l]);
      }
      if (startPos + s <= m) {
        int r = startPos + s;
        int l = max(0, min(startPos, r - (k - s)));
        ans = max(ans, sums[r + 1] - sums[l]);
      }
    }             
    return ans;
  }
};

Solution 2: Sliding Window

Maintain a window [l, r] such that the steps to cover [l, r] from startPos is less or equal to k.

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

// Author: Huahua
class Solution {
public:
  int maxTotalFruits(vector<vector<int>>& fruits, int startPos, int k) {    
    auto steps = [&](int l, int r) {
      if (r <= startPos)
        return startPos - l;
      else if (l >= startPos)
        return r - startPos;
      else
        return min(startPos + r - 2 * l, 2 * r - startPos - l);
    };
    int ans = 0;
    for (int r = 0, l = 0, cur = 0; r < fruits.size(); ++r) {
      cur += fruits[r][1];
      while (l <= r && steps(fruits[l][0], fruits[r][0]) > k)
        cur -= fruits[l++][1];      
      ans = max(ans, cur);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2106. Maximum Fruits Harvested After at Most K Steps appeared first on Huahua's Tech Road.

You are also given a 0-indexed 2D integer array queries where queries[i] = [lefti, righti] denotes the substring s[lefti...righti] (inclusive). For each query, you need to find the number of plates between candles that are in the substring. A plate is considered between candles if there is at least one candle to its left and at least one candle to its right in the substring.

• For example, s = "||**||**|*", and a query [3, 8] denotes the substring "*||**|". The number of plates between candles in this substring is 2, as each of the two plates has at least one candle in the substring to its left and right.

Return an integer array answer where answer[i] is the answer to the ith query.

Example 1:

Input: s = "**|**|***|", queries = [[2,5],[5,9]]
Output: [2,3]
Explanation:
- queries[0] has two plates between candles.
- queries[1] has three plates between candles.

Example 2:

Input: s = "***|**|*****|**||**|*", queries = [[1,17],[4,5],[14,17],[5,11],[15,16]]
Output: [9,0,0,0,0]
Explanation:
- queries[0] has nine plates between candles.
- The other queries have zero plates between candles.

Constraints:

• 3 <= s.length <= 105
• s consists of '*' and '|' characters.
• 1 <= queries.length <= 105
• queries[i].length == 2
• 0 <= lefti <= righti < s.length

Solution: Binary Search

Store the indices of all candles into an array idx.

For each query q:
1. Find the left most candle whose index is greater or equal to left as l.
2. Find the left most candle whose index is greater than right, choose the previous candle as r.

[idx[l], idx[r]] is the range that are elements between two candles , there are (idx[r] – idx[l] + 1) elements in total and there are (r – l + 1) candles in the range. So the number of plates is (idx[r] – idx[l] + 1) – (r – l + 1) or (idx[r] – idx[l]) – (r – l)

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

// Author: huahua
class Solution {
public:
  vector<int> platesBetweenCandles(string s, vector<vector<int>>& queries) {
    vector<int> idx;
    for (size_t i = 0; i < s.size(); ++i)
      if (s[i] == '|') idx.push_back(i);
    vector<int> ans;
    for (const auto& q : queries) {
      const int l = lower_bound(begin(idx), end(idx), q[0]) - begin(idx);
      const int r = upper_bound(begin(idx), end(idx), q[1]) - begin(idx) - 1;      
      ans.push_back(l >= r ? 0 : (idx[r] - idx[l]) - (r - l));
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2055. Plates Between Candles appeared first on Huahua's Tech Road.

• For example, the minimum absolute difference of the array [5,2,3,7,2] is |2 - 3| = 1. Note that it is not 0 because a[i] and a[j] must be different.

You are given an integer array nums and the array queries where queries[i] = [li, ri]. For each query i, compute the minimum absolute difference of the subarray nums[li...ri] containing the elements of nums between the 0-based indices li and ri (inclusive).

Return an array ans where ans[i] is the answer to the ith query.

A subarray is a contiguous sequence of elements in an array.

The value of |x| is defined as:

• x if x >= 0.
• -x if x < 0.

Example 1:

Input: nums = [1,3,4,8], queries = [[0,1],[1,2],[2,3],[0,3]]
Output: [2,1,4,1]
Explanation: The queries are processed as follows:
- queries[0] = [0,1]: The subarray is [1,3] and the minimum absolute difference is |1-3| = 2.
- queries[1] = [1,2]: The subarray is [3,4] and the minimum absolute difference is |3-4| = 1.
- queries[2] = [2,3]: The subarray is [4,8] and the minimum absolute difference is |4-8| = 4.
- queries[3] = [0,3]: The subarray is [1,3,4,8] and the minimum absolute difference is |3-4| = 1.

Example 2:

Input: nums = [4,5,2,2,7,10], queries = [[2,3],[0,2],[0,5],[3,5]]
Output: [-1,1,1,3]
Explanation: The queries are processed as follows:
- queries[0] = [2,3]: The subarray is [2,2] and the minimum absolute difference is -1 because all the
  elements are the same.
- queries[1] = [0,2]: The subarray is [4,5,2] and the minimum absolute difference is |4-5| = 1.
- queries[2] = [0,5]: The subarray is [4,5,2,2,7,10] and the minimum absolute difference is |4-5| = 1.
- queries[3] = [3,5]: The subarray is [2,7,10] and the minimum absolute difference is |7-10| = 3.

Constraints:

• 2 <= nums.length <= 105
• 1 <= nums[i] <= 100
• 1 <= queries.length <= 2 * 104
• 0 <= li < ri < nums.length

Solution: Binary Search

Since the value range of num is quiet small [1~100], we can store the indices for each value.
[2, 1, 2, 2, 3] => {1: [1], 2: [0, 2, 3]: 3: [4]}.

For each query, we try all possible value b. Check whether b is the query range using binary search, we also keep tracking the previous available value a, ans will be min{b – a}.

Time complexity: O(n + q * 100 * log(n))
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  vector<int> minDifference(vector<int>& nums, vector<vector<int>>& queries) {    
    constexpr int kMax = 100;
    const int n = nums.size();
    vector<vector<int>> idx(kMax + 1);
    for (int i = 0; i < n; ++i)
      idx[nums[i]].push_back(i);
    vector<int> ans;
    for (const auto& q: queries) {      
      int diff = INT_MAX;
      for (int a = 0, b = 1; b <= kMax; ++b) {
        auto it = lower_bound(begin(idx[b]), end(idx[b]), q[0]);
        if (it == end(idx[b]) || *it > q[1]) continue;
        if (a) diff = min(diff, b - a);
        a = b;
      }
      ans.push_back(diff == INT_MAX ? -1 : diff);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1906. Minimum Absolute Difference Queries appeared first on Huahua's Tech Road.

Example 1:

Input: mat = [[1,1,3,2,4,3,2],[1,1,3,2,4,3,2],[1,1,3,2,4,3,2]], threshold = 4
Output: 2
Explanation: The maximum side length of square with sum less than 4 is 2 as shown.

Example 2:

Input: mat = [[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2]], threshold = 1
Output: 0

Example 3:

Input: mat = [[1,1,1,1],[1,0,0,0],[1,0,0,0],[1,0,0,0]], threshold = 6
Output: 3

Example 4:

Input: mat = [[18,70],[61,1],[25,85],[14,40],[11,96],[97,96],[63,45]], threshold = 40184
Output: 2

Constraints:

• 1 <= m, n <= 300
• m == mat.length
• n == mat[i].length
• 0 <= mat[i][j] <= 10000
• 0 <= threshold <= 10^5

Solution: DP + Brute Force

Precompute the sums of sub-matrixes whose left-top corner is at (0,0).

Try all possible left-top corner and sizes.

Time complexity: O(m*n*min(m,n))
Space complexity: O(m*n)

// Author: Huahua, 148 ms
class Solution {
public:
  int maxSideLength(vector<vector<int>>& mat, int threshold) {
    const int m = mat.size();
    const int n = mat[0].size();
    
    vector<vector<int>> dp(m + 1, vector<int>(n + 1));
    for (int y = 1; y <= m; ++y)
      for (int x = 1; x <= n; ++x)
        dp[y][x] = dp[y][x - 1] + dp[y - 1][x]  - dp[y - 1][x - 1] + mat[y - 1][x - 1];
    
    auto rangeSum = [&](int x1, int y1, int x2, int y2) {
      return dp[y2][x2] - dp[y2][x1 - 1] - dp[y1 - 1][x2] + dp[y1 - 1][x1 - 1];
    };
    
    int ans = 0;
    for (int y = 1; y <= m; ++y)
      for (int x = 1; x <= n; ++x)
        for (int k = 0; y + k <= m && x + k <= n; ++k) {
          if (rangeSum(x, y, x + k, y + k) > threshold) break;
          ans = max(ans, k + 1);
        }
    return ans;  
  }
};

Solution 2: Binary Search

Search for the smallest size k that is greater than the threshold, ans = k – 1.

// Author: Huahua, 116 ms
class Solution {
public:
  int maxSideLength(vector<vector<int>>& mat, int threshold) {
    const int m = mat.size();
    const int n = mat[0].size();
    
    vector<vector<int>> dp(m + 1, vector<int>(n + 1));
    for (int y = 1; y <= m; ++y)
      for (int x = 1; x <= n; ++x)
        dp[y][x] = dp[y][x - 1] + dp[y - 1][x]  - dp[y - 1][x - 1] + mat[y - 1][x - 1];
    
    auto rangeSum = [&](int x1, int y1, int x2, int y2) {
      return dp[y2][x2] - dp[y2][x1 - 1] - dp[y1 - 1][x2] + dp[y1 - 1][x1 - 1];
    };
    
    int ans = 0;
    for (int y = 1; y <= m; ++y)
      for (int x = 1; x <= n; ++x) {
        int l = 0;
        int r = min(m - y, n - x) + 1;
        while (l < r) {
          int m = l + (r - l) / 2;
          // Find smllest l that > threshold, ans = (l + 1) - 1
          if (rangeSum(x, y, x + m, y + m) > threshold)
            r = m;
          else
            l = m + 1;
        }
        ans = max(ans, (l + 1) - 1);
      }
    return ans;  
  }
};

Solution 3: Bounded Search

Time complexity: O(m*n + min(m,n))

// Author: Huahua, 148 ms
class Solution {
public:
  int maxSideLength(vector<vector<int>>& mat, int threshold) {
    const int m = mat.size();
    const int n = mat[0].size();
    
    vector<vector<int>> dp(m + 1, vector<int>(n + 1));
    for (int y = 1; y <= m; ++y)
      for (int x = 1; x <= n; ++x)
        dp[y][x] = dp[y][x - 1] + dp[y - 1][x]  - dp[y - 1][x - 1] + mat[y - 1][x - 1];
    
    auto rangeSum = [&](int x1, int y1, int x2, int y2) {
      return dp[y2][x2] - dp[y2][x1 - 1] - dp[y1 - 1][x2] + dp[y1 - 1][x1 - 1];
    };
    
    int ans = 0;
    for (int y = 1; y <= m; ++y)
      for (int x = 1; x <= n; ++x)
        for (int k = ans; y + k <= m && x + k <= n; ++k) {
          if (rangeSum(x, y, x + k, y + k) > threshold) break;
          ans = max(ans, k + 1);
        }
    return ans;  
  }
};

The post 花花酱 LeetCode 1292. Maximum Side Length of a Square with Sum Less than or Equal to Threshold appeared first on Huahua's Tech Road.

• MajorityChecker(int[] arr) constructs an instance of MajorityChecker with the given array arr;
• int query(int left, int right, int threshold) has arguments such that:
  • 0 <= left <= right < arr.length representing a subarray of arr;
  • 2 * threshold > right - left + 1, ie. the threshold is always a strict majority of the length of the subarray

Each query(...) returns the element in arr[left], arr[left+1], ..., arr[right]that occurs at least threshold times, or -1 if no such element exists.

Example:

MajorityChecker majorityChecker = new MajorityChecker([1,1,2,2,1,1]);
majorityChecker.query(0,5,4); // returns 1
majorityChecker.query(0,3,3); // returns -1
majorityChecker.query(2,3,2); // returns 2

Constraints:

• 1 <= arr.length <= 20000
• 1 <= arr[i] <= 20000
• For each query, 0 <= left <= right < len(arr)
• For each query, 2 * threshold > right - left + 1
• The number of queries is at most 10000

Solution 0: Brute Force TLE

For each range, find the majority element in O(n) time / O(n) or O(1) space.

Solution 1: Cache the range result

Cache the result for each range: mode and frequency

Time complexity:
init: O(1)
query: O(|right – left|)
total queries: O(sum(right_i – left_i)), right_i, left_i are bounds of unique ranges.
Space complexity:
init: O(1)
query: O(20000)

// Author: Huahua, 568ms, 39.6 MB
class MajorityChecker {
public:
  MajorityChecker(vector<int>& arr):nums(arr) {}

  int query(int left, int right, int threshold) {        
    int key = left * 20000 + right;
    if (!seen.count(key)) {
      int c[20001] = {0};
      int best = (right - left) / 2;
      int best_num = -1;
      for (int i = left; i <= right; ++i) {
        if (++c[nums[i]] > best) {
          best = c[nums[i]];
          best_num = nums[i];
        }
      }
      seen[key] = {best_num, best};
    }
    return seen[key].second >= threshold ? seen[key].first : -1;
  }
private:
  unordered_map<int, pair<int, int>> seen;
  const vector<int>& nums;
};

Solution 2: HashTable + binary search

Preprocessing: use a hashtable to store the indices of each element. And sort by frequency of the element in descending order.
Query: iterator over (total_freq, num) pair, if freq >= threshold do a binary search to find the frequency of the given range for num in O(logn).

Time complexity:
Init: O(nlogn)
Query: worst case: O(nlogn), best case: O(logn)

// Author: Huahua, 156 ms, 44.7MB
class MajorityChecker {
public:
  MajorityChecker(vector<int>& arr):nums(arr) {
    const int max_n = *max_element(begin(nums), end(nums));
    m = vector<vector<int>>(max_n + 1);
    for (int i = 0; i < nums.size(); ++i) m[nums[i]].push_back(i);    
    for (int n = 1; n <= max_n; ++n) {
      if (m[n].size()) f.emplace_back(m[n].size(), n);
    }
    sort(rbegin(f), rend(f));    
  }

  int query(int left, int right, int threshold) {
    for (const auto& p : f) {
      if (p.first < threshold) return -1;
      int n = p.second;
      const auto& idx = m[n];
      int count = upper_bound(begin(idx), end(idx), right) - lower_bound(begin(idx), end(idx), left);
      if (count >= threshold) return n;
    }
    return -1;
  }
private:
  const vector<int>& nums;
  vector<vector<int>> m; // num -> {indices}
  vector<pair<int, int>> f; // {freq, num}
};

Solution 2+: Randomization

Randomly pick a num in range [left, right] and check its freq, try k (e.g. 30) times. If a majority element exists, you should find it with error rate 1/2^k.

Time complexity:
Init: O(n)
Query: O(30 * logn)
Space complexity: O(n)

// Author: Huahua, 240ms, 45.6MB
class MajorityChecker {
public:
  MajorityChecker(vector<int>& arr):nums(arr) {  
    for (int i = 0; i < nums.size(); ++i) m[nums[i]].push_back(i);    
  }

  int query(int left, int right, int threshold) {    
    for (int i = 0; i < 30; ++i) {
      int n = nums[rand() % (right - left + 1) + left];
      const auto& idx = m[n];
      int count = upper_bound(begin(idx), end(idx), right) - lower_bound(begin(idx), end(idx), left);
      if (count >= threshold) return n;
    }
    return -1;
  }
private:
  unordered_map<int, vector<int>> m; // num -> {indices}  
  const vector<int>& nums;
};

The post 花花酱 LeetCode 1157. Online Majority Element In Subarray appeared first on Huahua's Tech Road.

Problem

Given an integer array nums, find the sum of the elements between indices i and j (i ≤ j), inclusive.

Example:

Given nums = [-2, 0, 3, -5, 2, -1]

sumRange(0, 2) -> 1
sumRange(2, 5) -> -1
sumRange(0, 5) -> -3

Note:

1. You may assume that the array does not change.
2. There are many calls to sumRange function.

Solution: Prefix sum

sums[i] = nums[0] + nums[1] + … + nums[i]

sumRange(i, j) = sums[j] – sums[i – 1]

Time complexity: pre-compute: O(n), query: O(1)

Space complexity: O(n)

// Author: Huahua
// Running time: 112 ms
class NumArray {
public:
  NumArray(vector<int> nums): sums_(nums) {      
    if (nums.empty()) return;            
    for (int i = 1; i < nums.size();++i)
      sums_[i] += sums_[i - 1];
  }

  int sumRange(int i, int j) {
    if (i == 0) return sums_[j];
    return sums_[j] - sums_[i-1];
  }
private:    
  vector<int> sums_;
};

The post 花花酱 LeetCode 303. Range Sum Query – Immutable appeared first on Huahua's Tech Road.

https://leetcode.com/problems/range-sum-query-2d-immutable/description/

Problem:

Given matrix = [
  [3, 0, 1, 4, 2],
  [5, 6, 3, 2, 1],
  [1, 2, 0, 1, 5],
  [4, 1, 0, 1, 7],
  [1, 0, 3, 0, 5]
]

sumRegion(2, 1, 4, 3) : 8
sumRegion(1, 1, 2, 2) : 11
sumRegion(1, 2, 2, 4) : 12

// Author: Huahua
// Time complexity: 
// constructor: O(n^2)
// sumRegion: O(1)
// Running time: 22 ms 9/2017
class NumMatrix {
public:
    NumMatrix(const vector<vector<int>>& matrix) {
        sums_.clear();
        
        if (matrix.empty()) return;
        
        int m = matrix.size();        
        int n = matrix[0].size();
        
        // sums_[i][j] = sum(matrix[0][0] ~ matrix[i-1][j-1])
        sums_ = vector<vector<int>>(m + 1, vector<int>(n + 1, 0));
        for (int i = 1; i <= m; ++i)
            for (int j = 1; j <= n; ++j)
                sums_[i][j] = matrix[i - 1][j - 1]
                            + sums_[i - 1][j]
                            + sums_[i][j - 1]
                            - sums_[i - 1][j - 1];
    }
    
    int sumRegion(int row1, int col1, int row2, int col2) {        
        return sums_[row2 + 1][col2 + 1]
             - sums_[row2 + 1][col1]
             - sums_[row1][col2 + 1]
             + sums_[row1][col1];
    }
private:
    vector<vector<int>> sums_;
};

/**
 * Your NumMatrix object will be instantiated and called as such:
 * NumMatrix obj = new NumMatrix(matrix);
 * int param_1 = obj.sumRegion(row1,col1,row2,col2);
 */

The post 花花酱 LeetCode 304. Range Sum Query 2D – Immutable appeared first on Huahua's Tech Road.