In an operation, you select a set of indices in str1, and for each index i in the set, increment str1[i] to the next character cyclically. That is 'a' becomes 'b', 'b' becomes 'c', and so on, and 'z' becomes 'a'.

Return true if it is possible to make str2 a subsequence of str1 by performing the operation at most once, and false otherwise.

Note: A subsequence of a string is a new string that is formed from the original string by deleting some (possibly none) of the characters without disturbing the relative positions of the remaining characters.

Example 1:

Input: str1 = "abc", str2 = "ad"
Output: true
Explanation: Select index 2 in str1.
Increment str1[2] to become 'd'. 
Hence, str1 becomes "abd" and str2 is now a subsequence. Therefore, true is returned.

Example 2:

Input: str1 = "zc", str2 = "ad"
Output: true
Explanation: Select indices 0 and 1 in str1. 
Increment str1[0] to become 'a'. 
Increment str1[1] to become 'd'. 
Hence, str1 becomes "ad" and str2 is now a subsequence. Therefore, true is returned.

Example 3:

Input: str1 = "ab", str2 = "d"
Output: false
Explanation: In this example, it can be shown that it is impossible to make str2 a subsequence of str1 using the operation at most once. 
Therefore, false is returned.

Constraints:

• 1 <= str1.length <= 105
• 1 <= str2.length <= 105
• str1 and str2 consist of only lowercase English letters.

Solution: Two pointers

s1[i] and s2[j] can match if
s1[i] == s2[j] or inc(s1[i]) == s2[j]

If matched: ++i; ++j else ++i.

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

class Solution {
public:
  bool canMakeSubsequence(string_view s1, string_view s2) {    
    for (int i = 0, j = 0, n = s1.size(), m = s2.size(); i < n; ++i)
      if (s1[i] == s2[j] || (s1[i] - 'a' + 1) % 26 == s2[j] - 'a')
        if (++j == m) return true;
    return false;
  }
};

Iterator version

class Solution {
public:
  bool canMakeSubsequence(string_view s1, string_view s2) {    
    for (auto i = begin(s1), j = begin(s2); i != end(s1); ++i)
      if (*i == *j || (*i - 'a' + 1) % 26 == *j - 'a')
        if (++j == end(s2)) return true;
    return false;
  }
};

The post 花花酱 LeetCode 2825. Make String a Subsequence Using Cyclic Increments appeared first on Huahua's Tech Road.

• nums1[i] = [idi, vali] indicate that the number with the id idi has a value equal to vali.
• nums2[i] = [idi, vali] indicate that the number with the id idi has a value equal to vali.

Each array contains unique ids and is sorted in ascending order by id.

Merge the two arrays into one array that is sorted in ascending order by id, respecting the following conditions:

• Only ids that appear in at least one of the two arrays should be included in the resulting array.
• Each id should be included only once and its value should be the sum of the values of this id in the two arrays. If the id does not exist in one of the two arrays then its value in that array is considered to be 0.

Return the resulting array. The returned array must be sorted in ascending order by id.

Example 1:

Input: nums1 = [[1,2],[2,3],[4,5]], nums2 = [[1,4],[3,2],[4,1]]
Output: [[1,6],[2,3],[3,2],[4,6]]
Explanation: The resulting array contains the following:
- id = 1, the value of this id is 2 + 4 = 6.
- id = 2, the value of this id is 3.
- id = 3, the value of this id is 2.
- id = 4, the value of this id is 5 + 1 = 6.

Example 2:

Input: nums1 = [[2,4],[3,6],[5,5]], nums2 = [[1,3],[4,3]]
Output: [[1,3],[2,4],[3,6],[4,3],[5,5]]
Explanation: There are no common ids, so we just include each id with its value in the resulting list.

Constraints:

• 1 <= nums1.length, nums2.length <= 200
• nums1[i].length == nums2[j].length == 2
• 1 <= idi, vali <= 1000
• Both arrays contain unique ids.
• Both arrays are in strictly ascending order by id.

Solution: Two Pointers

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

