Posts tagged as “priority_queue”

花花酱 LeetCode 2208. Minimum Operations to Halve Array Sum

By zxi on March 21, 2022

You are given an array nums of positive integers. In one operation, you can choose any number from nums and reduce it to exactly half the number. (Note that you may choose this reduced number in future operations.)

Return the minimum number of operations to reduce the sum of nums by at least half.

Example 1:

Input: nums = [5,19,8,1]
Output: 3
Explanation: The initial sum of nums is equal to 5 + 19 + 8 + 1 = 33.
The following is one of the ways to reduce the sum by at least half:
Pick the number 19 and reduce it to 9.5.
Pick the number 9.5 and reduce it to 4.75.
Pick the number 8 and reduce it to 4.
The final array is [5, 4.75, 4, 1] with a total sum of 5 + 4.75 + 4 + 1 = 14.75. 
The sum of nums has been reduced by 33 - 14.75 = 18.25, which is at least half of the initial sum, 18.25 >= 33/2 = 16.5.
Overall, 3 operations were used so we return 3.
It can be shown that we cannot reduce the sum by at least half in less than 3 operations.

Example 2:

Input: nums = [3,8,20]
Output: 3
Explanation: The initial sum of nums is equal to 3 + 8 + 20 = 31.
The following is one of the ways to reduce the sum by at least half:
Pick the number 20 and reduce it to 10.
Pick the number 10 and reduce it to 5.
Pick the number 3 and reduce it to 1.5.
The final array is [1.5, 8, 5] with a total sum of 1.5 + 8 + 5 = 14.5. 
The sum of nums has been reduced by 31 - 14.5 = 16.5, which is at least half of the initial sum, 16.5 >= 31/2 = 16.5.
Overall, 3 operations were used so we return 3.
It can be shown that we cannot reduce the sum by at least half in less than 3 operations.

Constraints:

1 <= nums.length <= 10⁵
1 <= nums[i] <= 10⁷

Solution: Greedy + PriorityQueue/Max Heap

Always half the largest number, put all the numbers onto a max heap (priority queue), extract the largest one, and put reduced number back.

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

C++

// Author: Huahua

class Solution {

public:

int halveArray(vector<int>& nums) {

double sum = accumulate(begin(nums), end(nums), 0.0);

priority_queue<double> q;

for (int num : nums) q.push(num);

int ans = 0;

for (double cur = sum; cur > sum / 2; ++ans) {

double num = q.top(); q.pop();

cur -= num / 2;

q.push(num / 2);

}

return ans;

}

};

花花酱 LeetCode 1962. Remove Stones to Minimize the Total

By zxi on December 31, 2021

You are given a 0-indexed integer array piles, where piles[i] represents the number of stones in the i^th pile, and an integer k. You should apply the following operation exactly k times:

Choose any piles[i] and remove floor(piles[i] / 2) stones from it.

Notice that you can apply the operation on the same pile more than once.

Return the minimum possible total number of stones remaining after applying the k operations.

floor(x) is the greatest integer that is smaller than or equal to x (i.e., rounds x down).

Example 1:

Input: piles = [5,4,9], k = 2
Output: 12
Explanation: Steps of a possible scenario are:
- Apply the operation on pile 2. The resulting piles are [5,4,5].
- Apply the operation on pile 0. The resulting piles are [3,4,5].
The total number of stones in [3,4,5] is 12.

Example 2:

Input: piles = [4,3,6,7], k = 3
Output: 12
Explanation: Steps of a possible scenario are:
- Apply the operation on pile 2. The resulting piles are [4,3,3,7].
- Apply the operation on pile 3. The resulting piles are [4,3,3,4].
- Apply the operation on pile 0. The resulting piles are [2,3,3,4].
The total number of stones in [2,3,3,4] is 12.

Constraints:

1 <= piles.length <= 10⁵
1 <= piles[i] <= 10⁴
1 <= k <= 10⁵

Solution: Greedy / Heap

Always choose the largest pile to remove.

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

C++

// Author: Huahua

class Solution {

public:

int minStoneSum(vector<int>& piles, int k) {

int total = accumulate(begin(piles), end(piles), 0);

priority_queue<int> q(begin(piles), end(piles));

while (k--) {

int curr = q.top(); q.pop();

int remove = curr / 2;

total -= remove;

q.push(curr - remove);

}

return total;

}

};

花花酱 LeetCode 1606. Find Servers That Handled Most Number of Requests

By zxi on October 3, 2020

You have k servers numbered from 0 to k-1 that are being used to handle multiple requests simultaneously. Each server has infinite computational capacity but cannot handle more than one request at a time. The requests are assigned to servers according to a specific algorithm:

The i^th (0-indexed) request arrives.
If all servers are busy, the request is dropped (not handled at all).
If the (i % k)^th server is available, assign the request to that server.
Otherwise, assign the request to the next available server (wrapping around the list of servers and starting from 0 if necessary). For example, if the i^th server is busy, try to assign the request to the (i+1)^th server, then the (i+2)^th server, and so on.

You are given a strictly increasing array arrival of positive integers, where arrival[i] represents the arrival time of the i^th request, and another array load, where load[i] represents the load of the i^th request (the time it takes to complete). Your goal is to find the busiest server(s). A server is considered busiest if it handled the most number of requests successfully among all the servers.

Return a list containing the IDs (0-indexed) of the busiest server(s). You may return the IDs in any order.

Example 1:

Input: k = 3, arrival = [1,2,3,4,5], load = [5,2,3,3,3] 
Output: [1] 
Explanation:
All of the servers start out available.
The first 3 requests are handled by the first 3 servers in order.
Request 3 comes in. Server 0 is busy, so it's assigned to the next available server, which is 1.
Request 4 comes in. It cannot be handled since all servers are busy, so it is dropped.
Servers 0 and 2 handled one request each, while server 1 handled two requests. Hence server 1 is the busiest server.

Example 2:

Input: k = 3, arrival = [1,2,3,4], load = [1,2,1,2]
Output: [0]
Explanation:
The first 3 requests are handled by first 3 servers.
Request 3 comes in. It is handled by server 0 since the server is available.
Server 0 handled two requests, while servers 1 and 2 handled one request each. Hence server 0 is the busiest server.

Example 3:

Input: k = 3, arrival = [1,2,3], load = [10,12,11]
Output: [0,1,2]
Explanation: Each server handles a single request, so they are all considered the busiest.

Example 4:

Input: k = 3, arrival = [1,2,3,4,8,9,10], load = [5,2,10,3,1,2,2]
Output: [1]

Example 5:

Input: k = 1, arrival = [1], load = [1]
Output: [0]

Constraints:

1 <= k <= 10⁵
1 <= arrival.length, load.length <= 10⁵
arrival.length == load.length
1 <= arrival[i], load[i] <= 10⁹
arrival is strictly increasing.

Solution: Heap + TreeSet

Use a min heap to store the release time -> server.
Use a treeset to track the current available servers.
For reach request, check whether servers can be released at that time.

Time complexity: O(nlogk)
Space complexity: O(k)

C++

// Author: Huahua

class Solution {

public:

vector<int> busiestServers(int k, vector<int>& arrival, vector<int>& load) {

priority_queue<pair<int, int>, vector<pair<int,int>>, greater<>> q; // {release_time, server}

set<int> servers;

vector<int> requests(k);

for (int i = 0; i < k; ++i)

servers.insert(i);

for (int i = 0; i < arrival.size(); ++i) {

const int t = arrival[i];

const int l = load[i];

// Release servers. O(logk) per pop()

while (!q.empty() && q.top().first <= t) {

servers.insert(q.top().second);

q.pop();

}

// Drop the request.

if (servers.empty()) continue;

// Find first avaiable one O(logk)

auto it = servers.lower_bound(i % k);

if (it == servers.end()) it = begin(servers);

const int idx = *it;

++requests[idx];

servers.erase(it);

q.emplace(t + l, idx);

}

const int max_req = *max_element(begin(requests), end(requests));

vector<int> ans;

for (int i = 0; i < k; ++i)

if (requests[i] == max_req) ans.push_back(i);

return ans;

}

};

花花酱 LeetCode 628. Maximum Product of Three Numbers

By zxi on August 17, 2018

Problem

Given an integer array, find three numbers whose product is maximum and output the maximum product.

Example 1:

Input: [1,2,3]
Output: 6

Example 2:

Input: [1,2,3,4]
Output: 24

Note:

The length of the given array will be in range [3,10⁴] and all elements are in the range [-1000, 1000].
Multiplication of any three numbers in the input won’t exceed the range of 32-bit signed integer.

Idea:

Find the top 3 numbers t1, t2, t3, and bottom 2 numbers, b1, b2.

If all numbers are positives, answer must be t1 * t2 * t3.

Since the number can go negative, the answer must be either t1*t2*t3 or b1 * b2 * t1, if b1 and b2 are both negatives.

ex. nums: [5, 1, -6, 3, -1]

t1, t2, t3: 5, 3, 1

b1, b2: -6, -1

t1 * t2 * t3 = 15

t1 * b1 * b2 = 30

Solution 1: Manual Tracking

Time complexity: O(n)

Space complexity: O(1)

// Author: Huahua

// Running time: 28 ms

class Solution {

public:

int maximumProduct(vector<int>& nums) {

int max1 = INT_MIN;

int max2 = INT_MIN;

int max3 = INT_MIN;

int min1 = INT_MAX;

int min2 = INT_MAX;

for (const int num: nums) {

if (num > max1) {

max3 = max2;

max2 = max1;

max1 = num;

} else if (num > max2) {

max3 = max2;

max2 = num;

} else if (num > max3) {

max3=num;

}

if (num < min1) {

min2 = min1;

min1 = num;

} else if (num < min2) {

min2=num;

}

return max(max1*max2*max3, max1*min1*min2);

}

};

Solution 2: Sorting

Time complexity: O(nlogn)

Space complexity: O(1)

// Author: Huahua

// Running time: 48 ms

class Solution {

public:

int maximumProduct(vector<int>& nums) {

int n = nums.size();

sort(nums.rbegin(), nums.rend());

return max(nums[0] * nums[1] * nums[2], nums[0] * nums[n - 1] * nums[n - 2]);

}

};

Solution 3: Two Heaps (Priority Queues)

Time complexity: O(nlog3)

Space complexity: O(2 + 3)

// Author: Huahua

// Running time: 40 ms

class Solution {

public:

int maximumProduct(vector<int>& nums) {

priority_queue<int, vector<int>, less<int>> min_q; // max_heap

priority_queue<int, vector<int>, greater<int>> max_q; // min_heap

for (int num : nums) {

max_q.push(num);

if (max_q.size() > 3) max_q.pop();

min_q.push(num);

if (min_q.size() > 2) min_q.pop();

}

int max3 = max_q.top(); max_q.pop();

int max2 = max_q.top(); max_q.pop();

int max1 = max_q.top(); max_q.pop();

int min2 = min_q.top(); min_q.pop();

int min1 = min_q.top(); min_q.pop();

return max(max1 * max2 * max3, max1 * min1 * min2);

}

};