There are several consecutive houses along a street, each of which has some money inside. There is also a robber, who wants to steal money from the homes, but he refuses to steal from adjacent homes.

The capability of the robber is the maximum amount of money he steals from one house of all the houses he robbed.

You are given an integer array nums representing how much money is stashed in each house. More formally, the ith house from the left has nums[i] dollars.

You are also given an integer k, representing the minimum number of houses the robber will steal from. It is always possible to steal at least k houses.

Return the minimum capability of the robber out of all the possible ways to steal at least k houses.

Example 1:

Input: nums = [2,3,5,9], k = 2
Output: 5
Explanation: 
There are three ways to rob at least 2 houses:
- Rob the houses at indices 0 and 2. Capability is max(nums[0], nums[2]) = 5.
- Rob the houses at indices 0 and 3. Capability is max(nums[0], nums[3]) = 9.
- Rob the houses at indices 1 and 3. Capability is max(nums[1], nums[3]) = 9.
Therefore, we return min(5, 9, 9) = 5.

Example 2:

Input: nums = [2,7,9,3,1], k = 2
Output: 2
Explanation: There are 7 ways to rob the houses. The way which leads to minimum capability is to rob the house at index 0 and 4. Return max(nums[0], nums[4]) = 2.

Constraints:

• 1 <= nums.length <= 105
• 1 <= nums[i] <= 109
• 1 <= k <= (nums.length + 1)/2

Solution 1: Binary Search + DP

It’s easy to see that higher capability means more houses we can rob. Thus this can be formulate as a binary search algorithm e.g. find the minimum C s.t. we can rob at least k houses.

Then we can use dp(i) to calculate maximum houses we can rob if starting from the i’th house.
dp(i) = max(1 + dp(i + 2) if nums[i] <= C else 0, dp(i + 1))

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

// Author: Huahua
class Solution {
public:
  int minCapability(vector<int>& nums, int k) {
    int l = 0;
    int r = *max_element(begin(nums), end(nums)) + 1;
    vector<int> cache(nums.size(), -1);
    function<int(int, int)> rob = [&](int m, int i) -> int {
      if (i >= nums.size()) return 0;
      if (cache[i] >= 0) return cache[i];
      if (nums[i] > m) return rob(m, i + 1);
      return cache[i] = max(1 + rob(m, i + 2), rob(m, i + 1));
    };
    while (l < r) {
      int m = l + (r - l) / 2;
      fill(begin(cache), end(cache), -1);
      if (rob(m, 0) >= k)
        r = m;
      else
        l = m + 1;
    }
    return l;
  }
};

Solution 2: Binary Search + Greedy

From: dp(i) = max(1 + dp(i + 2) if nums[i] <= C else 0, dp(i + 1)) we can see that if we can pick the i-th one, it will be the same or better if we skip and start from dp(i + 1). Thus we can convert this from DP to greedy. As long as we can pick the current one, we pick it first.

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

// Author: Huahua
class Solution {
public:
  int minCapability(vector<int>& nums, int k) {
    int l = 0;
    int r = *max_element(begin(nums), end(nums)) + 1;    
    auto rob = [&](int m) -> int {
      int ans = 0;
      for (int i = 0; i < nums.size(); ++i)
        if (nums[i] <= m) {
          ++ans;
          ++i;
        }
      return ans;
    };
    while (l < r) {
      int m = l + (r - l) / 2;      
      if (rob(m) >= k)
        r = m;
      else
        l = m + 1;
    }
    return l;
  }
};

The post 花花酱 LeetCode 2560. House Robber IV appeared first on Huahua's Tech Road.

You are given the root of a binary search tree and an array queries of size n consisting of positive integers.

Find a 2D array answer of size n where answer[i] = [mini, maxi]:

• mini is the largest value in the tree that is smaller than or equal to queries[i]. If a such value does not exist, add -1 instead.
• maxi is the smallest value in the tree that is greater than or equal to queries[i]. If a such value does not exist, add -1 instead.

Return the array answer.

Example 1:

Input: root = [6,2,13,1,4,9,15,null,null,null,null,null,null,14], queries = [2,5,16]
Output: [[2,2],[4,6],[15,-1]]
Explanation: We answer the queries in the following way:
- The largest number that is smaller or equal than 2 in the tree is 2, and the smallest number that is greater or equal than 2 is still 2. So the answer for the first query is [2,2].
- The largest number that is smaller or equal than 5 in the tree is 4, and the smallest number that is greater or equal than 5 is 6. So the answer for the second query is [4,6].
- The largest number that is smaller or equal than 16 in the tree is 15, and the smallest number that is greater or equal than 16 does not exist. So the answer for the third query is [15,-1].