// Author: Huahua
class Solution {
public:
    vector<vector<int>> mergeArrays(vector<vector<int>>& nums1, vector<vector<int>>& nums2) {
      vector<vector<int>> ans;
      for (int i = 0, j = 0; i < nums1.size() || j < nums2.size();) {
        const int id1 = i < nums1.size() ? nums1[i][0] : INT_MAX;
        const int id2 = j < nums2.size() ? nums2[j][0] : INT_MAX;
        if (id1 == id2) {
          ans.push_back({id1, nums1[i++][1] + nums2[j++][1]});
        } else if (id1 < id2) {
          ans.push_back(nums1[i++]);
        } else {
          ans.push_back(nums2[j++]);
        }
      }
      return ans;
    }
};

The post 花花酱 2570. Merge Two 2D Arrays by Summing Values appeared first on Huahua's Tech Road.

A pair (i, j) is fair if:

• 0 <= i < j < n, and
• lower <= nums[i] + nums[j] <= upper

Example 1:

Input: nums = [0,1,7,4,4,5], lower = 3, upper = 6
Output: 6
Explanation: There are 6 fair pairs: (0,3), (0,4), (0,5), (1,3), (1,4), and (1,5).

Example 2:

Input: nums = [1,7,9,2,5], lower = 11, upper = 11
Output: 1
Explanation: There is a single fair pair: (2,3).

Constraints:

• 1 <= nums.length <= 105
• nums.length == n
• -109 <= nums[i] <= 109
• -109 <= lower <= upper <= 109

Solution: Two Pointers

Sort the array, use two pointers to find how # of pairs (i, j) s.t. nums[i] + nums[j] <= limit.
Ans = count(upper) – count(lower – 1)

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

// Author: Huahua
class Solution {
public:
  long long countFairPairs(vector<int>& nums, int lower, int upper) {
    sort(begin(nums), end(nums));
    auto count = [&](int limit) -> long long {
      long long ans = 0;
      for (int i = 0, j = nums.size() - 1; i < j; ++i) {
        while (i < j && nums[i] + nums[j] > limit) --j;
        ans += j - i;
      }
      return ans;
    };
    return count(upper) - count(lower - 1);
  }
};

The post 花花酱 LeetCode 2563. Count the Number of Fair Pairs appeared first on Huahua's Tech Road.

The ith player can match with the jth trainer if the player’s ability is less than or equal to the trainer’s training capacity. Additionally, the ith player can be matched with at most one trainer, and the jth trainer can be matched with at most one player.

Return the maximum number of matchings between players and trainers that satisfy these conditions.

Example 1:

Input: players = [4,7,9], trainers = [8,2,5,8]
Output: 2
Explanation:
One of the ways we can form two matchings is as follows:
- players[0] can be matched with trainers[0] since 4 <= 8.
- players[1] can be matched with trainers[3] since 7 <= 8.
It can be proven that 2 is the maximum number of matchings that can be formed.

Example 2:

Input: players = [1,1,1], trainers = [10]
Output: 1
Explanation:
The trainer can be matched with any of the 3 players.
Each player can only be matched with one trainer, so the maximum answer is 1.

Constraints:

• 1 <= players.length, trainers.length <= 105
• 1 <= players[i], trainers[j] <= 109

Solution: Sort + Two Pointers

Sort players and trainers.

Loop through players, skip trainers until he/she can match the current players.

Time complexity: O(nlogn + mlogm + n + m)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int matchPlayersAndTrainers(vector<int>& players, vector<int>& trainers) {
    sort(begin(players), end(players));
    sort(begin(trainers), end(trainers));
    const int n = players.size();
    const int m = trainers.size();
    int ans = 0;
    for (int i = 0, j = 0; i < n && j < m; ++i) {
      while (j < m && players[i] > trainers[j]) ++j;
      if (j++ == m) break;
      ++ans;
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2410. Maximum Matching of Players With Trainers appeared first on Huahua's Tech Road.

• nums.length is even.
• nums[i] != nums[i + 1] for all i % 2 == 0.

Note that an empty array is considered beautiful.

You can delete any number of elements from nums. When you delete an element, all the elements to the right of the deleted element will be shifted one unit to the left to fill the gap created and all the elements to the left of the deleted element will remain unchanged.

Return the minimum number of elements to delete from nums to make it beautiful.

Example 1:

Input: nums = [1,1,2,3,5]
Output: 1
Explanation: You can delete either nums[0] or nums[1] to make nums = [1,2,3,5] which is beautiful. It can be proven you need at least 1 deletion to make nums beautiful.

Example 2:

Input: nums = [1,1,2,2,3,3]
Output: 2
Explanation: You can delete nums[0] and nums[5] to make nums = [1,2,2,3] which is beautiful. It can be proven you need at least 2 deletions to make nums beautiful.

Constraints:

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

Solution: Greedy + Two Pointers

If two consecutive numbers are the same, we must remove one. We don’t need to actually remove elements from array, just need to track how many elements have been removed so far.

i is the position in the original array, ans is the number of elements been removed. i – ans is the position in the updated array.

ans += nums[i – ans] == nums[i – ans + 1]

Remove the last element (just increase answer by 1) if the length of the new array is odd.

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

// Author: Huahua
class Solution {
public:
  int minDeletion(vector<int>& nums) {
    const int n = nums.size();
    int ans = 0;
    for (int i = 0; i - ans + 1 < n; i += 2)
      ans += nums[i - ans] == nums[i - ans + 1];
    ans += (n - ans) & 1;
    return ans;
  }
};

The post 花花酱 LeetCode 2216. Minimum Deletions to Make Array Beautiful appeared first on Huahua's Tech Road.

You should rearrange the elements of nums such that the modified array follows the given conditions:

1. Every consecutive pair of integers have opposite signs.
2. For all integers with the same sign, the order in which they were present in nums is preserved.
3. The rearranged array begins with a positive integer.

Return the modified array after rearranging the elements to satisfy the aforementioned conditions.

Example 1:

Input: nums = [3,1,-2,-5,2,-4]
Output: [3,-2,1,-5,2,-4]
Explanation:
The positive integers in nums are [3,1,2]. The negative integers are [-2,-5,-4].
The only possible way to rearrange them such that they satisfy all conditions is [3,-2,1,-5,2,-4].
Other ways such as [1,-2,2,-5,3,-4], [3,1,2,-2,-5,-4], [-2,3,-5,1,-4,2] are incorrect because they do not satisfy one or more conditions.  

Example 2:

Input: nums = [-1,1]
Output: [1,-1]
Explanation:
1 is the only positive integer and -1 the only negative integer in nums.
So nums is rearranged to [1,-1].

Constraints:

• 2 <= nums.length <= 2 * 105
• nums.length is even
• 1 <= |nums[i]| <= 105
• nums consists of equal number of positive and negative integers.

Solution 1: Split and merge

Create two arrays to store positive and negative numbers.

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

// Author: Huahua
class Solution {
public:
  vector<int> rearrangeArray(vector<int>& nums) {
    vector<int> pos;
    vector<int> neg;
    for (int x : nums)
      (x > 0 ? pos : neg).push_back(x);
    vector<int> ans;
    for (int i = 0; i < pos.size(); ++i) {
      ans.push_back(pos[i]);
      ans.push_back(neg[i]);
    }
    return ans;
  }
};

Solution 2: Two Pointers

Use two pointers to store the next pos / neg.

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

// Author: Huahua
class Solution {
public:
  vector<int> rearrangeArray(vector<int>& nums) {
    vector<int> ans(nums.size());    
    int pos = 0;
    int neg = 1;
    for (int x : nums) {
      int& index = x > 0 ? pos : neg;
      ans[index] = x;
      index += 2;
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2149. Rearrange Array Elements by Sign appeared first on Huahua's Tech Road.

Solution: Simulation w/ Two Pointers

Simulate the watering process.

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

// Author: Huahua
class Solution {
public:
  int minimumRefill(vector<int>& plants, int capacityA, int capacityB) {
    const int n = plants.size();    
    int ans = 0;
    for (int l = 0, r = n - 1, A = capacityA, B = capacityB; l <= r; ++l, --r) {      
      if (l == r)
        return ans += max(A, B) < plants[l];
      if ((A -= plants[l]) < 0) 
        A = capacityA - plants[l], ++ans;        
      if ((B -= plants[r]) < 0) 
        B = capacityB - plants[r], ++ans;     
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2105. Watering Plants II 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.

A pair of indices (i, j), where 0 <= i < nums1.length and 0 <= j < nums2.length, is valid if both i <= j and nums1[i] <= nums2[j]. The distance of the pair is j - i​​​​.

Return the maximum distance of any valid pair (i, j). If there are no valid pairs, return 0.

An array arr is non-increasing if arr[i-1] >= arr[i] for every 1 <= i < arr.length.

Example 1:

Input: nums1 = [55,30,5,4,2], nums2 = [100,20,10,10,5]
Output: 2
Explanation: The valid pairs are (0,0), (2,2), (2,3), (2,4), (3,3), (3,4), and (4,4).
The maximum distance is 2 with pair (2,4).

Example 2:

Input: nums1 = [2,2,2], nums2 = [10,10,1]
Output: 1
Explanation: The valid pairs are (0,0), (0,1), and (1,1).
The maximum distance is 1 with pair (0,1).

Example 3:

Input: nums1 = [30,29,19,5], nums2 = [25,25,25,25,25]
Output: 2
Explanation: The valid pairs are (2,2), (2,3), (2,4), (3,3), and (3,4).
The maximum distance is 2 with pair (2,4).

Example 4:

Input: nums1 = [5,4], nums2 = [3,2]
Output: 0
Explanation: There are no valid pairs, so return 0.

Constraints:

• 1 <= nums1.length <= 105
• 1 <= nums2.length <= 105
• 1 <= nums1[i], nums2[j] <= 105
• Both nums1 and nums2 are non-increasing.

Solution: Two Pointers

For each i, find the largest j such that nums[j] >= nums[i].

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

// Author: Huahua
class Solution {
public:
  int maxDistance(vector<int>& nums1, vector<int>& nums2) {    
    int ans = 0;
    for (int i = 0, j = -1; i < nums1.size(); ++i) {
      while (j + 1 < nums2.size() && nums2[j + 1] >= nums1[i]) ++j;
      if (j >= i) ans = max(ans, j - i);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1855. Maximum Distance Between a Pair of Values appeared first on Huahua's Tech Road.

The score of a subarray (i, j) is defined as min(nums[i], nums[i+1], ..., nums[j]) * (j - i + 1). A good subarray is a subarray where i <= k <= j.

Return the maximum possible score of a good subarray.

Example 1:

Input: nums = [1,4,3,7,4,5], k = 3
Output: 15
Explanation: The optimal subarray is (1, 5) with a score of min(4,3,7,4,5) * (5-1+1) = 3 * 5 = 15. 

Example 2:

Input: nums = [5,5,4,5,4,1,1,1], k = 0
Output: 20
Explanation: The optimal subarray is (0, 4) with a score of min(5,5,4,5,4) * (4-0+1) = 4 * 5 = 20.

Constraints:

• 1 <= nums.length <= 105
• 1 <= nums[i] <= 2 * 104
• 0 <= k < nums.length

Solutions: Two Pointers

maintain a window [i, j], m = min(nums[i~j]), expend to the left if nums[i – 1] >= nums[j + 1], otherwise expend to the right.

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

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

The post 花花酱 LeetCode 1793. Maximum Score of a Good Subarray appeared first on Huahua's Tech Road.

A subarray is a contiguous subsequence of the array.

Return the length of the shortest subarray to remove.

Example 1:

Input: arr = [1,2,3,10,4,2,3,5]
Output: 3
Explanation: The shortest subarray we can remove is [10,4,2] of length 3. The remaining elements after that will be [1,2,3,3,5] which are sorted.
Another correct solution is to remove the subarray [3,10,4].

Example 2:

Input: arr = [5,4,3,2,1]
Output: 4
Explanation: Since the array is strictly decreasing, we can only keep a single element. Therefore we need to remove a subarray of length 4, either [5,4,3,2] or [4,3,2,1].

Example 3:

Input: arr = [1,2,3]
Output: 0
Explanation: The array is already non-decreasing. We do not need to remove any elements.

Example 4:

Input: arr = [1]
Output: 0

Constraints:

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

Solution: Two Pointers

Find the right most j such that arr[j – 1] > arr[j], if not found which means the entire array is sorted return 0. Then we have a non-descending subarray arr[j~n-1].

We maintain two pointers i, j, such that arr[0~i] is non-descending and arr[i] <= arr[j] which means we can remove arr[i+1~j-1] to get a non-descending array. Number of elements to remove is j – i – 1 .

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

// Author: Huahua
class Solution {
public:
  int findLengthOfShortestSubarray(vector<int>& arr) {
    const int n = arr.size();
    int j = n - 1;
    while (j > 0 && arr[j - 1] <= arr[j]) --j;
    if (j == 0) return 0;
    int ans = j; // remove arr[0~j-1]
    for (int i = 0; i < n; ++i) {
      if (i > 0 && arr[i - 1] > arr[i]) break;
      while (j < n && arr[i] > arr[j]) ++j;      
      // arr[i] <= arr[j], remove arr[i + 1 ~ j - 1]
      ans = min(ans, j - i - 1);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1574. Shortest Subarray to be Removed to Make Array Sorted appeared first on Huahua's Tech Road.

A validpath is defined as follows:

• Choose array nums1 or nums2 to traverse (from index-0).
• Traverse the current array from left to right.
• If you are reading any value that is present in nums1 and nums2 you are allowed to change your path to the other array. (Only one repeated value is considered in the valid path).

Score is defined as the sum of uniques values in a valid path.

Return the maximum score you can obtain of all possible valid paths.

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

Example 1:

Input: nums1 = [2,4,5,8,10], nums2 = [4,6,8,9]
Output: 30
Explanation: Valid paths:
[2,4,5,8,10], [2,4,5,8,9], [2,4,6,8,9], [2,4,6,8,10],  (starting from nums1)
[4,6,8,9], [4,5,8,10], [4,5,8,9], [4,6,8,10]    (starting from nums2)
The maximum is obtained with the path in green [2,4,6,8,10].

Example 2:

Input: nums1 = [1,3,5,7,9], nums2 = [3,5,100]
Output: 109
Explanation: Maximum sum is obtained with the path [1,3,5,100].

Example 3:

Input: nums1 = [1,2,3,4,5], nums2 = [6,7,8,9,10]
Output: 40
Explanation: There are no common elements between nums1 and nums2.
Maximum sum is obtained with the path [6,7,8,9,10].

Example 4:

Input: nums1 = [1,4,5,8,9,11,19], nums2 = [2,3,4,11,12]
Output: 61

Constraints:

• 1 <= nums1.length <= 10^5
• 1 <= nums2.length <= 10^5
• 1 <= nums1[i], nums2[i] <= 10^7
• nums1 and nums2 are strictly increasing.

Solution: Two Pointers + DP

Since numbers are strictly increasing, we can always traverse the smaller one using two pointers.
Traversing ([2,4,5,8,10], [4,6,8,10])
will be like [2, 4/4, 5, 6, 8, 10/10]
It two nodes have the same value, we have two choices and pick the larger one, then both move nodes one step forward. Otherwise, the smaller node moves one step forward.
dp1[i] := max path sum ends with nums1[i-1]
dp2[j] := max path sum ends with nums2[j-1]
if nums[i -1] == nums[j – 1]:
dp1[i] = dp2[j] = max(dp[i-1], dp[j-1]) + nums[i -1]
i += 1, j += 1
else if nums[i – 1] < nums[j – 1]:
dp[i] = dp[i-1] + nums[i -1]
i += 1
else if nums[j – 1] < nums[i – 1]:
dp[j] = dp[j-1] + nums[j -1]
j += 1
return max(dp1[-1], dp2[-1])

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

class Solution {
public:
  int maxSum(vector<int>& nums1, vector<int>& nums2) {
    constexpr int kMod = 1e9 + 7;
    const int n1 = nums1.size();
    const int n2 = nums2.size();
    vector<long> dp1(n1 + 1); // max path sum ends with nums1[i-1]
    vector<long> dp2(n2 + 1); // max path sum ends with nums2[j-1]
    int i = 0;
    int j = 0;
    while (i < n1 || j < n2) {
      if (i < n1 && j < n2 && nums1[i] == nums2[j]) {
        // Same, two choices, pick the larger one.
        dp2[j + 1] = dp1[i + 1] = max(dp1[i], dp2[j]) + nums1[i];
        ++i; ++j;
      } else if (i < n1 && (j == n2 || nums1[i] < nums2[j])) {
        dp1[i + 1] = dp1[i] + nums1[i];
        ++i;
      } else if (j < n2 && (i == n1 || nums2[j] < nums1[i])) {        
        dp2[j + 1] = dp2[j] + nums2[j];
        ++j;
      }
    }    
    return max(dp1.back(), dp2.back()) % kMod;
  }
};

class Solution {
  public int maxSum(int[] nums1, int[] nums2) {
    final int kMod = 1_000_000_007;
    int n1 = nums1.length;
    int n2 = nums2.length;
    int i = 0;
    int j = 0;
    long a = 0;
    long b = 0;
    while (i < n1 || j < n2) {
      if (i < n1 && j < n2 && nums1[i] == nums2[j]) {
        a = b = Math.max(a, b) + nums1[i];
        ++i;
        ++j;
      } else if (i < n1 && (j == n2 || nums1[i] < nums2[j])) {
        a += nums1[i++];        
      } else {
        b += nums2[j++];
      }
    }
    return (int)(Math.max(a, b) % kMod);
  }
}

class Solution:
  def maxSum(self, nums1: List[int], nums2: List[int]) -> int:
    n1, n2 = len(nums1), len(nums2)
    i, j = 0, 0
    a, b = 0, 0
    while i < n1 or j < n2:
      if i < n1 and j < n2 and nums1[i] == nums2[j]:
        a = b = max(a, b) + nums1[i]
        i += 1
        j += 1
      elif i < n1 and (j == n2 or nums1[i] < nums2[j]):
        a += nums1[i]
        i += 1
      else:
        b += nums2[j]
        j += 1
    return max(a, b) % (10**9 + 7)

The post 花花酱 LeetCode 1537. Get the Maximum Score appeared first on Huahua's Tech Road.

Return the number of non-empty subsequences of nums such that the sum of the minimum and maximum element on it is less or equal than target.

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

Example 1:

Input: nums = [3,5,6,7], target = 9
Output: 4
Explanation: There are 4 subsequences that satisfy the condition.
[3] -> Min value + max value <= target (3 + 3 <= 9)
[3,5] -> (3 + 5 <= 9)
[3,5,6] -> (3 + 6 <= 9)
[3,6] -> (3 + 6 <= 9)

Example 2:

Input: nums = [3,3,6,8], target = 10
Output: 6
Explanation: There are 6 subsequences that satisfy the condition. (nums can have repeated numbers).
[3] , [3] , [3,3], [3,6] , [3,6] , [3,3,6]

Example 3:

Input: nums = [2,3,3,4,6,7], target = 12
Output: 61
Explanation: There are 63 non-empty subsequences, two of them don't satisfy the condition ([6,7], [7]).
Number of valid subsequences (63 - 2 = 61).

Example 4:

Input: nums = [5,2,4,1,7,6,8], target = 16
Output: 127
Explanation: All non-empty subset satisfy the condition (2^7 - 1) = 127

Constraints:

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

Solution: Two Pointers

Since order of the elements in the subsequence doesn’t matter, we can sort the input array.
Very similar to two sum, we use two pointers (i, j) to maintain a window, s.t. nums[i] +nums[j] <= target.
Then fix nums[i], any subset of (nums[i+1~j]) gives us a valid subsequence, thus we have 2^(j-(i+1)+1) = 2^(j-i) valid subsequence for window (i, j).

Time complexity: O(nlogn) // Sort
Space complexity: O(n) // need to precompute 2^n % kMod.

// Author: Huahua
class Solution {
public:
  int numSubseq(vector<int>& nums, int target) {
    constexpr int kMod = 1e9 + 7;
    const int n = nums.size();
    vector<int> p(n + 1, 1);
    for (int i = 1; i <= n; ++i) 
      p[i] = (p[i - 1] << 1) % kMod;
    sort(begin(nums), end(nums));
    int ans = 0;
    for (int i = 0, j = n - 1; i <= j; ++i) {
      while (i <= j && nums[i] + nums[j] > target) --j;
      if (i > j) continue;
      // In subarray nums[i~j]:
      // min = nums[i], max = nums[j]
      // nums[i] + nums[j] <= target
      // {nums[i], (j - i - 1 + 1 values)}
      // Any subset of the right part gives a valid subsequence 
      // in the original array. And There are 2^(j - i) ones.
      ans = (ans + p[j - i]) % kMod;
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1498. Number of Subsequences That Satisfy the Given Sum Condition appeared first on Huahua's Tech Road.

The distance value is defined as the number of elements arr1[i] such that there is not any element arr2[j] where |arr1[i]-arr2[j]| <= d.

Example 1:

Input: arr1 = [4,5,8], arr2 = [10,9,1,8], d = 2
Output: 2
Explanation: 
For arr1[0]=4 we have: 
|4-10|=6 > d=2 
|4-9|=5 > d=2 
|4-1|=3 > d=2 
|4-8|=4 > d=2 
For arr1[1]=5 we have: 
|5-10|=5 > d=2 
|5-9|=4 > d=2 
|5-1|=4 > d=2 
|5-8|=3 > d=2
For arr1[2]=8 we have:
|8-10|=2 <= d=2
|8-9|=1 <= d=2
|8-1|=7 > d=2
|8-8|=0 <= d=2

Example 2:

Input: arr1 = [1,4,2,3], arr2 = [-4,-3,6,10,20,30], d = 3
Output: 2

Example 3:

Input: arr1 = [2,1,100,3], arr2 = [-5,-2,10,-3,7], d = 6
Output: 1

Constraints:

• 1 <= arr1.length, arr2.length <= 500
• -10^3 <= arr1[i], arr2[j] <= 10^3
• 0 <= d <= 100

Solution 1: All pairs

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

// Author: Huahua
class Solution {
public:
  int findTheDistanceValue(vector<int>& arr1, vector<int>& arr2, int d) {    
    int ans = 0;
    for (int x : arr1) {
      bool flag = true;
      for (int y : arr2)
        if (abs(x - y) <= d) {
          flag = false;
          break;
        }
      ans += flag;
    }
    return ans;
  }
};

# Author: Huahua
class Solution:
  def findTheDistanceValue(self, arr1: List[int], arr2: List[int], d: int) -> int:
    return sum(all(abs(x - y) > d for y in arr2) for x in arr1)

Solution 2: Two Pointers

Sort arr1 in ascending order and sort arr2 in descending order.
Time complexity: O(mlogm + nlogn + m + n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int findTheDistanceValue(vector<int>& arr1, vector<int>& arr2, int d) {    
    sort(begin(arr1), end(arr1));
    sort(rbegin(arr2), rend(arr2));
    int ans = 0;
    for (int a : arr1) {
      while (arr2.size() && arr2.back() < a - d)
        arr2.pop_back();
      ans += arr2.empty() || arr2.back() > a + d;
    }
    return ans;
  }
};

Solution 3: Binary Search

Sort arr2 in ascending order. and do two binary searches for each element to determine the range of [a-d, a+d], if that range is empty we increase the counter

Time complexity: O(mlogm + nlogm)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int findTheDistanceValue(vector<int>& arr1, vector<int>& arr2, int d) {    
    sort(begin(arr2), end(arr2));
    int ans = 0;
    for (int a : arr1) {
      auto it1 = lower_bound(begin(arr2), end(arr2), a - d);
      auto it2 = upper_bound(begin(arr2), end(arr2), a + d);
      if (it1 == it2) ++ans;
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1385. Find the Distance Value Between Two Arrays appeared first on Huahua's Tech Road.

• Integers in each row are sorted in ascending from left to right.
• Integers in each column are sorted in ascending from top to bottom.

Example:

Consider the following matrix:

[
  [1,   4,  7, 11, 15],
  [2,   5,  8, 12, 19],
  [3,   6,  9, 16, 22],
  [10, 13, 14, 17, 24],
  [18, 21, 23, 26, 30]
]

Given target = 5, return true.

Solution 1: Two Pointers

Start from first row + last column, if the current value is larger than target, –column; if smaller then ++row.

e.g.
1. r = 0, c = 4, v = 15, 15 > 5 => –c
2. r = 0, c = 3, v = 11, 11 > 5 => –c
3. r = 0, c = 2, v = 7, 7 > 5 => –c
4. r = 0, c = 1, v = 4, 4 < 5 => ++r
5. r = 1, c = 1, v = 5, 5 = 5, found it!

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

// Author: Huahua
class Solution {
public:
  bool searchMatrix(vector<vector<int>>& matrix, int target) {
    if (matrix.empty() || matrix[0].empty()) return false;
    const int m = matrix.size();
    const int n = matrix[0].size();
    int r = 0;
    int c = matrix[0].size() - 1;
    while (r < m && c >= 0) {
      if (matrix[r][c] == target) return true;
      else if (matrix[r][c] > target) --c;
      else ++r;
    }
    return false;
  }
};

The post 花花酱 LeetCode 240. Search a 2D Matrix II appeared first on Huahua's Tech Road.