Number of Flowers in Full Bloom

class Solution:
    def fullBloomFlowers(self, flowers: List[List[int]], persons: List[int]) -> List[int]:
        start = []
        end = []
        for t in flowers:
        res = []
        for t in persons:
            started = bisect.bisect_right(start, t)
            ended = bisect.bisect_left(end, t)
            res.append(started - ended)
        return res

10 Prerequisite LeetCode Problems

“2251. Number of Flowers in Full Bloom” involves understanding the states of flowers (in full bloom or not) after performing some operations. This might require knowledge related to array manipulation, sorting, and interval scheduling. Here are some problems to build the necessary skills:

  1. 56. Merge Intervals: This problem deals with overlapping intervals, similar to the way flowers might overlap in blooming time.

  2. 435. Non-overlapping Intervals: This problem involves finding the maximum number of non-overlapping intervals, similar to finding the number of flowers in full bloom.

  3. 452. Minimum Number of Arrows to Burst Balloons: This problem is about interval scheduling and could be beneficial for understanding how to handle the blooming times of flowers.

  4. 253. Meeting Rooms II: This problem also deals with managing overlapping intervals, and involves sorting.

  5. 57. Insert Interval: This problem involves manipulating and merging intervals, which is a similar operation to what might be needed for this problem.

  6. 986. Interval List Intersections: This problem involves finding the intersection of two lists of intervals, which could be helpful for understanding how to determine when a flower is in bloom.

  7. 759. Employee Free Time: This problem involves finding gaps in a schedule, which is somewhat similar to finding when a flower is not in bloom.

  8. 1288. Remove Covered Intervals: This problem involves removing covered intervals, which might be useful for understanding how to handle overlapping blooming times.

  9. 1109. Corporate Flight Bookings: This problem involves tracking bookings over a series of intervals, which is similar to tracking the blooming of flowers over time.

  10. 729. My Calendar I: This problem involves scheduling non-overlapping events, which could provide insight into handling the blooming times of flowers.

Problem Analysis and Key Insights

What are the key insights from analyzing the problem statement?

Problem Boundary

What is the scope of this problem?

How to establish the boundary of this problem?

Problem Classification

The problem belongs to the domain of “Array and Interval Manipulation” in Computer Science, more specifically, it’s a type of computational problem often seen in algorithmic challenges. It also incorporates elements of time-based events (flower blooming and people arriving).


  • Input Data:

    • A 2D array flowers representing time intervals for each flower’s full bloom.
    • An array people representing the times that people arrive to see the flowers.
  • Output Data:

    • An array answer that represents the number of flowers in full bloom when each person arrives.
  • Constraints:

    • Length and element size constraints for flowers and people.
    • Timing constraints for when each flower blooms.

Further Classification

  • Problem Type: Query-based Computational Problem
  • Sub-Type: Interval Overlap Counting
  • Additional Context: None

The problem is a typical query-based computational problem where you are given a set of static intervals (flowers) and a set of query points (people). The goal is to determine the number of intervals that contain each query point. Here, intervals represent the time each flower is in full bloom, and query points represent the time people arrive to see the flowers.

The problem revolves around efficiently determining the number of overlapping intervals for each query point, making it an Interval Overlap Counting problem.

Distilling the Problem to Its Core Elements

Fundamental Concept or Principle

The fundamental concept this problem is based upon is “Interval Overlap.” You have a set of time intervals during which flowers are in bloom and discrete time points when people arrive. The core task is to find out how many intervals (flowers in bloom) overlap with each time point (person arriving).

Simplest Description

Imagine you have a list of flowers that bloom at different times. You also know exactly when people will come to see these flowers. Your job is to tell how many flowers will be in full bloom when each person arrives.

Core Problem

The core problem is to find the number of flowers that are in full bloom for each person when they arrive.

Simplified Problem Statement

Given two lists:

  1. Times when flowers bloom and wither.
  2. Times when people arrive.

For each time a person arrives, find out how many flowers are in full bloom.

Key Components

  1. Input validation: Ensure the given inputs meet the problem’s constraints.
  2. Query processing: For each person’s arrival time, calculate the number of flowers in bloom.
  3. Output generation: Create a list containing the number of flowers in bloom for each person’s arrival time.

Minimal Set of Operations

  1. Read the input lists flowers and people.
  2. Initialize an output list answer to store results.
  3. Loop through each time in the people list:
    1. For each time, loop through flowers to check how many flowers are in bloom at that moment.
    2. Add the count to answer.
  4. Return answer.

By performing these operations, you’ll solve the problem as stated. The focus is on efficiently checking how many intervals overlap with each query point.

Visual Model of the Problem

Visualizing this problem can help in understanding it better. One effective way to do so is by using a timeline or a number line to represent when each flower is in full bloom and when each person arrives.

Steps for Visualization

  1. Draw a Number Line: Create a horizontal number line where each point represents a unit of time.

  2. Mark Flower Intervals: For each flower’s blooming period [start, end], draw a horizontal line segment above the number line between the start and end times. Label these lines as Flower 1, Flower 2, etc.

  3. Mark People Arrival Times: Place vertical lines or points at the positions corresponding to each time a person arrives. Label these as Person 1, Person 2, etc.

  4. Identify Overlaps: At each vertical line (person’s arrival), check how many flower intervals overlap with it.

Example Visualization

For example, given flowers = [[1,6],[3,7],[9,12],[4,13]] and people = [2,3,7,11].

  • The number line might start at 1 and go up to 13 (or higher, based on your flower and people data).

  • The intervals for the flowers might look like horizontal line segments above these points:

    • Flower 1: [1, 6]
    • Flower 2: [3, 7]
    • Flower 3: [9, 12]
    • Flower 4: [4, 13]
  • The people’s arrival times would be vertical lines or points at:

    • Person 1: 2
    • Person 2: 3
    • Person 3: 7
    • Person 4: 11

Looking at this visualization, you can easily see that:

  • At time 2, only Flower 1 is in full bloom.
  • At time 3, Flowers 1 and 2 are in full bloom.
  • At time 7, Flowers 2 and 4 are in full bloom.
  • At time 11, Flowers 3 and 4 are in full bloom.

This visual representation provides a clear idea of how many flowers are in bloom at each person’s arrival time, helping you to understand the problem and develop a solution strategy.

Problem Restatement

You’re given two lists:

  1. flowers: A list of time intervals during which individual flowers are in full bloom. Each interval is represented as [start, end], where start and end are the times the flower starts and stops blooming.

  2. people: A list of specific times when people arrive to see the flowers.

Your task is to create a new list, answer, that will contain the number of flowers that are fully blooming when each person arrives.


  • The output list, answer, should be the same length as the people list.
  • For each person’s arrival time in people, you must count the number of flowers in full bloom at that exact time.


  • The flowers list contains between 1 and 50,000 elements.
  • Each flower’s bloom time is represented by a list of two integers, where 1 <= start <= end <= 1,000,000,000.
  • The people list contains between 1 and 50,000 elements, where each element is an integer between 1 and 1,000,000,000.

By paraphrasing the problem like this, the core challenge becomes clearer: efficiently count the number of intervals that overlap with each query point.

Abstract Representation of the Problem

An abstract representation focuses on the core elements of the problem, stripping away any context-specific details. For this problem, the abstraction can be stated as follows:

Abstract Representation

You have two sets of integers:

  1. Set A: A set of integer intervals [a, b], where a and b represent the starting and ending points of each interval. Each interval represents a condition being ’true’ or ‘active’ between a and b inclusive.

  2. Set B: A set of discrete integers, each representing a query point.

Your goal is to produce a new set, Set C, which contains, for each integer in Set B, the count of intervals in Set A that include that integer.


  • Set A: Contains the ‘active’ intervals.
  • Set B: Contains the query points.
  • Set C: The output set, which will contain the counts of overlapping intervals from Set A for each query point in Set B.


  • For each integer in Set B, find how many intervals in Set A include it.


  • The size of Set A and Set B are limited and are described by specific upper bounds.
  • Each interval [a, b] in Set A adheres to given limits for a and b.

This abstract representation encapsulates the essential structure of the problem, emphasizing the need for efficient overlap counting for each query point.


Understanding some specialized terms can be beneficial for this problem:

  1. Interval: A set of real numbers with the property that any number that lies between two numbers in the set is also included in the set. In this problem, an interval [a, b] represents the time during which a flower is in full bloom.

  2. Overlap: In the context of intervals, overlap means that two intervals share at least one point in common. Here, you need to find how many intervals from the flowers list overlap with each query point from the people list.

  3. Query Point: A specific point at which we want to evaluate a condition. In this problem, each integer in the people list serves as a query point where we want to count the number of overlapping intervals from the flowers list.

  4. Inclusive: When an interval is defined as [a, b], it means both a and b are part of the interval. This is important when counting overlaps, as both the start and end points are considered.

  5. Array: A data structure that can hold more than one value at a time. In this problem, we use arrays to hold the intervals for flowers and the query points for people.

  6. 2D Array (Two-Dimensional Array): An array of arrays. In this problem, the flowers list is a 2D array where each element is itself an array [start, end] representing an interval.

  7. Constraints: Conditions or limitations imposed on the problem. Understanding constraints like the maximum size of the arrays or the upper and lower bounds for the interval endpoints helps in choosing the right algorithmic approach.

Understanding these terms will make it easier to grasp the problem and formulate a solution. For example, knowing what “overlap” means is crucial for understanding what you’re actually supposed to count. Similarly, understanding that intervals are “inclusive” tells you that both endpoints should be considered when checking for overlaps.

Problem Simplification and Explanation

You have two lists:

  1. Flower List: Tells you when each flower will be in full bloom. Think of this as a schedule. For example, Flower 1 will be in full bloom from 9 AM to 11 AM.

  2. People List: Tells you when people will come to see the flowers. This is also like a schedule, but for visitors. For example, Person 1 will come at 9:30 AM.

Your job is to find out how many flowers each person will get to see in full bloom.

Key Concepts

  1. Time Interval: Each flower has a blooming time that starts and ends at specific times.
  2. Time Point: Each person comes at a specific time.
  3. Overlap: A person gets to see a flower if their visit time overlaps with that flower’s blooming time.


For each time point from the People List, you check all the time intervals from the Flower List to see how many flowers are in bloom. Then, you note down the count for each person.

Metaphor or Analogy

Imagine a music concert where multiple bands are scheduled to play during the day. Each band has a specific start and end time for their performance, just like the blooming times for the flowers.

People come to the concert venue at different times, and they can only listen to the bands that are playing at that moment. Your task is to tell each visitor how many bands are currently performing when they arrive.

So, for each visitor (person in the People List), you need to check the schedule (Flower List) to see how many bands (flowers) are performing (in bloom).

In this way, you help each visitor (person) know how many bands (flowers) they’ll get to enjoy during their time at the concert (flower field).


  1. Sorting: Both the flowers and people lists are not guaranteed to be in any particular order. Sorting them can allow for more efficient overlap checking, enabling us to use techniques like binary search or two-pointer traversal.

  2. Time Points: The maximum time point for both flower bloom periods and people arrival times is (10^9), a large number. However, the maximum number of flowers and people is (5 \times 10^4), much smaller in comparison. This suggests that working directly with time points, rather than ranges, can be more efficient.

  3. Bounded Interval Length: Each flower’s bloom time is described by two integers, start and end, where (1 \leq start \leq end \leq 10^9). There are no constraints that say the intervals can’t overlap, but knowing that they are bound by these numbers can be helpful when considering how to store or compare them.

  4. Fixed Interval Points: Each interval for a flower’s bloom time has a start and end point, but no points in between are explicitly provided. This allows us to potentially use a line sweep algorithm where we only consider the start and end points, rather than every point in the range.

  5. Multiple Query Points: Since you’ll be doing the same operation (counting overlapping intervals) for multiple query points (people), any precomputation that helps speed up this operation could be beneficial.

  6. Uniform Output Size: The output array should have the same size as the people array. Knowing the size of the output in advance may allow for pre-allocation of space, thereby saving computational time.

  7. Non-negative Integers: All numbers involved are positive integers, which eliminates the need to deal with zero or negative values. This simplifies the calculations and comparisons.

  8. Non-Unique People Arrival Times: Multiple people can arrive at the same time, which suggests that storing previously computed results for a given time could avoid duplicate work.

  9. Inclusion Criteria: Both start and end points are inclusive, meaning if a person arrives exactly at the start or end time of a flower’s blooming period, that flower is considered in full bloom for that person.

By identifying these characteristics and conditions, you can tailor your approach to exploit them, potentially leading to a more efficient solution.

From analyzing the constraints, we can gather several key insights:

  1. Large Time Range, Smaller Data Set: The time range can go up to (10^9), which is very large. However, the maximum number of intervals (flowers) and query points (people) is capped at (5 \times 10^4). This suggests that algorithms with time complexity tied directly to the time range would be impractical. Instead, we should focus on algorithms that work efficiently with the size of the data set.

  2. Sorting Advantage: Neither the flowers nor people lists are sorted, but sorting them could significantly improve efficiency, especially for overlap checks. Sorting both lists allows for faster, more efficient algorithms, like binary search or two-pointer methods.

  3. Potential for Precomputation: Since the same operation (counting overlapping intervals) is performed for multiple query points, precomputation techniques could be particularly effective. For instance, pre-sorting, pre-counting at each unique time point, or using a data structure like a balanced tree could speed up the queries.

  4. Uniform Output: The output list size is known in advance (same as the people list). This allows for pre-allocation and direct indexing into the output array, which could result in some computational savings.

  5. No Negative Numbers: All numbers involved are positive integers, simplifying the logic and comparisons, as we don’t have to account for zero or negative numbers.

  6. Duplication is Possible: Multiple people can arrive at the same time. This suggests that memorization or caching could be useful to avoid calculating the same value multiple times.

  7. Endpoints Matter: Both the start and end times of an interval are inclusive. This needs to be carefully handled during overlap checks to make sure flowers are correctly counted as “in bloom” for edge cases where people arrive exactly at the start or end time of an interval.

By focusing on these insights, we can aim for a solution that is both correct and optimized for the given constraints.

Case Analysis

Creating additional examples or test cases covering a wider range of inputs, including edge and boundary conditions, can offer valuable insights into the problem. Here are some categorized examples:

Single Flower, Single Person (Minimum Boundary Case)

Example 1.1
Input: flowers = [[1, 5]], people = [3]
Output: [1]

Analysis: This is the simplest possible case with only one flower and one person. The flower is in bloom from time 1 to 5, and the person arrives at time 3. The person sees the single flower in bloom, hence the output is [1].

Multiple Flowers, Single Time Point (Overlap Case)

Example 2.1
Input: flowers = [[1, 5], [3, 7], [2, 4]], people = [4]
Output: [3]

Analysis: All three flowers are in bloom when the single person arrives at time 4. This scenario checks whether the solution correctly identifies multiple overlapping intervals.

Non-Overlapping Flowers (No Overlap Case)

Example 3.1
Input: flowers = [[1, 2], [4, 5], [7, 8]], people = [3, 6]
Output: [0, 0]

Analysis: No flowers are in bloom when the people arrive. This case tests whether the solution can correctly return zero when there are no overlaps.

Overlapping and Non-Overlapping Flowers (Mixed Case)

Example 4.1
Input: flowers = [[1, 5], [6, 10], [4, 8]], people = [2, 7, 11]
Output: [1, 2, 0]

Analysis: The first person sees 1 flower, the second sees 2 flowers, and the third sees no flowers in bloom. This is a more generic scenario covering different aspects of the problem.

Duplicate Arrival Times (Duplication Case)

Example 5.1
Input: flowers = [[1, 3], [2, 4]], people = [3, 3, 3]
Output: [2, 2, 2]

Analysis: All people arrive at the same time, and they all see 2 flowers in bloom. This tests if the solution handles duplicate arrival times efficiently.

Edge Time Points (Endpoint Inclusivity Case)

Example 6.1
Input: flowers = [[1, 5], [5, 10]], people = [1, 5, 10]
Output: [1, 2, 1]

Analysis: Tests if the solution correctly considers the inclusivity of endpoints in the intervals. At time 1, the first flower is just starting to bloom. At time 5, both flowers are in bloom because endpoints are inclusive. At time 10, only the second flower is still in bloom.

All People Arrive Before/After All Flowers (Out of Range Case)

Example 7.1
Input: flowers = [[5, 10]], people = [1, 15]
Output: [0, 0]

Analysis: This tests if the solution can handle cases where all people arrive either before any flower blooms or after all flowers have stopped blooming.

These examples are designed to provide insights into the problem and ensure that the solution handles all possible scenarios. The edge cases include minimum input size, maximum input size, edge time points, and cases that test the inclusivity of endpoints.

Analyzing different test cases provides several key insights:

  1. Handling of Minimum Inputs: The solution should be able to deal with the smallest possible input sizes, like a single flower and a single person.

  2. Multiple Overlaps: Multiple flowers can be in bloom at the same time, so the solution should be able to count these accurately.

  3. Zero Overlap: There can be scenarios where no flowers are in bloom when people arrive. The solution should be able to handle such cases and return zero correctly.

  4. Mixed Scenarios: Real-world cases can include a mix of overlapping and non-overlapping intervals. The solution should be versatile enough to handle these mixed cases.

  5. Duplicate Arrival Times: Multiple people can arrive at the same time, so the solution should handle these cases efficiently, possibly using memoization to avoid redundant calculations.

  6. Endpoint Inclusivity: Endpoints in the time intervals are inclusive. The solution must account for this when determining whether a flower is in bloom.

  7. Out-of-Range Scenarios: People may arrive before any flower starts blooming or after all have stopped blooming. These are edge conditions that the solution must handle.

  8. Uniform Output: The length of the output list is the same as the input list of people. This can help in pre-allocating space for the output.

