2251

2251. Number of Flowers in Full Bloom (Hard)

You are given a 0-indexed 2D integer array flowers, where flowers[i] = [starti, endi] means the ith flower will be in full bloom from starti to endi (inclusive). You are also given a 0-indexed integer array people of size n, where people[i] is the time that the ith person will arrive to see the flowers.

Return an integer array answer of size n, where answer[i] is the number of flowers that are in full bloom when the ith person arrives.

 

Example 1:

Input: flowers = [[1,6],[3,7],[9,12],[4,13]], poeple = [2,3,7,11]
Output: [1,2,2,2]
Explanation: The figure above shows the times when the flowers are in full bloom and when the people arrive.
For each person, we return the number of flowers in full bloom during their arrival.

Example 2:

Input: flowers = [[1,10],[3,3]], poeple = [3,3,2]
Output: [2,2,1]
Explanation: The figure above shows the times when the flowers are in full bloom and when the people arrive.
For each person, we return the number of flowers in full bloom during their arrival.

 

Constraints:

• 1 <= flowers.length <= 5 * 104
• flowers[i].length == 2
• 1 <= starti <= endi <= 109
• 1 <= people.length <= 5 * 104
• 1 <= people[i] <= 109

Companies: Google

Related Topics:
Array, Hash Table, Binary Search, Sorting, Prefix Sum, Ordered Set

Similar Questions:

• Meeting Rooms II (Medium)
• Minimum Interval to Include Each Query (Hard)

Hints:

• Notice that for any given time t, the number of flowers blooming at time t is equal to the number of flowers that have started blooming minus the number of flowers that have already stopped blooming.
• We can obtain these values efficiently using binary search.
• We can store the starting times in sorted order, which then allows us to binary search to find how many flowers have started blooming for a given time t.
• We do the same for the ending times to find how many flowers have stopped blooming at time t.

Solution 1.

// OJ: https://leetcode.com/problems/number-of-flowers-in-full-bloom
// Author: github.com/lzl124631x
// Time: O(FlogF + PlogP + PlogF)
// Space: O(F + P)
class Solution {
public:
    vector<int> fullBloomFlowers(vector<vector<int>>& F, vector<int>& P) {
        int M = F.size(), N = P.size();
        vector<int> ans(N), id(N);
        iota(begin(id), end(id), 0); // people ids
        sort(begin(id), end(id), [&](int a, int b) { return P[a] < P[b]; }); // Sort people
        sort(begin(F), end(F)); // sort flowers in ascending order of start time
        priority_queue<int, vector<int>, greater<>> pq; // a min heap of blooming flowers' end times
        for (int i = 0, j = 0; i < N; ++i) {
            int p = P[id[i]];
            while (j < M && F[j][0] <= p) pq.push(F[j++][1]); // push end time of flowers that `<=` people[i]'s arrival time into the min heap
            while (pq.size() && pq.top() < p) pq.pop(); // remove flowers that ended blooming before people[i]'s arrival time from the min heap
            ans[id[i]] = pq.size();
        }
        return ans;
    }
};