You are given a 0-indexed 2D integer array, flowers, where each element flowers[i] $= [start_i, end_i]$ represents the time interval during which the $i^{th}$ flower is in full bloom (inclusive).

You are also given a 0-indexed integer array, people, of size $n$, where people[i] denotes the time at which the $i^{th}$ person arrives to view the flowers.

For each person, determine how many flowers are in full bloom at their arrival time. Return an integer array, ans, of length $n$, where ans[i] is the number of blooming flowers when the $i^{th}$ person arrives.

Constraints:

• 1 $\leq$ flowers.length $\leq$ $10^3$

• flowers[i].length $== 2$

• 1 $\leq$ $start_i$ $\leq$ $end_i$ $\leq$ $10^4$

• 1 $\leq$ people.length $\leq$ $10^3$

• 1 $\leq$ people[i] $\leq$ $10^4$

The core intuition behind this solution is to avoid directly simulating flower blooming across all possible time values, which would be inefficient. Instead, we transform the problem into one of counting intervals using binary search. The challenge is to determine a person’s arrival time. The difference between these two counts gives the number of flowers in bloom at that moment.

To achieve this, the solution separates the flowers’ intervals into two lists: one for start times and one for end times. The key trick is that the end times are stored as $end_i + 1$ instead of $end_i$. This ensures that when a person arrives at exactly $end_i$, the flower is still counted as blooming. With both lists sorted, we can use binary search to quickly determine counts for any arrival time.

Let’s break down the key steps of the solution:

1. Initialize the starts and ends arrays for storing start and end times, respectively.

2. Iterate over each flower interval $[start_i, end_i]$.

   1. Add $start_i$ to the starts list.

   2. Add $end_i+1$ to the ends list (to account for inclusive ranges).

3. Sort both lists to ensure that binary search can efficiently count the number of flowers that started or ended before a given arrival time.

4. Create an ans list of size $n$ to store the answer for each person.

5. Iterate over people array and for each person’s arrival time, perform two binary searches:

   1. On starts, find how many flowers began blooming at or before the arrival time.

   2. On ends, find how many flowers had already finished blooming before the arrival time.

   3. Store the difference between the counts in the ans array.

6. After completing the iteration, return the ans array as the output.

Binary search implementation details:

1. The binarySearch function is a modified version of the standard algorithm.

2. It returns the index of the first element greater than the target (upper bound).

3. This effectively gives the count of values $\leq$ target.

Let’s look at the following illustration to get a better understanding of the solution: