The performance of a team is the sum of their engineers’ speeds multiplied by the minimum efficiency among their engineers. 

Example 1:

Input: n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 2
Output: 60
Explanation: 
We have the maximum performance of the team by selecting engineer 2 (with speed=10 and efficiency=4) and engineer 5 (with speed=5 and efficiency=7). That is, performance = (10 + 5) * min(4, 7) = 60.

Example 2:

Input: n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 3
Output: 68
Explanation:
This is the same example as the first but k = 3. We can select engineer 1, engineer 2 and engineer 5 to get the maximum performance of the team. That is, performance = (2 + 10 + 5) * min(5, 4, 7) = 68.

Example 3:

Input: n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 4
Output: 72

Constraints:

• 1 <= n <= 10^5
• speed.length == n
• efficiency.length == n
• 1 <= speed[i] <= 10^5
• 1 <= efficiency[i] <= 10^8
• 1 <= k <= n

Solution: Greedy + Sliding Window

1. Sort engineers by their efficiency in descending order.
2. For each window of K engineers (we can have less than K people in the first k-1 windows), ans is sum(speed) * min(efficiency).

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

// Author: Huahua
class Solution {
public:
  int maxPerformance(int n, vector<int>& speed, vector<int>& efficiency, int k) {
    vector<pair<int, int>> es;
    for (int i = 0; i < n; ++i)
      es.push_back({efficiency[i], speed[i]});
    sort(rbegin(es), rend(es));
    priority_queue<int, vector<int>, greater<int>> q;
    long sum = 0;
    long ans = 0;
    for (int i = 0; i < n; ++i) {
      if (i >= k) {
        sum -= q.top();
        q.pop();
      }
      sum += es[i].second;
      q.push(es[i].second);
      ans = max(ans, sum * es[i].first);
    }
    return ans % static_cast<int>(1e9 + 7);
  }
};

# Author: Huahua
class Solution:
  def maxPerformance(self, n: int, speed: List[int], efficiency: List[int], k: int) -> int:
    speeds = 0
    ans = 0
    q = []
    for e, s in sorted(zip(efficiency, speed), reverse=True):
      if len(q) >= k:
        speeds -= heapq.heappop(q)
      speeds += s
      heapq.heappush(q, s)
      ans = max(ans, speeds * e)
    return ans % (10**9 + 7)

The post 花花酱 LeetCode 1383. Maximum Performance of a Team 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.

Given a list of non-negative numbers and a target integer k, write a function to check if the array has a continuous subarray of size at least 2 that sums up to the multiple of k, that is, sums up to n*k where n is also an integer.

Example 1:

Input: [23, 2, 4, 6, 7],  k=6
Output: True
Explanation: Because [2, 4] is a continuous subarray of size 2 and sums up to 6.

Example 2:

Input: [23, 2, 6, 4, 7],  k=6
Output: True
Explanation: Because [23, 2, 6, 4, 7] is an continuous subarray of size 5 and sums up to 42.

Note:

1. The length of the array won’t exceed 10,000.
2. You may assume the sum of all the numbers is in the range of a signed 32-bit integer.

Special case:

nums = [0,0], k = 0, return = True

Solution: Prefix Sum Reminder

Time complexity: O(n)

Space complexity: O(min(n, k))

// Author: Huahua
// Running time: 16 ms (<99.62%)
class Solution {
public:
  bool checkSubarraySum(vector<int>& nums, int k) {    
    unordered_map<int, int> m; // sum % k -> first index
    m[0] = -1;
    int sum = 0;
    for (int i = 0; i < nums.size(); ++i) {
      sum += nums[i];
      if (k != 0) sum %= k;      
      if (m.count(sum)) {
        if (i - m.at(sum) > 1) return true;
      } else {
        m[sum] = i;
      }
    }
    return false;
  }
};

Related Problems

• 花花酱 LeetCode 560. Subarray Sum Equals K
• 花花酱 LeetCode 525. Contiguous Array

The post 花花酱 LeetCode 523. Continuous Subarray Sum appeared first on Huahua's Tech Road.