These insights guide the development of a robust and efficient solution that caters to all possible input scenarios and edge cases.

Identification of Applicable Theoretical Concepts

There are several mathematical and algorithmic concepts that can make solving this problem more efficient:

  1. Interval Overlap: The core problem involves finding overlapping intervals, a topic extensively studied in computer science. Interval trees or segment trees could be used for faster query times.

  2. Sorting: Sorting both the flowers by their start times and people by their arrival times will allow us to use more efficient algorithms. Two-pointer methods or binary search can exploit sorted data.

  3. Counting and Caching: Since we need to find how many flowers are in bloom for multiple points in time, we can preprocess the intervals and use a cache to store how many flowers are in bloom at any given point. This reduces the need to recalculate the same information.

  4. Prefix Sum: A prefix sum array could be used to keep track of the number of flowers blooming at each point in time, allowing for O(1) queries.

  5. Memoization: As multiple people can arrive at the same time, storing previously calculated results in a hash table can eliminate the need for redundant calculations.

  6. Divide and Conquer: If the input is too large, the problem could potentially be broken down into smaller sub-problems which can be solved independently and then combined.

  7. Binary Indexed Trees (Fenwick Trees): These can also be used for quick updates and queries for the number of flowers in bloom at any given time.

  8. Line Sweep Algorithm: This is a technique used to solve geometric problems, but it can be adapted here to ‘sweep’ through time points, updating the state of flowers in bloom as you go.

  9. Set Data Structure: A balanced binary search tree can keep track of currently blooming flowers. It allows for efficient insertions, deletions, and queries, which can be useful for this problem.

Understanding and applying these mathematical and algorithmic concepts can drastically improve both the implementation and efficiency of the solution.

Simple Explanation

Imagine you have a garden with different types of flowers. Each type of flower blooms and stops blooming at specific times. Now, you have friends who come to visit your garden at various times. They want to see the flowers, but not all flowers are in bloom when they visit. Your task is to tell each friend how many types of flowers they will see in full bloom when they come to visit.

Here’s a simple everyday example: Think of the blooming flowers as your favorite TV shows. Some shows air from 8-9 PM, others from 9-10 PM, and so on. Now, your friends plan to visit you, but they can only come at specific times, like 8:30 PM or 9:45 PM. You want to tell each friend how many shows they’ll be able to watch fully when they visit.

The problem is similar to figuring out what TV shows are airing when your friends visit, just like finding out which flowers are in bloom when your friends are in the garden.

Problem Breakdown and Solution Methodology

To solve this problem, I’ll break it down into manageable steps:

Steps to Solve:

  1. Sort Both Lists: Sort the list of flower bloom intervals and the list of people’s arrival times. Sorting the bloom intervals allows for quick checks on the flowers in bloom. Sorting the list of people lets us optimize the calculation for multiple people.

    • Why: Think of sorting the bloom intervals as organizing your TV guide in chronological order. This makes it easier to know which shows (or flowers) are on air when a friend visits.
  2. Initialize Counters and Containers: Create a counter to keep track of the number of flowers currently in bloom. Also, prepare a container to store the results for each person.

  3. Iterate through Sorted Lists: Use two pointers to iterate through the sorted list of flower intervals and the sorted list of people. The two pointers are like two people walking through a timeline, one checking when flowers bloom and fade, and the other noting when people arrive.

    • Why: Imagine you and a friend are going through a TV guide. You note when each show starts and ends, while your friend points out when other friends will visit. Together, you figure out how many shows each visiting friend can watch.
  4. Update and Record: As you iterate, update the counter that tracks flowers in bloom. If a flower starts blooming, increase the counter; if a flower stops blooming, decrease the counter. When a person arrives, record the current counter value in the result container.

    • Why: This is like having a clicker to count the number of shows currently on air. When a friend arrives, you simply tell them the clicker’s count.

How Parameters Affect the Solution:

  1. More Flowers or Longer Intervals: If the number of flowers increases or if the bloom intervals become longer, the computational time may increase, affecting performance. Pre-sorting becomes more important.

  2. More People: The more people in the list, the larger the output container. This could also slightly impact performance.


Let’s use the first example to demonstrate:

  • Flowers: [[1,6],[3,7],[9,12],[4,13]]
  • People: [2,3,7,11]
  1. Sort Both Lists:

    • Flowers: [[1,6],[3,7],[4,13],[9,12]]
    • People: [2,3,7,11]
  2. Initialize Counters and Containers:

    • Counter: 0
    • Results: []
  3. Iterate:

    • At time 1, first flower blooms. Counter = 1
    • At time 2, first person arrives. Result = [1]
    • At time 3, second flower blooms and second person arrives. Counter = 2, Result = [1, 2]
    • At time 4, third flower blooms. Counter = 3
    • At time 6, first flower stops blooming. Counter = 2
    • At time 7, third person arrives. Result = [1, 2, 2]
    • At time 9, fourth flower blooms. Counter = 3
    • At time 11, fourth person arrives. Result = [1, 2, 2, 2]
  4. Output the result, which is [1, 2, 2, 2].

By following these steps, we can efficiently solve the problem for any given set of flower intervals and people’s arrival times.

Inference of Problem-Solving Approach from the Problem Statement

  1. 2D Integer Array (flowers): This is a list of intervals representing when each flower blooms and fades. The intervals guide us to consider problems of overlapping intervals, which leads us to sorting and efficient querying techniques.

  2. Integer Array (people): This array signifies the time points at which we need to query the number of flowers in bloom. Because the array is not necessarily sorted, sorting it first becomes essential for efficient querying.

  3. Return an Integer Array (answer): The task requires us to output the result as an integer array, signaling that the result for each person’s arrival time is independent and can be stored in a list-like data structure.

  4. Constraints: The constraints like “1 <= flowers.length <= 5 * 10^4” and “1 <= people.length <= 5 * 10^4” tell us that the input size can be large. This suggests that we need an efficient solution, ideally O(n log n) or faster.

  5. Full Bloom (starti, endi): The terms “full bloom,” “starti,” and “endi” inform us that we are dealing with closed intervals. This means we have to consider both the start and end times inclusively while counting.

  6. 0-Indexed: The problem specifies 0-indexing, which informs us how to iterate through the lists.

  7. Inclusive: The problem states that the flower blooms from “starti to endi (inclusive),” which means that we need to consider the flower as blooming at both the start and end times.

  8. Number of Flowers in Full Bloom: This is the core problem to be solved, and it guides us to think about techniques for fast interval querying, such as sorted arrays, binary search, or interval trees.

Each of these key terms or concepts suggests a specific strategy or method to employ, such as sorting for fast querying, using counters for tracking, or leveraging advanced data structures for efficient interval management.

How did you infer from the problem statement that this problem can be solved using ?

Simple Explanation of the Proof

I’m having trouble understanding the proof of this algorithm. Could you explain it in a way that’s easy to understand?

Stepwise Refinement

High Level Steps:

  1. Preparation: 1.1. Sort the flowers array by the starti value. 1.2. Sort the people array. 1.3. Initialize an empty list, answer, to store the results. 1.4. Initialize a variable, flowerCounter, to 0 for counting the flowers in bloom.

  2. Setup Pointers and Queues: 2.1. Initialize two pointers, flowerPtr and peoplePtr, to 0. 2.2. Create an empty priority queue, endTimes, to store the end times of blooming flowers.

  3. Iterate and Query: 3.1. While peoplePtr has not reached the end of the people array: 3.1.1. For each flower with starti <= people[peoplePtr], add its endi to endTimes and increment flowerCounter. 3.1.2. Remove flowers from endTimes whose endi < people[peoplePtr] and decrement flowerCounter accordingly. 3.1.3. Append flowerCounter to answer. 3.1.4. Increment peoplePtr.

  4. Return Results: 4.1. Return the answer list.

Granular, Actionable Steps:

  1. Sort the Arrays:

    • Use a built-in sort function to sort flowers and people.
  2. Initialize Variables:

    • Set flowerCounter = 0 and answer = [].
  3. Set Pointers and Priority Queue:

    • flowerPtr = 0, peoplePtr = 0
    • Initialize endTimes as an empty priority queue.
  4. Loop Through People:

    • While looping, perform the following sub-steps:
      • Loop through flowers and update endTimes and flowerCounter.
      • Update flowerCounter based on flowers that have ended blooming.
      • Append the current count to answer.
  5. Return Result:

    • Return answer.

Independent Parts:

  1. Sorting the flowers array and sorting the people array can be done independently.
  2. Counting flowers for each person in people is independent once flowers is sorted.

Repeatable Patterns:

  1. The pattern of checking for newly blooming flowers and adding their endi to the priority queue.
  2. The pattern of checking for flowers that have stopped blooming and removing them from the priority queue.
  3. The pattern of appending the current flower count to answer for each person.

By following these refined steps, we achieve an organized and efficient solution to the problem.

Solution Approach and Analysis

Detailed Approach:

Sorting as a Time Machine

Imagine a timeline where flowers bloom and fade, and people arrive to see them. Sorting both flowers and people is like setting this timeline in order. Sorting ensures that we visit each event—either a flower’s bloom or a person’s arrival—in the order it occurs. This helps us to know exactly what’s happening at any point in time.

  1. Step 1: Sort the Flowers and People
    • Sort flowers by the starti value.
    • Sort people by their arrival time.

Counters and Priority Queue as Tools

Consider the flowerCounter as your tally board and endTimes as your reminder or alarm clock for when each flower stops blooming.

  1. Step 2: Initialize Variables
    • Initialize an empty list, answer, for the final result.
    • Set a counter, flowerCounter, to 0 for tracking the number of blooming flowers.
    • Initialize two pointers, flowerPtr and peoplePtr, to 0.
    • Use a priority queue, endTimes, to keep track of when each flower will stop blooming.

Walking Through the Timeline

As you walk through this timeline, the priority queue reminds you when each flower fades, and the tally board keeps the current count. When a person arrives, you simply tell them the count on the tally board.

  1. Step 3: Iterate Over Sorted People

    • Start iterating over the sorted people array using peoplePtr.
      1. For each person arriving, iterate over flowers starting from flowerPtr until you find a flower that hasn’t started blooming yet.
        • Add the endi of each blooming flower to the priority queue endTimes.
        • Increment flowerCounter.
      2. Remove flowers from endTimes that have already stopped blooming.
        • Decrement flowerCounter for each removed flower.
      3. Append flowerCounter to answer.
  2. Step 4: Return Answer

    • Once you have iterated over all the people, return the answer.

How Changes in Parameters Affect the Solution:

  • Increased Array Size: If flowers or people have more elements, the solution remains efficient, but the computational time would increase.
  • Larger Time Values: If the time range (starti, endi, people[i]) increases, it won’t affect the algorithm’s efficiency.