Example 2:

Input: root = [4,null,9], queries = [3]
Output: [[-1,4]]
Explanation: The largest number that is smaller or equal to 3 in the tree does not exist, and the smallest number that is greater or equal to 3 is 4. So the answer for the query is [-1,4].

Constraints:

• The number of nodes in the tree is in the range [2, 105].
• 1 <= Node.val <= 106
• n == queries.length
• 1 <= n <= 105
• 1 <= queries[i] <= 106

Solution: Convert to sorted array

Since we don’t know whether the tree is balanced or not, the safest and easiest way is to convert the tree into a sorted array using inorder traversal. Or just any traversal and sort the array later on.

Once we have a sorted array, we can use lower_bound / upper_bound to query.

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

// Author: Huahua
class Solution {
public:
  vector<vector<int>> closestNodes(TreeNode* root, vector<int>& queries) {    
    vector<int> vals;
    function<void(TreeNode*)> inorder = [&](TreeNode* root) {
      if (!root) return;
      inorder(root->left);
      vals.push_back(root->val);
      inorder(root->right);
    };
    
    inorder(root);
    
    vector<vector<int>> ans;
    for (const int q : queries) {
      vector<int> cur{-1, -1};
      auto lit = upper_bound(begin(vals), end(vals), q);
      if (lit != begin(vals))
        cur[0] = *(prev(lit));
      auto rit = lower_bound(begin(vals), end(vals), q);
      if (rit != end(vals))
        cur[1] = *rit;      
      ans.push_back(std::move(cur));
    }
    return ans;
  }
};

One binary search per query.

// Author: Huahua
class Solution {
public:
  vector<vector<int>> closestNodes(TreeNode* root, vector<int>& queries) {    
    vector<int> vals;
    function<void(TreeNode*)> inorder = [&](TreeNode* root) {
      if (!root) return;
      inorder(root->left);
      if (vals.empty() || root->val > vals.back()) vals.push_back(root->val);
      inorder(root->right);
    };
    
    inorder(root);
    
    vector<vector<int>> ans;
    for (const int q : queries) {
      vector<int> cur{-1, -1};      
      auto it = lower_bound(begin(vals), end(vals), q);
      if (it != end(vals) && *it == q)
        cur[0] = cur[1] = q;
      else {
        if (it != begin(vals)) cur[0] = *prev(it);
        if (it != end(vals)) cur[1] = *it;        
      }
      ans.push_back(std::move(cur));
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2476. Closest Nodes Queries in a Binary Search Tree appeared first on Huahua's Tech Road.

Return an array answer of length m where answer[i] is the maximum size of a subsequence that you can take from nums such that the sum of its elements is less than or equal to queries[i].

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,5,2,1], queries = [3,10,21]
Output: [2,3,4]
Explanation: We answer the queries as follows:
- The subsequence [2,1] has a sum less than or equal to 3. It can be proven that 2 is the maximum size of such a subsequence, so answer[0] = 2.
- The subsequence [4,5,1] has a sum less than or equal to 10. It can be proven that 3 is the maximum size of such a subsequence, so answer[1] = 3.
- The subsequence [4,5,2,1] has a sum less than or equal to 21. It can be proven that 4 is the maximum size of such a subsequence, so answer[2] = 4.

Example 2:

Input: nums = [2,3,4,5], queries = [1]
Output: [0]
Explanation: The empty subsequence is the only subsequence that has a sum less than or equal to 1, so answer[0] = 0.

Constraints:

• n == nums.length
• m == queries.length
• 1 <= n, m <= 1000
• 1 <= nums[i], queries[i] <= 106

Solution: Sort + PrefixSum + Binary Search

Time complexity: O(nlogn + mlogn)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  vector<int> answerQueries(vector<int>& nums, vector<int>& queries) {    
    sort(begin(nums), end(nums));
    partial_sum(begin(nums), end(nums), begin(nums));
    vector<int> ans;
    for (int q : queries)
      ans.push_back(upper_bound(begin(nums), end(nums), q) - begin(nums));
    return ans;
  }
};

The post 花花酱 LeetCode 2389. Longest Subsequence With Limited Sum appeared first on Huahua's Tech Road.

You are also given an integer k. You should allocate piles of candies to k children such that each child gets the same number of candies. Each child can take at most one pile of candies and some piles of candies may go unused.

Return the maximum number of candies each child can get.

Example 1:

Input: candies = [5,8,6], k = 3
Output: 5
Explanation: We can divide candies[1] into 2 piles of size 5 and 3, and candies[2] into 2 piles of size 5 and 1. We now have five piles of candies of sizes 5, 5, 3, 5, and 1. We can allocate the 3 piles of size 5 to 3 children. It can be proven that each child cannot receive more than 5 candies.

Example 2:

Input: candies = [2,5], k = 11
Output: 0
Explanation: There are 11 children but only 7 candies in total, so it is impossible to ensure each child receives at least one candy. Thus, each child gets no candy and the answer is 0.

Constraints:

• 1 <= candies.length <= 105
• 1 <= candies[i] <= 107
• 1 <= k <= 1012

Solution: Binary Search

Find the smallest L s.t. we can allocate candies to less than k children.

ans = L – 1.

Time complexity: O(nlogm) where n is number of piles, m is sum(candies) / k.
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int maximumCandies(vector<int>& candies, long long k) {
    long long total = accumulate(begin(candies), end(candies), 0LL);
    long long l = 1;
    long long r = total / k + 1;
    while (l < r) {
      long long m = l + (r - l) / 2;
      long long c = 0;
      for (int pile : candies)
        c += pile / m;
      if (c < k)
        r = m;
      else
        l = m + 1;
    }
    return l - 1;
  }
};

The post 花花酱 LeetCode 2226. Maximum Candies Allocated to K Children appeared first on Huahua's Tech Road.

Each bus can make multiple trips successively; that is, the next trip can start immediately after completing the current trip. Also, each bus operates independently; that is, the trips of one bus do not influence the trips of any other bus.

You are also given an integer totalTrips, which denotes the number of trips all buses should make in total. Return the minimum time required for all buses to complete at least totalTrips trips.

Example 1:

Input: time = [1,2,3], totalTrips = 5
Output: 3
Explanation:
- At time t = 1, the number of trips completed by each bus are [1,0,0]. 
  The total number of trips completed is 1 + 0 + 0 = 1.
- At time t = 2, the number of trips completed by each bus are [2,1,0]. 
  The total number of trips completed is 2 + 1 + 0 = 3.
- At time t = 3, the number of trips completed by each bus are [3,1,1]. 
  The total number of trips completed is 3 + 1 + 1 = 5.
So the minimum time needed for all buses to complete at least 5 trips is 3.

Example 2:

Input: time = [2], totalTrips = 1
Output: 2
Explanation:
There is only one bus, and it will complete its first trip at t = 2.
So the minimum time needed to complete 1 trip is 2.

Constraints:

• 1 <= time.length <= 105
• 1 <= time[i], totalTrips <= 107

Solution: Binary Search

Find the smallest t s.t. trips >= totalTrips.

Time complexity: O(nlogm), where m ~= 1e15
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  long long minimumTime(vector<int>& time, int totalTrips) {
    long long l = 1;
    long long r = 1e15;
    while (l < r) {
      long long m = l + (r - l) / 2;
      long long trips = 0;
      for (int t : time) {        
        trips += m / t;
        if (trips >= totalTrips) break;
      }
      if (trips >= totalTrips)
        r = m;
      else
        l = m + 1;
    }
    return l;
  }
};

The post 花花酱 LeetCode 2187. Minimum Time to Complete Trips appeared first on Huahua's Tech Road.

Initially, you can insert at most one battery into each computer. After that and at any integer time moment, you can remove a battery from a computer and insert another battery any number of times. The inserted battery can be a totally new battery or a battery from another computer. You may assume that the removing and inserting processes take no time.

Note that the batteries cannot be recharged.

Return the maximum number of minutes you can run all the n computers simultaneously.

Example 1:

Input: n = 2, batteries = [3,3,3]
Output: 4
Explanation: 
Initially, insert battery 0 into the first computer and battery 1 into the second computer.
After two minutes, remove battery 1 from the second computer and insert battery 2 instead. Note that battery 1 can still run for one minute.
At the end of the third minute, battery 0 is drained, and you need to remove it from the first computer and insert battery 1 instead.
By the end of the fourth minute, battery 1 is also drained, and the first computer is no longer running.
We can run the two computers simultaneously for at most 4 minutes, so we return 4.

Example 2:

Input: n = 2, batteries = [1,1,1,1]
Output: 2
Explanation: 
Initially, insert battery 0 into the first computer and battery 2 into the second computer. 
After one minute, battery 0 and battery 2 are drained so you need to remove them and insert battery 1 into the first computer and battery 3 into the second computer. 
After another minute, battery 1 and battery 3 are also drained so the first and second computers are no longer running.
We can run the two computers simultaneously for at most 2 minutes, so we return 2.

Constraints:

• 1 <= n <= batteries.length <= 105
• 1 <= batteries[i] <= 109

Solution: Binary Search

Find the smallest L that we can not run, ans = L – 1.

For a guessing m, we check the total battery powers T = sum(min(m, batteries[i])), if T >= m * n, it means there is a way (doesn’t need to figure out how) to run n computers for m minutes by fully unitize those batteries.

Proof: If T >= m*n holds, there are two cases:

1. There are only n batteries, can not swap, but each of them has power >= m.
2. At least one of the batteries have power less than m, but there are more than n batteries and total power is sufficient, we can swap them with others.

Time complexity: O(Slogn) where S = sum(batteries)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  long long maxRunTime(int n, vector<int>& batteries) {
    long long l = 0;
    long long r = accumulate(begin(batteries), end(batteries), 0LL) + 1;
    while (l < r) {
      long long m = l + (r - l) / 2;
      long long t = 0;
      for (long long b : batteries)
        t += min(m, b);
      if (m * n > t) // smallest m that does not fit.
        r = m;
      else
        l = m + 1;
    }
    return l - 1; // greatest m that fits.
  }
};

The post 花花酱 LeetCode 2141. Maximum Running Time of N Computers appeared first on Huahua's Tech Road.

• nums[a] + nums[b] + nums[c] == nums[d], and
• a < b < c < d

Example 1:

Input: nums = [1,2,3,6]
Output: 1
Explanation: The only quadruplet that satisfies the requirement is (0, 1, 2, 3) because 1 + 2 + 3 == 6.

Example 2:

Input: nums = [3,3,6,4,5]
Output: 0
Explanation: There are no such quadruplets in [3,3,6,4,5].

Example 3:

Input: nums = [1,1,1,3,5]
Output: 4
Explanation: The 4 quadruplets that satisfy the requirement are:
- (0, 1, 2, 3): 1 + 1 + 1 == 3
- (0, 1, 3, 4): 1 + 1 + 3 == 5
- (0, 2, 3, 4): 1 + 1 + 3 == 5
- (1, 2, 3, 4): 1 + 1 + 3 == 5

Constraints:

• 4 <= nums.length <= 50
• 1 <= nums[i] <= 100

Solution 1: Brute force (224ms)

Enumerate a, b, c, d.

Time complexity: O(C(n, 4)) = O(n⁴/24)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int countQuadruplets(vector<int>& nums) {
    const int n = nums.size();
    int ans = 0;
    for (int a = 0; a < n; ++a)
      for (int b = a + 1; b < n; ++b)
        for (int c = b + 1; c < n; ++c)
          for (int d = c + 1; d < n; ++d)
            ans += nums[a] + nums[b] + nums[c] == nums[d];
    return ans;
  }
};

Solution 2: Static frequency table + binary search (39ms)

For each element, we store its indices (sorted).

Given a, b, c, target t = nums[a] + nums[b] + nums[c], we check the hashtable and use binary search to find how many times it occurred after index c.

Time complexity: O(n³/6*logn)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int countQuadruplets(vector<int>& nums) {
    constexpr int kMax = 100;
    const int n = nums.size();
    int ans = 0;
    vector<vector<int>> m(kMax + 1);
    for (int i = 0; i < n; ++i)
      m[nums[i]].push_back(i);
    for (int a = 0; a < n; ++a)
      for (int b = a + 1; b < n; ++b)
        for (int c = b + 1; c < n; ++c) {
          const int t = nums[a] + nums[b] + nums[c];
          if (t > kMax) continue;
          ans += end(m[t]) - lower_bound(begin(m[t]), end(m[t]), c + 1);
        }
    return ans;
  }
};

Solution 3: Dynamic frequency table (29ms)

Similar to 花花酱 LeetCode 1. Two Sum, we dynamically add elements (from right to left) into the hashtable.

