A smooth descent period of a stock consists of one or more contiguous days such that the price on each day is lower than the price on the preceding day by exactly 1. The first day of the period is exempted from this rule.

Return the number of smooth descent periods.

Example 1:

Input: prices = [3,2,1,4]
Output: 7
Explanation: There are 7 smooth descent periods:
[3], [2], [1], [4], [3,2], [2,1], and [3,2,1]
Note that a period with one day is a smooth descent period by the definition.

Example 2:

Input: prices = [8,6,7,7]
Output: 4
Explanation: There are 4 smooth descent periods: [8], [6], [7], and [7]
Note that [8,6] is not a smooth descent period as 8 - 6 ≠ 1.

Example 3:

Input: prices = [1]
Output: 1
Explanation: There is 1 smooth descent period: [1]

Constraints:

• 1 <= prices.length <= 105
• 1 <= prices[i] <= 105

Solution: DP

Same as longest decreasing subarray.

dp[i] := length of longest smoothing subarray ends with nums[i].

dp[i] = dp[i – 1] + 1 if nums[i] + 1 = nums[i – 1] else 1

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

// Author: Huahua
class Solution {
public:
  long long getDescentPeriods(vector<int>& prices) {
    const int n = prices.size();
    vector<long long> dp(n, 1);
    long long ans = 1;
    for (int i = 1; i < n; ++i) {
      if (prices[i] - prices[i - 1] == -1)
        dp[i] = dp[i - 1] + 1;    
      ans += dp[i];
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2110. Number of Smooth Descent Periods of a Stock appeared first on Huahua's Tech Road.

Solution 0: Brute force [TLE]

Enumerate all subarrays, for each one, find min and max.

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

Solution 1: Prefix min/max

We can use prefix technique to extend the array while keep tracking the min/max of the subarray.

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

// Author: Huahua
class Solution {
public:
  long long subArrayRanges(vector<int>& nums) {
    const int n = nums.size();    
    long long ans = 0;
    for (int i = 0; i < n; ++i) {
      int lo = nums[i];
      int hi = nums[i];
      for (int j = i + 1; j < n; ++j) {
        lo = min(lo, nums[j]);
        hi = max(hi, nums[j]);
        ans += (hi - lo);
      }
    }
    return ans;
  }
};

Solution 2: Monotonic stack

This problem can be reduced to 花花酱 LeetCode 907. Sum of Subarray Minimums

Just need to run twice one for sum of mins and another for sum of maxs.

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

// Author: Huahua
class Solution {
public:
  long long subArrayRanges(vector<int>& nums) {
    const int n = nums.size();
    auto sumOf = [&](function<bool(int, int)> op) {
      long long ans = 0;
      stack<int> s;
      for (long long i = 0; i <= n; ++i) {
        while (!s.empty() and (i == n or op(nums[s.top()], nums[i]))) {
          long long k = s.top(); s.pop();
          long long j = s.empty() ? -1 : s.top();
          ans += nums[k] * (i - k) * (k - j);
        }
        s.push(i);
      }
      return ans;
    };
    return sumOf(less<int>()) - sumOf(greater<int>());
  }
};

The post 花花酱 LeetCode 2104. Sum of Subarray Ranges appeared first on Huahua's Tech Road.

The testcases will be generated such that the answer is unique.

A substring is a contiguous sequence of characters within the string.

Example 1:

Input: s = "ADOBECODEBANC", t = "ABC"
Output: "BANC"
Explanation: The minimum window substring "BANC" includes 'A', 'B', and 'C' from string t.

Example 2:

Input: s = "a", t = "a"
Output: "a"
Explanation: The entire string s is the minimum window.

Example 3:

Input: s = "a", t = "aa"
Output: ""
Explanation: Both 'a's from t must be included in the window.
Since the largest window of s only has one 'a', return empty string.

Constraints:

• m == s.length
• n == t.length
• 1 <= m, n <= 105
• s and t consist of uppercase and lowercase English letters.

Follow up: Could you find an algorithm that runs in O(m + n) time?

Solution: Hashtable + Two Pointers

Use a hashtable to store the freq of characters we need to match for t.

Use (i, j) to track a subarray that contains all the chars in t.

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

// Author: Huahua
class Solution {
public:
  string minWindow(string s, string t) {
    const int n = s.length();
    const int m = t.length();
    vector<int> freq(128);
    for (char c : t) ++freq[c];
    int start = 0;
    int l = INT_MAX;    
    for (int i = 0, j = 0, left = m; j < n; ++j) {
      if (--freq[s[j]] >= 0) --left;
      while (left == 0) {
        if (j - i + 1 < l) {
          l = j - i + 1;
          start = i;
        }
        if (++freq[s[i++]] == 1) ++left;
      }
    }
    return l == INT_MAX ? "" : s.substr(start, l);
  }
};

The post 花花酱 LeetCode 76. Minimum Window Substring appeared first on Huahua's Tech Road.

It is guaranteed that the answer will fit in a 32-bit integer.

A subarray is a contiguous subsequence of the array.

Example 1:

Input: nums = [2,3,-2,4]
Output: 6
Explanation: [2,3] has the largest product 6.

Example 2:

Input: nums = [-2,0,-1]
Output: 0
Explanation: The result cannot be 2, because [-2,-1] is not a subarray.

Constraints:

• 1 <= nums.length <= 2 * 104
• -10 <= nums[i] <= 10
• The product of any prefix or suffix of nums is guaranteed to fit in a 32-bit integer.

Solution: Track high and low

Compute the low / high of prefix product, reset if nums[i] is higher than high or lower than low.

Swap low and high if nums[i] is a negative number.

e.g. [2, 3, -1, 8, -2]
nums[i] = 2, low = 2, high = 2
nums[i] = 3, low = 3, high = 2 * 3 = 6
nums[i] = -1, low = 6 * -1 = -6, high = -1
nums[i] = 8, low = -6 * 8 = -48, high = 8
nums[i] = -2, low = 8*-2 = -16, high = -48 * -2 = 96

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

// Author: Huahua
class Solution {
public:
  int maxProduct(vector<int>& nums) {   
    int ans = nums[0];
    for (int i = 1, h = ans, l = ans; i < nums.size(); ++i) {
      if (nums[i] < 0) swap(l, h);
      l = min(nums[i], nums[i] * l);
      h = max(nums[i], nums[i] * h);
      ans = max(ans, h);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 152. Maximum Product Subarray appeared first on Huahua's Tech Road.

nums is considered continuous if both of the following conditions are fulfilled:

• All elements in nums are unique.
• The difference between the maximum element and the minimum element in nums equals nums.length - 1.

For example, nums = [4, 2, 5, 3] is continuous, but nums = [1, 2, 3, 5, 6] is not continuous.

Return the minimum number of operations to make numscontinuous.

Example 1:

Input: nums = [4,2,5,3]
Output: 0
Explanation: nums is already continuous.

Example 2:

Input: nums = [1,2,3,5,6]
Output: 1
Explanation: One possible solution is to change the last element to 4.
The resulting array is [1,2,3,5,4], which is continuous.

Example 3:

Input: nums = [1,10,100,1000]
Output: 3
Explanation: One possible solution is to:
- Change the second element to 2.
- Change the third element to 3.
- Change the fourth element to 4.
The resulting array is [1,2,3,4], which is continuous.

Constraints:

• 1 <= nums.length <= 105
• 1 <= nums[i] <= 109

Solution: Sliding Window

Remove duplicates and sort the numbers.
Try using nums[i] as the min number of the final array.
window [i, j), max – min < n, then change the rest of array to fit into or append after the window, which takes n – (j – i) steps.
e.g. input = [10, 3, 1, 4, 5, 6, 6, 6, 11, 15] => sorted + unique => [1, 3, 4, 5, 6, 10, 11, 15]
n = 10, window = [3, 4, 5, 6, 10, 11], max = 11, min = 3, max – min = 8 < 10
Final array = [3, 4, 5, 6, 1->7, 6₂->8, 6₃->9, 10, 11, 15->12]
Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int minOperations(vector<int>& A) {
    const int n = A.size();
    sort(begin(A), end(A));
    A.erase(unique(begin(A), end(A)), end(A));    
    int ans = INT_MAX;
    for (int i = 0, j = 0, m = A.size(); i < m; ++i) {
      while (j < m && A[j] < A[i] + n) ++j;
      ans = min(ans, n - (j - i));
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2009. Minimum Number of Operations to Make Array Continuous appeared first on Huahua's Tech Road.

Return the maximum absolute sum of any (possibly empty) subarray of nums.

Note that abs(x) is defined as follows:

• If x is a negative integer, then abs(x) = -x.
• If x is a non-negative integer, then abs(x) = x.

Example 1:

Input: nums = [1,-3,2,3,-4]
Output: 5
Explanation: The subarray [2,3] has absolute sum = abs(2+3) = abs(5) = 5.

Example 2:

Input: nums = [2,-5,1,-4,3,-2]
Output: 8
Explanation: The subarray [-5,1,-4] has absolute sum = abs(-5+1-4) = abs(-8) = 8.

Constraints:

• 1 <= nums.length <= 105
• -104 <= nums[i] <= 104

Solution: Prefix Sum

ans = max{abs(prefix_sum[i] – max(prefix_sum[0:i])), abs(prefix_sum – min(prefix_sum[0:i])}

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

// Author: Huahua
class Solution {
public:
  int maxAbsoluteSum(vector<int>& nums) {
    int lo = 0;
    int hi = 0;
    int s = 0;
    int ans = 0;
    for (int x : nums) {
      s += x;
      ans = max({ans, abs(s - lo), abs(s - hi)});
      hi = max(hi, s);
      lo = min(lo, s);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1749. Maximum Absolute Sum of Any Subarray appeared first on Huahua's Tech Road.

Return the maximum number of non-empty non-overlapping subarrays such that the sum of values in each subarray is equal to target.

Example 1:

Input: nums = [1,1,1,1,1], target = 2
Output: 2
Explanation: There are 2 non-overlapping subarrays [1,1,1,1,1] with sum equals to target(2).

Example 2:

Input: nums = [-1,3,5,1,4,2,-9], target = 6
Output: 2
Explanation: There are 3 subarrays with sum equal to 6.
([5,1], [4,2], [3,5,1,4,2,-9]) but only the first 2 are non-overlapping.

Example 3:

Input: nums = [-2,6,6,3,5,4,1,2,8], target = 10
Output: 3

Example 4:

Input: nums = [0,0,0], target = 0
Output: 3

Constraints:

• 1 <= nums.length <= 10^5
• -10^4 <= nums[i] <= 10^4
• 0 <= target <= 10^6

Solution: Prefix Sum + DP

Use a hashmap index to record the last index when a given prefix sum occurs.
dp[i] := max # of non-overlapping subarrays of nums[0~i], nums[i] is not required to be included.
dp[i+1] = max(dp[i], // skip nums[i]
dp[index[sum – target] + 1] + 1) // use nums[i] to form a new subarray
ans = dp[n]

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

class Solution {
public:
  int maxNonOverlapping(vector<int>& nums, int target) {
    const int n = nums.size();
    vector<int> dp(n + 1, 0); // ans at nums[i];
    unordered_map<int, int> index; // {prefix sum -> last_index}
    index[0] = -1;    
    int sum = 0;
    for (int i = 0; i < n; ++i) {
      sum += nums[i];
      int t = sum - target;
      dp[i + 1] = dp[i]; 
      if (index.count(t))
        dp[i + 1] = max(dp[i + 1], dp[index[t] + 1] + 1);
      index[sum] = i;      
    }
    return dp[n];
  }
};

The post 花花酱 LeetCode 1546. Maximum Number of Non-Overlapping Subarrays With Sum Equals Target appeared first on Huahua's Tech Road.

Return the number of substrings with all characters 1’s.

Since the answer may be too large, return it modulo 10^9 + 7.

Example 1:

Input: s = "0110111"
Output: 9
Explanation: There are 9 substring in total with only 1's characters.
"1" -> 5 times.
"11" -> 3 times.
"111" -> 1 time.

Example 2:

Input: s = "101"
Output: 2
Explanation: Substring "1" is shown 2 times in s.

Example 3:

Input: s = "111111"
Output: 21
Explanation: Each substring contains only 1's characters.

Example 4:

Input: s = "000"
Output: 0

Constraints:

• s[i] == '0' or s[i] == '1'
• 1 <= s.length <= 10^5

Solution: DP / Prefix Sum

dp[i] := # of all 1 subarrays end with s[i].
dp[i] = dp[i-1] if s[i] == ‘1‘ else 0
ans = sum(dp)
s=1101
dp[0] = 1 // 1
dp[1] = 2 // 11, *1
dp[2] = 0 // None
dp[3] = 1 // ***1
ans = 1 + 2 + 1 = 5

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

class Solution {
public:
  int numSub(string s) {
    constexpr int kMod = 1e9 + 7;
    long ans = 0;
    vector<int> dp(s.length() + 1);
    for (int i = 1; i <= s.length(); ++i) {
      dp[i] = s[i - 1] == '1' ? dp[i - 1] + 1 : 0;
      ans += dp[i];
    }
    return ans % kMod;
  }
};

dp[i] only depends on dp[i-1], we can reduce the space complexity to O(1)

class Solution {
public:
  int numSub(string s) {
    constexpr int kMod = 1e9 + 7;
    long ans = 0;
    int cur = 0;
    for (char c : s) {
      cur = c == '1' ? cur + 1 : 0;
      ans += cur;
    }
    return ans % kMod;
  }
};

class Solution {
  public int numSub(String s) {
    final int kMod = 1_000_000_000 + 7;
    int ans = 0;
    int cur = 0;
    for (int i = 0; i < s.length(); ++i) {
      cur = s.charAt(i) == '1' ? cur + 1 : 0;
      ans = (ans + cur) % kMod;
    }
    return ans;
  }
}

class Solution:
  def numSub(self, s: str) -> int:
    kMod = 10**9 + 7
    ans = 0
    cur = 0
    for c in s:
      cur = cur + 1 if c == '1' else 0
      ans += cur
    return ans % kMod

The post 花花酱 LeetCode 1513. Number of Substrings With Only 1s appeared first on Huahua's Tech Road.

Given a string s of lowercase letters, you need to find the maximum number of non-empty substrings of s that meet the following conditions:

1. The substrings do not overlap, that is for any two substrings s[i..j] and s[k..l], either j < k or i > l is true.
2. A substring that contains a certain character c must also contain all occurrences of c.

Find the maximum number of substrings that meet the above conditions. If there are multiple solutions with the same number of substrings, return the one with minimum total length. It can be shown that there exists a unique solution of minimum total length.

Notice that you can return the substrings in any order.

Example 1:

Input: s = "adefaddaccc"
Output: ["e","f","ccc"]
Explanation: The following are all the possible substrings that meet the conditions:
[
  "adefaddaccc"
  "adefadda",
  "ef",
  "e",
  "f",
  "ccc",
]
If we choose the first string, we cannot choose anything else and we'd get only 1. If we choose "adefadda", we are left with "ccc" which is the only one that doesn't overlap, thus obtaining 2 substrings. Notice also, that it's not optimal to choose "ef" since it can be split into two. Therefore, the optimal way is to choose ["e","f","ccc"] which gives us 3 substrings. No other solution of the same number of substrings exist.

Example 2:

Input: s = "abbaccd"
Output: ["d","bb","cc"]
Explanation: Notice that while the set of substrings ["d","abba","cc"] also has length 3, it's considered incorrect since it has larger total length.

Constraints:

• 1 <= s.length <= 10^5
• s contains only lowercase English letters.

Solution: Greedy

Observation: If a valid substring contains shorter valid strings, ignore the longer one and use the shorter one.
e.g. “abbeefba” is a valid substring, however, it includes “bbeefb”, “ee”, “f” three valid substrings, thus it won’t be part of the optimal solution, since we can always choose a shorter one, with potential to have one or more non-overlapping substrings. For “bbeefb”, again it includes “ee” and “f”, so it won’t be optimal either. Thus, the optimal ones are “ee” and “f”.

1. We just need to record the first and last occurrence of each character
2. When we meet a character for the first time we must include everything from current pos to it’s last position. e.g. “abbeefba” | ccc, from first ‘a’ to last ‘a’, we need to cover “abbeefba”
3. If any character in that range has larger end position, we must extend the string. e.g. “abcabbcc” | efg, from first ‘a’ to last ‘a’, we have characters ‘b’ and ‘c’, so we have to extend the string to cover all ‘b’s and ‘c’s. Our first valid substring extended from “abca” to “abcabbcc”.
4. If any character in the covered range has a smallest first occurrence, then it’s an invalid substring. e.g. ab | “cbc”, from first ‘c’ to last ‘c’, we have ‘b’, but ‘b’ is not fully covered, thus “cbc” is an invalid substring.
5. For the first valid substring, we append it to the ans array. “abbeefba” => ans = [“abbeefba”]
6. If we find a shorter substring that is full covered by the previous valid substring, we replace that substring with the shorter one. e.g.
   “abbeefba” | ccc => ans = [“abbeefba”]
   “abbeefba” | ccc => ans = [“bbeefb”]
   “abbeefba” | ccc => ans = [“ee”]
7. If the current substring does not overlap with previous one, append it to ans array.
   “abbeefba” | ccc => ans = [“ee”]
   “abbeefba” | ccc => ans = [“ee”, “f”]
   “abbeefbaccc” => ans = [“ee”, “f”, “ccc”]

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

// Author: Huahua
class Solution {
public:
  vector<string> maxNumOfSubstrings(const string& s) {
    const int n = s.length();    
    vector<int> l(26, INT_MAX);
    vector<int> r(26, INT_MIN);
    for (int i = 0; i < n; ++i) {
      l[s[i] - 'a'] = min(l[s[i] - 'a'], i);
      r[s[i] - 'a'] = max(r[s[i] - 'a'], i);
    }
    auto extend = [&](int i) -> int {      
      int p = r[s[i] - 'a'];
      for (int j = i; j <= p; ++j) {
        if (l[s[j] - 'a'] < i) // invalid substring
          return -1; // e.g. a|"ba"...b
        p = max(p, r[s[j] - 'a']);
      }
      return p;
    };
    
    vector<string> ans;
    int last = -1;
    for (int i = 0; i < n; ++i) {
      if (i != l[s[i] - 'a']) continue;
      int p = extend(i);
      if (p == -1) continue;
      if (i > last) ans.push_back("");
      ans.back() = s.substr(i, p - i + 1);
      last = p;      
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1520. Maximum Number of Non-Overlapping Substrings appeared first on Huahua's Tech Road.

Given the array nums consisting of n positive integers. You computed the sum of all non-empty continous subarrays from the array and then sort them in non-decreasing order, creating a new array of n * (n + 1) / 2 numbers.

Return the sum of the numbers from index left to index right (indexed from 1), inclusive, in the new array. Since the answer can be a huge number return it modulo 10^9 + 7.

Example 1:

Input: nums = [1,2,3,4], n = 4, left = 1, right = 5
Output: 13 
Explanation: All subarray sums are 1, 3, 6, 10, 2, 5, 9, 3, 7, 4. After sorting them in non-decreasing order we have the new array [1, 2, 3, 3, 4, 5, 6, 7, 9, 10]. The sum of the numbers from index le = 1 to ri = 5 is 1 + 2 + 3 + 3 + 4 = 13. 

Example 2:

Input: nums = [1,2,3,4], n = 4, left = 3, right = 4
Output: 6
Explanation: The given array is the same as example 1. We have the new array [1, 2, 3, 3, 4, 5, 6, 7, 9, 10]. The sum of the numbers from index le = 3 to ri = 4 is 3 + 3 = 6.

Example 3:

Input: nums = [1,2,3,4], n = 4, left = 1, right = 10
Output: 50

Constraints:

• 1 <= nums.length <= 10^3
• nums.length == n
• 1 <= nums[i] <= 100
• 1 <= left <= right <= n * (n + 1) / 2

Solution 1: Brute Force

Find sums of all the subarrays and sort the values.

Time complexity: O(n^2logn)
Space complexity: O(n^2)

// Author: Huahua
class Solution {
public:
  int rangeSum(vector<int>& nums, int n, int left, int right) {
    constexpr int kMod = 1e9 + 7;
    vector<int> sums;
    for (int i = 0; i < n; ++i)      
      for (int j = i, sum = 0; j < n; ++j)
        sums.push_back(sum += nums[j]);
    sort(begin(sums), end(sums));
    return accumulate(begin(sums) + left - 1, begin(sums) + right, 0LL) % kMod;
  }
};

// Author: Huahua
class Solution {
  public int rangeSum(int[] nums, int n, int left, int right) {
    final int kMod = (int)(1e9 + 7);
    int[] sums = new int[n * (n + 1) / 2];
    int idx = 0;
    for (int i = 0; i < n; ++i)
      for (int j = i, sum = 0; j < n; ++j, ++idx)
        sums[idx] = sum += nums[j];
    Arrays.sort(sums);
    int ans = 0;
    for (int i = left; i <= right; ++i)
      ans = (ans + sums[i - 1]) % kMod;
    return ans;
  }
}

# Author: Huahua
class Solution:
  def rangeSum(self, nums: List[int], n: int, left: int, right: int) -> int:
    sums = []
    for i in range(n):
      s = 0
      for j in range(i, n):
        s += nums[j]
        sums.append(s)
    sums.sort()
    return sum(sums[left - 1:right])

Solution 2: Priority Queue / Min Heap

For each subarray, start with one element e.g nums[i], put them into a priority queue (min heap). Each time, we have the smallest subarray sum, and extend that subarray and put the new sum back into priority queue. Thought it has the same time complexity as the brute force one in worst case, but space complexity can be reduce to O(n).

Time complexity: O(n^2logn)
Space complexity: O(n)

struct Entry {
  int sum;
  int i;
  bool operator<(const Entry& e) const { return sum > e.sum; }
};

class Solution {
public:
  int rangeSum(vector<int>& nums, int n, int left, int right) {
    constexpr int kMod = 1e9 + 7;
    priority_queue<Entry> q; // Sort by e.sum in descending order.
    for (int i = 0; i < n; ++i)
      q.push({nums[i], i});
    long ans = 0;
    for (int j = 1; j <= right; ++j) {
      const auto e = std::move(q.top()); q.pop();
      if (j >= left) ans += e.sum;
      if (e.i + 1 < n) q.push({e.sum + nums[e.i + 1], e.i + 1});
    }
    return ans % kMod;
  }
};

import java.util.AbstractMap;
class Solution {
  public int rangeSum(int[] nums, int n, int left, int right) {
    final int kMod = (int)(1e9 + 7);
    var q = new PriorityQueue<Map.Entry<Integer, Integer>>((a, b) -> a.getKey() - b.getKey());
    for (int i = 0; i < n; ++i)
      q.offer(new AbstractMap.SimpleEntry<>(nums[i], i));
    
    int ans = 0;
    for (int k = 1; k <= right; ++k) {      
      var e = q.poll();
      int sum = e.getKey();
      int i = e.getValue();
      if (k >= left) 
        ans = (ans + sum) % kMod;
      if (i + 1 < n) 
        q.offer(new AbstractMap.SimpleEntry<>(sum + nums[i + 1], i + 1));
    }
    return ans;
  }
}

# Author: Huahua
class Solution:
  def rangeSum(self, nums: List[int], n: int, left: int, right: int) -> int:
    q = [(num, i) for i, num in enumerate(nums)]
    heapq.heapify(q)
    ans = 0
    for k in range(1, right + 1):
      s, i = heapq.heappop(q)
      if k >= left:
        ans += s
      if i + 1 < n:
        heapq.heappush(q, (s + nums[i + 1], i + 1))
    return ans % int(1e9 + 7)

Solution 3: Binary Search + Sliding Window

Use binary search to find S s.t. that there are at least k subarrys have sum <= S.

Given S, we can use sliding window to count how many subarrays have sum <= S and their total sum.

ans = sums_of_first(right) – sums_of_first(left – 1).

Time complexity: O(n * log(sum(nums))
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int rangeSum(vector<int>& nums, int n, int left, int right) {
    constexpr int kMod = 1e9 + 7;    
    // Returns number of subarrays that have 
    // sum <= target and their total sum.
    auto countAndSum = [&](int target) -> pair<int, long> {
      int count = 0;
      long cur = 0;
      long sum = 0;
      long total_sum = 0;
      for (long j = 0, i = 0; j < n; ++j) {
        cur += nums[j];
        sum += nums[j] * (j - i + 1);
        while (cur > target) {          
          sum -= cur;
          cur -= nums[i++];
        }        
        count += j - i + 1;
        total_sum += sum;
      }
      return {count, total_sum};
    };
    
    // Returns the total sums of smallest k subarrays.
    // Use binary search to find the smallest sum l s.t. 
    // there are at least k of subarrays have sums <= l.
    const int min_sum = *min_element(begin(nums), end(nums));
    const int max_sum = accumulate(begin(nums), end(nums), 0) + 1;
    auto sumOfFirstK = [&](int k) -> long {
      int l = min_sum;
      int r = max_sum;
      while (l < r) {
        int mid = l + (r - l) / 2;
        if (countAndSum(mid).first >= k)
          r = mid;
        else
          l = mid + 1;
      }      
      const auto [count, sum] = countAndSum(l);
      // There can be more subarrays have the same sum of l.      
      return sum - l * (count - k);
    };
    
    return (sumOfFirstK(right) - sumOfFirstK(left - 1)) % kMod;
  }
};

The post 花花酱 LeetCode 1508. Range Sum of Sorted Subarray Sums appeared first on Huahua's Tech Road.

Given a binary array nums, you should delete one element from it.

Return the size of the longest non-empty subarray containing only 1’s in the resulting array.

Return 0 if there is no such subarray.

Example 1:

Input: nums = [1,1,0,1]
Output: 3
Explanation: After deleting the number in position 2, [1,1,1] contains 3 numbers with value of 1's.

Example 2:

Input: nums = [0,1,1,1,0,1,1,0,1]
Output: 5
Explanation: After deleting the number in position 4, [0,1,1,1,1,1,0,1] longest subarray with value of 1's is [1,1,1,1,1].

Example 3:

Input: nums = [1,1,1]
Output: 2
Explanation: You must delete one element.

Example 4:

Input: nums = [1,1,0,0,1,1,1,0,1]
Output: 4

Example 5:

Input: nums = [0,0,0]
Output: 0

Constraints:

• 1 <= nums.length <= 10^5
• nums[i] is either 0 or 1.

Solution 1: DP

Preprocess:
l[i] := longest 1s from left side ends with nums[i], l[i] = nums[i] + nums[i] * l[i – 1]
r[i] := longest 1s from right side ends with nums[i], r[i] = nums[i] + nums[i] * r[i + 1]

Use each node as a bridge (ignored), the total number of consecutive 1s = l[i – 1] + r[i + 1].

ans = max{l[i-1] + r[i +1]}
Time complexity: O(n)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int longestSubarray(vector<int>& nums) {
    const int n = nums.size();
    vector<int> l(n);
    vector<int> r(n);
    for (int i = 0; i < n; ++i)
      l[i] = (i > 0 ? l[i - 1] * nums[i] : 0) + nums[i];
    for (int i = n - 1; i >= 0; --i)
      r[i] = (i < n - 1 ? r[i + 1] * nums[i] : 0) + nums[i];
    int ans = 0;
    for (int i = 0; i < n; ++i)
      ans = max(ans, (i > 0 ? l[i - 1] : 0) + 
                     (i < n - 1 ? r[i + 1] : 0));
    return ans;
  }
};

Solution 2: DP

dp[i][0] := longest subarray ends with nums[i] has no ones.
dp[i][0] := longest subarray ends with nums[i] has 1 one.
if nums[i] == 1:
dp[i][0] = dp[i – 1][0] + 1
dp[i][1] = dp[i – 1][1] + 1
if nums[i] == 0:
dp[i][0] = 0
dp[i][1] = dp[i – 1][0] + 1
Time complexity: O(n)
Space complexity: O(n) -> O(1)

// Author: Huahua
class Solution {
public:
  int longestSubarray(vector<int>& nums) {
    const int n = nums.size();
    // dp[i][0] := longest subarray ends with nums[i-1] has no zeros.
    // dp[i][0] := longest subarray ends with nums[i-1] has 1 zero.
    vector<vector<int>> dp(n + 1, vector<int>(2));
    int ans = 0;
    for (int i = 1; i <= n; ++i) {
      if (nums[i - 1] == 1) {
        dp[i][0] = dp[i - 1][0] + 1;
        dp[i][1] = dp[i - 1][1] + 1;
      } else {
        dp[i][0] = 0;
        dp[i][1] = dp[i - 1][0] + 1;
      }
      ans = max({ans, dp[i][0] - 1, dp[i][1] - 1});
    }
    return ans;
  }
};

Solution 3: Sliding Window

Maintain a sliding window l ~ r s.t sum(num[l~r]) >= r – l. There can be at most one 0 in the window.
ans = max{r – l} for all valid windows.

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

// Author: Huahua
class Solution {
public:
  int longestSubarray(vector<int>& nums) {
    const int n = nums.size();
    int ans = 0;
    int sum = 0; // sum of nums[l~r].
    for (int l = 0, r = 0; r < n; ++r) {
      sum += nums[r];
      // Maintain sum >= r - l, at most 1 zero.
      while (l < r && sum < r - l)
        sum -= nums[l++];
      ans = max(ans, r - l);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1493. Longest Subarray of 1’s After Deleting One Element appeared first on Huahua's Tech Road.

Given an array of integers arr and an integer target.

You have to find two non-overlapping sub-arrays of arr each with sum equal target. There can be multiple answers so you have to find an answer where the sum of the lengths of the two sub-arrays is minimum.

Return the minimum sum of the lengths of the two required sub-arrays, or return -1 if you cannot find such two sub-arrays.

Example 1:

Input: arr = [3,2,2,4,3], target = 3
Output: 2
Explanation: Only two sub-arrays have sum = 3 ([3] and [3]). The sum of their lengths is 2.

Example 2:

Input: arr = [7,3,4,7], target = 7
Output: 2
Explanation: Although we have three non-overlapping sub-arrays of sum = 7 ([7], [3,4] and [7]), but we will choose the first and third sub-arrays as the sum of their lengths is 2.

Example 3:

Input: arr = [4,3,2,6,2,3,4], target = 6
Output: -1
Explanation: We have only one sub-array of sum = 6.

Example 4:

Input: arr = [5,5,4,4,5], target = 3
Output: -1
Explanation: We cannot find a sub-array of sum = 3.

Example 5:

Input: arr = [3,1,1,1,5,1,2,1], target = 3
Output: 3
Explanation: Note that sub-arrays [1,2] and [2,1] cannot be an answer because they overlap.

Constraints:

• 1 <= arr.length <= 10^5
• 1 <= arr[i] <= 1000
• 1 <= target <= 10^8

Solution: Sliding Window + Best so far

1. Use a sliding window to maintain a subarray whose sum is <= target
2. When the sum of the sliding window equals to target, we found a subarray [s, e]
3. Update ans with it’s length + shortest subarray which ends before s.
4. We can use an array to store the shortest subarray which ends before s.

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

// Author: Huahua
class Solution {
public:
  int minSumOfLengths(vector<int>& arr, int target) {
    constexpr int kInf = 1e9;
    const int n = arr.size();
    // min_lens[i] := min length of a valid subarray ends or before i.
    vector<int> min_lens(n, kInf);
    int ans = kInf;
    int sum = 0;
    int s = 0;
    int min_len = kInf;
    for (int e = 0; e < n; ++e) {
      sum += arr[e];
      while (sum > target) sum -= arr[s++];
      if (sum == target) {       
        const int cur_len = e - s + 1;
        if (s > 0 && min_lens[s - 1] != kInf)
          ans = min(ans, cur_len + min_lens[s - 1]);
        min_len = min(min_len, cur_len);
      }
      min_lens[e] = min_len;
    }    
    return ans >= kInf ? -1 : ans;
  }
};

The post 花花酱 LeetCode 1477. Find Two Non-overlapping Sub-arrays Each With Target Sum appeared first on Huahua's Tech Road.

Return the number of sub-arrays of size k and average greater than or equal to threshold.

Example 1:

Input: arr = [2,2,2,2,5,5,5,8], k = 3, threshold = 4
Output: 3
Explanation: Sub-arrays [2,5,5],[5,5,5] and [5,5,8] have averages 4, 5 and 6 respectively. All other sub-arrays of size 3 have averages less than 4 (the threshold).

Example 2:

Input: arr = [1,1,1,1,1], k = 1, threshold = 0
Output: 5

Example 3:

Input: arr = [11,13,17,23,29,31,7,5,2,3], k = 3, threshold = 5
Output: 6
Explanation: The first 6 sub-arrays of size 3 have averages greater than 5. Note that averages are not integers.

Example 4:

Input: arr = [7,7,7,7,7,7,7], k = 7, threshold = 7
Output: 1

Example 5:

Input: arr = [4,4,4,4], k = 4, threshold = 1
Output: 1

Constraints:

• 1 <= arr.length <= 10^5
• 1 <= arr[i] <= 10^4
• 1 <= k <= arr.length
• 0 <= threshold <= 10^4

Solution: Sliding Window

1. Window size = k
2. Maintain the sum of the window
3. Check sum >= threshold * k

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

// Author: Huahua
class Solution {
public:
  int numOfSubarrays(vector<int>& arr, int k, int threshold) {
    int ans = 0;
    int sum = 0;
    for (int i = 0; i < arr.size(); ++i) {
      sum += arr[i];
      if (i + 1 >= k) {
        if (threshold * k <= sum) ++ans;
        sum -= arr[i + 1 - k];
      } 
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1343. Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold appeared first on Huahua's Tech Road.

Note that the subarray needs to be non-empty after deleting one element.

Example 1:

Input: arr = [1,-2,0,3]
Output: 4
Explanation: Because we can choose [1, -2, 0, 3] and drop -2, thus the subarray [1, 0, 3] becomes the maximum value.

Example 2:

Input: arr = [1,-2,-2,3]
Output: 3
Explanation: We just choose [3] and it's the maximum sum.

Example 3:

Input: arr = [-1,-1,-1,-1]
Output: -1
Explanation: The final subarray needs to be non-empty. You can't choose [-1] and delete -1 from it, then get an empty subarray to make the sum equals to 0.

Constraints:

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

Solution: DP

First, handle the special case: all numbers are negative, return the max one.

s0 = max subarray sum ends with a[i]
s1 = max subarray sum ends with a[i] with at most one deletion

whenever s0 or s1 becomes negative, reset them to 0.

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

// Author: Huahua
class Solution {
public:
  int maximumSum(vector<int>& arr) {    
    int m = *max_element(begin(arr), end(arr));
    if (m <= 0) return m;
    
    int s0 = 0;
    int s1 = 0;
    int ans = 0;
    
    for (int a : arr) {
      s1 = max(s0, s1 + a);
      s0 += a;
      ans = max(ans, max(s0, s1));
      if (s0 < 0) s0 = 0;
      if (s1 < 0) s1 = 0;
    }
    
    return ans;
  }
};

The post 花花酱 LeetCode 1186. Maximum Subarray Sum with One Deletion appeared first on Huahua's Tech Road.

Example 1:

Input:
A: [1,2,3,2,1]
B: [3,2,1,4,7]
Output: 3
Explanation: 
The repeated subarray with maximum length is [3, 2, 1].

Note:

1. 1 <= len(A), len(B) <= 1000
2. 0 <= A[i], B[i] < 100

Solution: DP

dp[i][j] := max length of (A[0:i], B[0:j])

dp[i][j] = dp[i – 1][j – 1] + 1 if A[i-1] == B[j-1] else 0

Time complexity: O(m*n)
Space complexity: O(m*n) -> O(n)

// Author: Huahua, 176 ms / 106.4 MB
class Solution {
public:
  int findLength(vector<int>& A, vector<int>& B) {
    int m = A.size();
    int n = B.size();
    vector<vector<int>> dp(m + 1, vector<int>(n + 1));    
    int ans = 0;
    for (int i = 1; i <= m; ++i)
      for (int j = 1; j <= n; ++j)
        if (A[i - 1] == B[j - 1]) {
          dp[i][j] = dp[i - 1][j - 1] + 1;
          ans = max(ans, dp[i][j]);
        }
    return ans;
  }
};

// Author: Huahua, 152 ms / 9.1 MB
class Solution {
public:
  int findLength(vector<int>& A, vector<int>& B) {
    if (A.size() < B.size()) swap(A, B);
    int m = A.size();
    int n = B.size();
    vector<int> dp(n + 1);    
    int ans = 0;
    for (int i = 1; i <= m; ++i)
      for (int j = n; j >= 1; --j) {
        dp[j] = A[i - 1] == B[j - 1] ? dp[j - 1] + 1 : 0;        
        ans = max(ans, dp[j]);
      }
    return ans;
  }
};

The post 花花酱 LeetCode 718. Maximum Length of Repeated Subarray appeared first on Huahua's Tech Road.