Example Case:

  • flowers = [[1, 6], [3, 7], [9, 12], [4, 13]]
  • people = [2, 3, 7, 11]
  1. Sorting:
    • flowers = [[1, 6], [3, 7], [4, 13], [9, 12]]
    • people = [2, 3, 7, 11]
  2. Initialize Variables: answer = [], flowerCounter = 0, flowerPtr = 0, peoplePtr = 0
  3. Iteration:
    • When peoplePtr = 0 (people[0] = 2): One flower is blooming ([1, 6]), answer = [1].
    • When peoplePtr = 1 (people[1] = 3): Two flowers are blooming ([1, 6] and [3, 7]), answer = [1, 2].
    • When peoplePtr = 2 (people[2] = 7): Two flowers are blooming ([3, 7] and [4, 13]), answer = [1, 2, 2].
    • When peoplePtr = 3 (people[3] = 11): Two flowers are blooming ([4, 13] and [9, 12]), answer = [1, 2, 2, 2].
  4. Return: answer = [1, 2, 2, 2]

By following this approach, you efficiently solve the problem by organizing the events on a timeline and walking through it in a controlled manner.

Identify Invariant

An invariant in this problem is the relationship between the blooming flowers and the people arriving to see them at any given point in time. Specifically, at any time t, the number of flowers in bloom is accurately represented by flowerCounter, and it should correctly indicate the count of flowers that are actively blooming at that point.

When a person arrives at time t, flowerCounter will have the exact number of flowers that are in full bloom from the sorted and filtered list of flowers. This invariant holds true as we iterate through the sorted list of people and update flowerCounter based on the sorted flowers and endTimes priority queue.

This invariant assures that we always have a real-time, accurate count of blooming flowers for each arriving person, thereby allowing us to build the answer list correctly.

Identify Loop Invariant

What is the loop invariant in this problem?

Thought Process

Basic Thought Process:

1. Understand the Problem:

The first thing to do is fully understand what is being asked. We have flowers with bloom times and people arriving at different times. We need to find out how many flowers are blooming when each person arrives.

Cues in Problem Statement:

  • We have 2D arrays and timelines, hinting that sorting may be involved.
  • We are counting overlapping ranges, which suggests the need for some form of dynamic tracking.

2. Break It Down:

  • We’ll need to sort both the flower times and people’s arrival times.
  • As we go through each sorted time, we’ll update which flowers are currently blooming.
  • When a person arrives, we simply look at our tracker to see how many flowers are blooming.

3. Consider Efficiency:

  • We’ll need an efficient way to track blooming flowers to meet the constraints. A priority queue serves well here.

4. Edge Cases and Invariants:

  • Keep in mind the possibility of multiple people arriving at the same time or multiple flowers having the same bloom times.

Coding the Final Solution:

Here’s the Python3 code that follows the thought process:

import heapq

def flowers_in_bloom(flowers, people):
    # Step 1: Sort the Flowers and People
    people = sorted(enumerate(people), key=lambda x: x[1])
    # Step 2: Initialize Variables
    answer = [0] * len(people)
    flowerCounter = 0
    flowerPtr = 0
    endTimes = []
    # Step 3: Iterate Over Sorted People
    for peoplePtr, arrival_time in people:
        # Add flowers that start blooming before or at this arrival_time
        while flowerPtr < len(flowers) and flowers[flowerPtr][0] <= arrival_time:
            heapq.heappush(endTimes, flowers[flowerPtr][1])
            flowerPtr += 1
            flowerCounter += 1
        # Remove flowers that have already stopped blooming
        while endTimes and endTimes[0] < arrival_time:
            flowerCounter -= 1
        # Store the answer for this person
        answer[peoplePtr] = flowerCounter
    # Step 4: Return Answer
    return answer

# Example usage:
flowers = [[1, 6], [3, 7], [9, 12], [4, 13]]
people = [2, 3, 7, 11]
print(flowers_in_bloom(flowers, people))  # Output should be [1, 2, 2, 2]


  • Sorting is a powerful tool for problems dealing with ranges and time, as it helps you to linearly walk through events.
  • Priority queues are effective for tracking elements that have both a start and an end time, as they allow you to efficiently know when an element “expires” or should be removed.
  • The invariant in this case ensures that flowerCounter accurately represents the count of blooming flowers at any arrival time, which simplifies the construction of the answer list.

Establishing Preconditions and Postconditions

  1. Parameters:

    • What are the inputs to the method?
    • What types are these parameters?
    • What do these parameters represent in the context of the problem?
  2. Preconditions:

    • Before this method is called, what must be true about the state of the program or the values of the parameters?
    • Are there any constraints on the input parameters?
    • Is there a specific state that the program or some part of it must be in?
  3. Method Functionality:

    • What is this method expected to do?
    • How does it interact with the inputs and the current state of the program?
  4. Postconditions:

    • After the method has been called and has returned, what is now true about the state of the program or the values of the parameters?
    • What does the return value represent or indicate?
    • What side effects, if any, does the method have?
  5. Error Handling:

    • How does the method respond if the preconditions are not met?
    • Does it throw an exception, return a special value, or do something else?

Problem Decomposition

  1. Problem Understanding:

    • Can you explain the problem in your own words? What are the key components and requirements?
  2. Initial Breakdown:

    • Start by identifying the major parts or stages of the problem. How can you break the problem into several broad subproblems?
  3. Subproblem Refinement:

    • For each subproblem identified, ask yourself if it can be further broken down. What are the smaller tasks that need to be done to solve each subproblem?
  4. Task Identification:

    • Within these smaller tasks, are there any that are repeated or very similar? Could these be generalized into a single, reusable task?
  5. Task Abstraction:

    • For each task you’ve identified, is it abstracted enough to be clear and reusable, but still makes sense in the context of the problem?
  6. Method Naming:

    • Can you give each task a simple, descriptive name that makes its purpose clear?
  7. Subproblem Interactions:

    • How do these subproblems or tasks interact with each other? In what order do they need to be performed? Are there any dependencies?

From Brute Force to Optimal Solution

Brute-Force Solution:

The most straightforward way to solve this problem is by using nested loops to go through each person’s arrival time and count the number of flowers that are in bloom at that specific moment.

Here’s how the brute-force solution would look in Python:

def flowers_in_bloom_brute_force(flowers, people):
    answer = []
    for time in people:
        count = 0
        for flower in flowers:
            if flower[0] <= time <= flower[1]:
                count += 1
    return answer

# Example usage:
flowers = [[1, 6], [3, 7], [9, 12], [4, 13]]
people = [2, 3, 7, 11]
print(flowers_in_bloom_brute_force(flowers, people))  # Output should be [1, 2, 2, 2]


  1. Time Complexity: The time complexity is (O(n \times m)), where (n) is the length of the flowers list and (m) is the length of the people list. This is quite inefficient given the constraints.

Optimized Solution:

To optimize, we can take advantage of sorting and use a priority queue (heap) to keep track of ending times of the blooming flowers. This way, we only need to go through the list of flowers and people once, updating our count and heap as needed.

Here’s how the optimized solution could look:

import heapq

def flowers_in_bloom(flowers, people):
    people = sorted(enumerate(people), key=lambda x: x[1])

    answer = [0] * len(people)
    flowerCounter = 0
    flowerPtr = 0
    endTimes = []
    for peoplePtr, arrival_time in people:
        while flowerPtr < len(flowers) and flowers[flowerPtr][0] <= arrival_time:
            heapq.heappush(endTimes, flowers[flowerPtr][1])
            flowerPtr += 1
            flowerCounter += 1
        while endTimes and endTimes[0] < arrival_time:
            flowerCounter -= 1
        answer[peoplePtr] = flowerCounter
    return answer


  1. Sorting: Both flowers and people are sorted once, which helps in maintaining a count of blooming flowers as time progresses.

  2. Heap: A heap is used to efficiently track the ending times of currently blooming flowers.

Complexity Analysis:

  1. Time Complexity: Sorting takes (O(n \log n)) for flowers and (O(m \log m)) for people. The loops for updating the flowerCounter take (O(n)) for flowers and (O(m)) for people. Thus, the total time complexity is (O(n \log n + m \log m)).

  2. Space Complexity: The additional space used is (O(n)) for the heap and (O(m)) for the answer, which is (O(n + m)).

The optimized solution is much more efficient than the brute-force approach, both in terms of time and space complexity.

To implement the optimized solution in a class, you can use the following code:

from typing import List
import heapq

class Solution:
    def fullBloomFlowers(self, flowers: List[List[int]], persons: List[int]) -> List[int]:
        # Sort the flowers based on their start time
        # Sort persons based on arrival time, also keep track of their original indices
        persons = sorted(enumerate(persons), key=lambda x: x[1])

        # Initialize the answer list and flower counter
        answer = [0] * len(persons)
        flowerCounter = 0
        flowerPtr = 0
        endTimes = []  # Priority queue to store end times of blooming flowers

        # Iterate through sorted persons
        for personPtr, arrival_time in persons:
            # Add blooming flowers to the heap
            while flowerPtr < len(flowers) and flowers[flowerPtr][0] <= arrival_time:
                heapq.heappush(endTimes, flowers[flowerPtr][1])
                flowerPtr += 1
                flowerCounter += 1

            # Remove flowers that are no longer in bloom
            while endTimes and endTimes[0] < arrival_time:
                flowerCounter -= 1

            # Store the count of blooming flowers for this person
            answer[personPtr] = flowerCounter

        return answer

# Example usage:
sol = Solution()
flowers = [[1, 6], [3, 7], [9, 12], [4, 13]]
persons = [2, 3, 7, 11]
print(sol.fullBloomFlowers(flowers, persons))  # Output should be [1, 2, 2, 2]

The Solution class contains a method called fullBloomFlowers, which takes two arguments: a list of lists flowers and a list persons. It returns a list of integers representing the count of flowers in full bloom when each person arrives. The method uses sorting and a heap to optimize the solution.

Code Explanation and Design Decisions

  1. Initial Parameters:
  • flowers: A list of lists, where each sub-list has a start and end time indicating when a flower is in full bloom. The significance is to know the bloom period for each flower.
  • persons: A list of integers representing the times people arrive to see the flowers. The significance is to find how many flowers each person will see in full bloom.
  1. Primary Loop:
  • The primary loop iterates over each person sorted by their arrival time. Each iteration represents a unique arrival time of a person, and the goal is to count how many flowers are in full bloom at that time.
  1. Conditions or Branches:
  • The first while loop adds flowers that have started blooming by the person’s arrival time to a heap.
  • The second while loop removes flowers from the heap that are no longer in bloom at the person’s arrival time.

These conditions help filter the relevant flowers for each person’s arrival time.

  1. Updates or Modifications:
  • flowerPtr advances to avoid rechecking the same flowers.
  • flowerCounter keeps the current count of blooming flowers.
  • endTimes (heap) adds or removes flower end times based on the current time.

These updates help in maintaining the state of the system (i.e., number of currently blooming flowers) at each person’s arrival time.

  1. Invariant:
  • The flowerCounter is an invariant that represents the exact number of flowers in full bloom at any point in time, given the conditions (start and end times). It ensures that at any person’s arrival time, the solution has the correct number of currently blooming flowers.
  1. Final Output:
  • The final output is a list answer, where answer[i] tells the number of flowers in full bloom when the i-th person arrives. It satisfies the problem’s requirement by providing this information for each person.

Coding Constructs

  1. High-Level Strategies:
  • Sorting for efficient time comparison
  • Priority Queue (Min-Heap) for tracking bloom periods
  • Pointer traversal to avoid redundant checks
  1. Non-Programmer Explanation:
  • The code figures out how many flowers are fully open when each person arrives at a garden. It does this in a smart way so that it doesn’t have to check each flower for each person, making it faster.
  1. Logical Elements:
  • Sorting mechanism
  • Loops for iteration
  • Conditional branches (if and while statements)
  • Counters and pointers
  • Data structures (list and heap)
  1. Algorithmic Approach in Plain English:
  • First, sort the people by when they arrive.
  • Start with the first person and keep a counter at zero.
  • As you go through the list of people, check which flowers bloom by that time and add their end times to a list.
  • Also, remove any flowers from the list that are no longer blooming.
  • The counter will then tell you how many flowers are blooming when each person arrives.
  1. Key Steps or Operations:
  • Sort the persons array for efficient time comparison.
  • Traverse each sorted arrival time and update the heap and counter based on flower bloom periods.
  • Store the counter’s value at each arrival time in the output list.