Time complexity: O(n³/6)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int countQuadruplets(vector<int>& nums) {
    constexpr int kMax = 100;
    const int n = nums.size();
    int ans = 0;
    vector<int> m(kMax + 1);    
    // for every c we had seen, we can use it as target (nums[d]).
    for (int c = n - 1; c >= 0; ++m[nums[c--]])
      for (int a = 0; a < c; ++a)
        for (int b = a + 1; b < c; ++b) {
          const int t = nums[a] + nums[b] + nums[c];
          if (t > kMax) continue;
          ans += m[t];
        }
    return ans;
  }
};

The post 花花酱 LeetCode 1995. Count Special Quadruplets appeared first on Huahua's Tech Road.

In case of a tie, return the minimum such integer.

Notice that the answer is not neccesarilly a number from arr.

Example 1:

Input: arr = [4,9,3], target = 10
Output: 3
Explanation: When using 3 arr converts to [3, 3, 3] which sums 9 and that's the optimal answer.

Example 2:

Input: arr = [2,3,5], target = 10
Output: 5

Example 3:

Input: arr = [60864,25176,27249,21296,20204], target = 56803
Output: 11361

Constraints:

• 1 <= arr.length <= 104
• 1 <= arr[i], target <= 105

Solution: Binary Search

Find the smallest number x s.t. sum of the mutated array is >= target. Answer must be either x or x – 1.

Note, the search range should be [0, max(arr))

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

// Author: Huahua]
class Solution {
public:
  int findBestValue(vector<int>& arr, int target) {
    int l = 0;
    int r = *max_element(begin(arr), end(arr));
    int ans = 0;
    auto sum = [&](int v) {
      int ans = 0;
      for (int x : arr)
        ans += min(x, v);
      return ans;
    };
    while (l < r) {
      int m = l + (r - l) / 2;            
      if (sum(m) >= target)
        r = m;
      else
        l = m + 1;
    }
    return abs(sum(l) - target) < abs(sum(l - 1) - target) ? l : l - 1;
  }
};

The post 花花酱 LeetCode 1300. Sum of Mutated Array Closest to Target appeared first on Huahua's Tech Road.

The array arr is called K-increasing if arr[i-k] <= arr[i] holds for every index i, where k <= i <= n-1.

• For example, arr = [4, 1, 5, 2, 6, 2] is K-increasing for k = 2 because:
  • arr[0] <= arr[2] (4 <= 5)
  • arr[1] <= arr[3] (1 <= 2)
  • arr[2] <= arr[4] (5 <= 6)
  • arr[3] <= arr[5] (2 <= 2)
• However, the same arr is not K-increasing for k = 1 (because arr[0] > arr[1]) or k = 3 (because arr[0] > arr[3]).

In one operation, you can choose an index i and change arr[i] into any positive integer.

Return the minimum number of operations required to make the array K-increasing for the given k.

Example 1:

Input: arr = [5,4,3,2,1], k = 1
Output: 4
Explanation:
For k = 1, the resultant array has to be non-decreasing.
Some of the K-increasing arrays that can be formed are [5,6,7,8,9], [1,1,1,1,1], [2,2,3,4,4]. All of them require 4 operations.
It is suboptimal to change the array to, for example, [6,7,8,9,10] because it would take 5 operations.
It can be shown that we cannot make the array K-increasing in less than 4 operations.

Example 2:

Input: arr = [4,1,5,2,6,2], k = 2
Output: 0
Explanation:
This is the same example as the one in the problem description.
Here, for every index i where 2 <= i <= 5, arr[i-2] <=arr[i].
Since the given array is already K-increasing, we do not need to perform any operations.

Example 3:

Input: arr = [4,1,5,2,6,2], k = 3
Output: 2
Explanation:
Indices 3 and 5 are the only ones not satisfying arr[i-3] <= arr[i] for 3 <= i <= 5.
One of the ways we can make the array K-increasing is by changing arr[3] to 4 and arr[5] to 5.
The array will now be [4,1,5,4,6,5].
Note that there can be other ways to make the array K-increasing, but none of them require less than 2 operations.

Constraints:

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

Solution: Longest increasing subsequence

if k = 1, we need to modify the following arrays
1. [a[0], a[1], a[2], …]
if k = 2, we need to modify the following arrays
1. [a[0], a[2], a[4], …]
2. [a[1], a[3], a[5], …]
if k = 3, we need to modify the following arrays
1. [a[0], a[3], a[6], …]
2. [a[1], a[4], a[7], …]
3. [a[2], a[5], a[8], …]
…

These arrays are independent of each other, we just need to find LIS of it, # ops = len(arr) – LIS(arr).
Ans = sum(len(arr_i) – LIS(arr_i)) 1 <= i <= k

Reference: 花花酱 LeetCode 300. Longest Increasing Subsequence

Time complexity: O(k * (n/k)* log(n/k)) = O(n * log(n/k))
Space complexity: O(n/k)

// Author: Huahua
class Solution {
public:
  int kIncreasing(vector<int>& arr, int k) {
    auto LIS = [](const vector<int>& nums) {
      vector<int> lis;
      for (int x : nums)
        if (lis.empty() || lis.back() <= x)
          lis.push_back(x);
        else
          *upper_bound(begin(lis), end(lis), x) = x;
      return lis.size();
    };
    const int n = arr.size();
    int ans = 0;
    for (int i = 0; i < k; ++i) {
      vector<int> cur;
      for (int j = i; j < n; j += k)
        cur.push_back(arr[j]);
      ans += cur.size() - LIS(cur);
    }
    return ans;
  }
};

# Author: Huahua
class Solution:
  def kIncreasing(self, arr: List[int], k: int) -> int:
    def LIS(arr: List[int]) -> int:
      lis = []
      for x in arr:
        if not lis or lis[-1] <= x:
          lis.append(x)
        else:
          lis[bisect_right(lis, x)] = x
      return len(lis)
    
    return sum(len(arr[i::k]) - LIS(arr[i::k]) for i in range(k))

The post 花花酱 LeetCode 2111. Minimum Operations to Make the Array K-Increasing appeared first on Huahua's Tech Road.

Before being passed to your function, nums is rotated at an unknown pivot index k (0 <= k < nums.length) such that the resulting array is [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]] (0-indexed). For example, [0,1,2,4,4,4,5,6,6,7] might be rotated at pivot index 5 and become [4,5,6,6,7,0,1,2,4,4].

Given the array nums after the rotation and an integer target, return true if target is in nums, or false if it is not in nums.

You must decrease the overall operation steps as much as possible.

Example 1:

Input: nums = [2,5,6,0,0,1,2], target = 0
Output: true

Example 2:

Input: nums = [2,5,6,0,0,1,2], target = 3
Output: false

Constraints:

• 1 <= nums.length <= 5000
• -104 <= nums[i] <= 104
• nums is guaranteed to be rotated at some pivot.
• -104 <= target <= 104

Solution: Binary search or divide and conquer

If current range is ordered, use binary search, Otherwise, divide and conquer.

Time complexity: O(logn) best, O(n) worst
Space complexity: O(logn)

// Author: Huahua
class Solution {
public:
  bool search(vector<int>& A, int target) {
    return search(A, 0, A.size() - 1, target);
  }
private:
  bool search(vector<int>& A, int l, int r, int target) {
    if (l > r) return 0;
    if (l == r) return target == A[l];

    int mid = l + (r - l) / 2;

    if (A[l] < A[mid] && A[mid] < A[r])
      return (target <= A[mid]) ? search(A, l, mid, target) : search(A, mid + 1, r, target);
    else
      return search(A, l, mid, target) || search(A, mid + 1, r, target);
  }
};

The post 花花酱 LeetCode 81. Search in Rotated Sorted Array II appeared first on Huahua's Tech Road.

Since the return type is an integer, the decimal digits are truncated, and only the integer part of the result is returned.

Note: You are not allowed to use any built-in exponent function or operator, such as pow(x, 0.5) or x ** 0.5.

Example 1:

Input: x = 4
Output: 2

Example 2:

Input: x = 8
Output: 2
Explanation: The square root of 8 is 2.82842..., and since the decimal part is truncated, 2 is returned.

Constraints:

• 0 <= x <= 231 - 1

Solution 1: Binary Search

Find the smallest l such that l * l > x, sqrt(x) = l – 1.

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

// Author: Huahua
class Solution {
public:
  int mySqrt(int x) {      
    unsigned l = 1;
    unsigned r = 1u + x;
    while (l < r) {
      unsigned m = l + (r - l) / 2;
      if (m > x / m) { 
        r = m;
      } else {
        l = m + 1;
      }
    }
    return l - 1;
  }
};

The post 花花酱 LeetCode 69. Sqrt(x) appeared first on Huahua's Tech Road.

If target is not found in the array, return [-1, -1].

You must write an algorithm with O(log n) runtime complexity.

Example 1:

Input: nums = [5,7,7,8,8,10], target = 8
Output: [3,4]

Example 2:

Input: nums = [5,7,7,8,8,10], target = 6
Output: [-1,-1]

Example 3:

Input: nums = [], target = 0
Output: [-1,-1]

Constraints:

• 0 <= nums.length <= 105
• -109 <= nums[i] <= 109
• nums is a non-decreasing array.
• -109 <= target <= 109

Solution: Binary Search

Use lower_bound to find first
Use upper_bound to find last + 1

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

// Author: Huahua
class Solution {
public:
  vector<int> searchRange(vector<int>& nums, int target) {
    auto it = lower_bound(begin(nums), end(nums), target);
    int l = (it == end(nums) || *it != target) ? -1 : it - begin(nums);
    auto it2 = upper_bound(begin(nums), end(nums), target);
    int r = (it2 == begin(nums) || *prev(it2) != target) ? -1 : prev(it2) - begin(nums);
    return {l, r};
  }
};

The post 花花酱 LeetCode 34. Find First and Last Position of Element in Sorted Array appeared first on Huahua's Tech Road.

Prior to being passed to your function, nums is possibly rotated at an unknown pivot index k (1 <= k < nums.length) such that the resulting array is [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]] (0-indexed). For example, [0,1,2,4,5,6,7] might be rotated at pivot index 3 and become [4,5,6,7,0,1,2].

Given the array nums after the possible rotation and an integer target, return the index of target if it is in nums, or -1 if it is not in nums.

You must write an algorithm with O(log n) runtime complexity.

Example 1:

Input: nums = [4,5,6,7,0,1,2], target = 0
Output: 4

Example 2:

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

Example 3:

Input: nums = [1], target = 0
Output: -1

Constraints:

• 1 <= nums.length <= 5000
• -104 <= nums[i] <= 104
• All values of nums are unique.
• nums is an ascending array that is possibly rotated.
• -104 <= target <= 104

Solution: Binary Search

If the current range [l, r] is ordered, reduce to normal binary search. Otherwise, determine the range to search next by comparing target and nums[0].

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

// Author: Huahua
class Solution {
public:
  int search(vector<int>& nums, int target) {
    int l = 0;
    int r = nums.size();
    while (l < r) {
      int m = l + (r - l) / 2;
      int x = (nums[m] < nums[0]) == (target < nums[0])
              ? nums[m]
              : target < nums[0] ? INT_MIN : INT_MAX;
      if (x < target)
        l = m + 1;
      else if (x > target)
        r = m;
      else
        return m;
    }
    return -1;
  }
};

The post 花花酱 LeetCode 33. Search in Rotated Sorted Array appeared first on Huahua's Tech Road.

The frequency of a value in a subarray is the number of occurrences of that value in the subarray.

Implement the RangeFreqQuery class:

• RangeFreqQuery(int[] arr) Constructs an instance of the class with the given 0-indexed integer array arr.
• int query(int left, int right, int value) Returns the frequency of value in the subarray arr[left...right].

A subarray is a contiguous sequence of elements within an array. arr[left...right] denotes the subarray that contains the elements of nums between indices left and right (inclusive).

Example 1:

Input
["RangeFreqQuery", "query", "query"]
[[[12, 33, 4, 56, 22, 2, 34, 33, 22, 12, 34, 56]], [1, 2, 4], [0, 11, 33]]
Output

[null, 1, 2]

Explanation RangeFreqQuery rangeFreqQuery = new RangeFreqQuery([12, 33, 4, 56, 22, 2, 34, 33, 22, 12, 34, 56]); rangeFreqQuery.query(1, 2, 4); // return 1. The value 4 occurs 1 time in the subarray [33, 4] rangeFreqQuery.query(0, 11, 33); // return 2. The value 33 occurs 2 times in the whole array.

Constraints:

• 1 <= arr.length <= 105
• 1 <= arr[i], value <= 104
• 0 <= left <= right < arr.length
• At most 105 calls will be made to query

Solution: Hashtable + Binary Search

Time complexity: Init: O(max(arr) + n), query: O(logn)
Space complexity: O(max(arr) + n)

// Author: Huahua
class RangeFreqQuery {
public:
  RangeFreqQuery(vector<int>& arr) : s_(10001) {
    for (int i = 0; i < arr.size(); ++i)
      s_[arr[i]].push_back(i);
  }

  int query(int left, int right, int value) {
    const auto& m = s_[value];
    if (m.empty()) return 0;
    auto r = prev(upper_bound(begin(m), end(m), right));
    auto l = lower_bound(begin(m), end(m), left);    
    return r - l + 1;
  }
private:
  vector<vector<int>> s_;
};
/**
 * Your RangeFreqQuery object will be instantiated and called as such:
 * RangeFreqQuery* obj = new RangeFreqQuery(arr);
 * int param_1 = obj->query(left,right,value);
 */

The post 花花酱 LeetCode 2080. Range Frequency Queries appeared first on Huahua's Tech Road.

Additionally, you have pills magical pills that will increase a worker’s strength by strength. You can decide which workers receive the magical pills, however, you may only give each worker at most one magical pill.

Given the 0-indexed integer arrays tasks and workers and the integers pills and strength, return the maximum number of tasks that can be completed.

Example 1:

Input: tasks = [3,2,1], workers = [0,3,3], pills = 1, strength = 1
Output: 3
Explanation:
We can assign the magical pill and tasks as follows:
- Give the magical pill to worker 0.
- Assign worker 0 to task 2 (0 + 1 >= 1)
- Assign worker 1 to task 1 (3 >= 2)
- Assign worker 2 to task 0 (3 >= 3)

Example 2:

Input: tasks = [5,4], workers = [0,0,0], pills = 1, strength = 5
Output: 1
Explanation:
We can assign the magical pill and tasks as follows:
- Give the magical pill to worker 0.
- Assign worker 0 to task 0 (0 + 5 >= 5)

Example 3:

Input: tasks = [10,15,30], workers = [0,10,10,10,10], pills = 3, strength = 10
Output: 2
Explanation:
We can assign the magical pills and tasks as follows:
- Give the magical pill to worker 0 and worker 1.
- Assign worker 0 to task 0 (0 + 10 >= 10)
- Assign worker 1 to task 1 (10 + 10 >= 15)

Example 4:

Input: tasks = [5,9,8,5,9], workers = [1,6,4,2,6], pills = 1, strength = 5
Output: 3
Explanation:
We can assign the magical pill and tasks as follows:
- Give the magical pill to worker 2.
- Assign worker 1 to task 0 (6 >= 5)
- Assign worker 2 to task 2 (4 + 5 >= 8)
- Assign worker 4 to task 3 (6 >= 5)

Constraints:

• n == tasks.length
• m == workers.length
• 1 <= n, m <= 5 * 104
• 0 <= pills <= m
• 0 <= tasks[i], workers[j], strength <= 109

Solution: Greedy + Binary Search in Binary Search.

Find the smallest k, s.t. we are NOT able to assign. Then answer is k- 1.

The key is to verify whether we can assign k tasks or not.

Greedy: We want k smallest tasks and k strongest workers.

Start with the hardest tasks among (smallest) k:
1. assign task[i] to the weakest worker without a pill (if he can handle the hardest work so far, then the stronger workers can handle any simpler tasks left)
2. If 1) is not possible, we find a weakest worker + pill that can handle task[i] (otherwise we are wasting workers)
3. If 2) is not possible, impossible to finish k tasks.

Let k = min(n, m)
Time complexity: O((logk)² * k)
Space complexity: O(k)

// Author: Huahua
class Solution {
public:
  int maxTaskAssign(vector<int>& tasks, vector<int>& workers, int pills, int strength) {
    const int n = tasks.size();    
    sort(begin(tasks), end(tasks));    
    sort(begin(workers), end(workers)); 
    auto check = [&](int k) {      
      multiset<int> ws(rbegin(workers), rbegin(workers) + k);
      for (int i = k - 1, p = 0; i >= 0; --i) {
        auto it = ws.lower_bound(tasks[i]);
        if (it != end(ws)) {
          ws.erase(it);
        } else if ((it = ws.lower_bound(tasks[i] - strength)) != end(ws)) {
          if (++p > pills) return false;
          ws.erase(it);
        } else {
          return false;
        }
      }
      return true;
    };
    int l = 0;
    int r = min(tasks.size(), workers.size()) + 1;
    while (l < r) {
      int m = l + (r - l) / 2;
      if (!check(m)) {
        r = m;
      } else {
        l = m + 1;
      }
    }
    return l - 1;
  }
};

The post 花花酱 LeetCode 2071. Maximum Number of Tasks You Can Assign appeared first on Huahua's Tech Road.