These steps allow us to efficiently determine the number of blooming flowers at each person’s arrival time without redundant checks.

  1. Algorithmic Patterns:
  • Sorting for preprocessing
  • Two-pointer technique for tracking flower bloom status
  • Priority Queue (Min-Heap) for maintaining end times in sorted order, allowing for quick insertions and deletions.

Language Agnostic Coding Drills

  1. Distinct Coding Concepts:
  • Variable Initialization: Setting up variables to store data.
  • List Manipulation: Handling list operations like appending elements.
  • Sorting: Arranging elements in a specific order.
  • Looping: Iterating over arrays/lists to perform operations.
  • Conditional Statements: Using if and while for decision-making.
  • Counter: Maintaining a count of specific elements.
  • Priority Queue (Min-Heap): A specialized data structure for tracking elements based on their priorities.
  • Two-Pointer Technique: Using two pointers to traverse an array efficiently.
  1. List of Concepts in Order of Increasing Difficulty:
  • Variable Initialization: The basis for holding data, simplest to understand.
  • List Manipulation: Simple but requires understanding of data structures.
  • Looping: Fundamental to almost all algorithms, involves control flow.
  • Conditional Statements: Requires logical reasoning but is straightforward.
  • Sorting: More advanced as it involves ordering data based on specific criteria.
  • Counter: A bit more complex because it involves state management within loops.
  • Two-Pointer Technique: Requires a solid understanding of arrays and efficient traversal.
  • Priority Queue (Min-Heap): Most advanced, involves understanding a specialized data structure and its operations.
  1. Problem-Solving Approach:
  • Start by initializing variables like counters and lists to store blooming flowers.
  • Sort the list of people’s arrival times for efficient comparison.
  • Create a loop to go through each person’s arrival time.
    • Inside the loop, another loop checks flowers’ bloom times.
      • If a flower starts to bloom, it’s added to a priority queue, and the counter increases.
      • If a flower is no longer in bloom, it’s removed from the priority queue, and the counter decreases.
    • The current value of the counter (number of blooming flowers) is stored in the result list.
  • Each of these steps contributes to making the final solution both accurate and efficient. We are able to tell exactly how many flowers are in full bloom when each person arrives while also minimizing the amount of computational work needed.

Targeted Drills in Python

1. Python-based Coding Drills for General Concepts:

Variable Initialization

# Initialize an integer variable and a list
my_integer = 0
my_list = []

List Manipulation

# Append elements to a list
my_list = []


# Iterate through a list
for element in my_list:

Conditional Statements

# If-Else Statement
if my_integer == 0:
    print("Not Zero")


# Sort a list
my_list = [3, 1, 2]
sorted_list = sorted(my_list)


# Count the occurrences of each element in a list
from collections import Counter
my_list = [1, 1, 2, 3, 3]
count_elements = Counter(my_list)

Two-Pointer Technique

# Use two pointers to find the sum of two elements that equals a target
my_list = [1, 2, 3, 4, 5]
target = 6
left, right = 0, len(my_list) - 1
while left < right:
    current_sum = my_list[left] + my_list[right]
    if current_sum == target:
        print(f"Found: {my_list[left]}, {my_list[right]}")
    elif current_sum < target:
        left += 1
        right -= 1

Priority Queue (Min-Heap)

# Use a priority queue to keep track of smallest elements
import heapq
my_heap = []
heapq.heappush(my_heap, 3)
heapq.heappush(my_heap, 1)
heapq.heappush(my_heap, 2)
smallest = heapq.heappop(my_heap)  # pops 1

2. Problem-Specific Drills

None needed

For the given problem, all required concepts are general; no problem-specific drills are needed.

3. Integration

  • First, initialize the variables and lists to store flower bloom times, people’s arrival times, and the result.
  • Sort the list of people’s arrival times.
  • Use a loop to iterate through sorted people’s arrival times.
    • Inside this loop, use another loop to go through each flower’s bloom time.
      • Apply conditional statements to determine if the flower starts or stops blooming.
        • Update your priority queue and counter accordingly.
      • Append the counter value to the result list after each person’s check.
  • Return the final result list.


What are the reasons for making these mistakes in the given code?

Similar Problems

The original problem involves list manipulation, conditional statements, and possibly sorting or priority queues. Here are 10 LeetCode problems that require similar problem-solving strategies:

  1. Two Sum (LeetCode 1)

    • Similarity: Uses list iteration and conditional statements.
  2. Merge Intervals (LeetCode 56)

    • Similarity: Involves sorting and list manipulation to merge intervals.
  3. Top K Frequent Elements (LeetCode 347)

    • Similarity: Uses a counter and a priority queue (min-heap).
  4. Valid Parentheses (LeetCode 20)

    • Similarity: Requires list manipulation through stack operations.
  5. Contains Duplicate (LeetCode 217)

    • Similarity: Uses a counter to count occurrences of elements.
  6. Intersection of Two Arrays II (LeetCode 350)

    • Similarity: Involves list iteration and using a counter.
  7. Find All Numbers Disappeared in an Array (LeetCode 448)

    • Similarity: Uses list manipulation and conditional statements.
  8. 3Sum (LeetCode 15)

    • Similarity: Requires sorting and uses a two-pointer technique.
  9. Maximum Subarray (LeetCode 53)

    • Similarity: Uses list iteration and conditional statements.
  10. Meeting Rooms II (LeetCode 253)

    • Similarity: Involves sorting and a priority queue for scheduling.

These problems share common ground with the original problem in terms of list manipulation, sorting, conditional checks, or usage of counters and priority queues.