Minimum Number of Arrows to Burst Balloons

Minimum Number of Arrows to Burst Balloons - Problem

Imagine you're defending a castle with a bow and arrow! 🏰 There are spherical balloons floating at different heights along a wall, and you need to burst all of them using the minimum number of arrows.

Each balloon is represented by an interval [x_start, x_end] showing its horizontal span on the wall. When you shoot an arrow vertically at position x, it will burst all balloons whose intervals contain that point (where x_start ≤ x ≤ x_end).

Your mission: Find the minimum number of arrows needed to burst all balloons!

Example: If you have balloons at [[10,16], [2,8], [1,6], [7,12]], you can burst them all with just 2 arrows - one at position 6 (hits balloons [2,8] and [1,6]) and another at position 11 (hits balloons [10,16] and [7,12]).

Input & Output

example_1.py — Basic Case

$ Input: points = [[10,16],[2,8],[1,6],[7,12]]

› Output: 2

💡 Note: One way is to shoot arrows at x = 6 (bursting [2,8] and [1,6]) and x = 11 (bursting [10,16] and [7,12]). Two arrows are sufficient.

example_2.py — Non-overlapping

$ Input: points = [[1,2],[3,4],[5,6],[7,8]]

› Output: 4

💡 Note: Since none of the balloons overlap, we need one arrow for each balloon. Four arrows are required.

example_3.py — All Overlapping

$ Input: points = [[1,2],[2,3],[3,4],[4,5]]

› Output: 2

💡 Note: We can shoot at x = 2 (hits [1,2] and [2,3]) and x = 4 (hits [3,4] and [4,5]). Two arrows are needed.

Constraints

1 ≤ points.length ≤ 10⁵
points[i].length == 2
-2³¹ ≤ x_start < x_end ≤ 2³¹ - 1
All balloon coordinates are valid integers

Visualization

Tap to expand

Sort by end points: [1,6], [2,8], [7,12], [10,16]2. First arrow at x=6: Hits [1,6] and [2,8] (both end ≥ 6)3. Check [7,12]: Starts at 7 > 6, so need new arrow4. Second arrow at x=12: Hits [7,12] and [10,16]Result: 2 arrows (optimal!)

Understanding the Visualization

Sort by End Points

Arrange balloons by when they end - this helps us find the optimal shooting positions

Shoot at First End

Place the first arrow at the end point of the first balloon - this maximizes coverage

Check Coverage

For each subsequent balloon, check if our current arrow can still reach it

New Arrow When Needed

Only when the current arrow can't reach a balloon do we need to shoot a new one

Key Takeaway

🎯 Key Insight: Always shoot at the earliest end point of overlapping balloons - this guarantees maximum coverage while using the minimum number of arrows!

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 29 f Meta 24

The optimal solution uses a greedy approach: sort balloons by their end points, then place arrows at the earliest end position of each group of overlapping balloons. This strategy guarantees the minimum number of arrows needed while ensuring all balloons are burst.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Sorting Approach (Optimal)	O(n log n)	O(1)	Sort by end points and greedily place arrows at earliest end positions
Brute Force (Try All Positions)	O(2^n)	O(n)	Try all possible arrow positions and find minimum combination

Greedy Sorting Approach (Optimal) — Algorithm Steps

Sort balloons by their end coordinates (x_end)
Initialize arrow count to 0 and current arrow position to negative infinity
For each balloon, check if current arrow can burst it
If not, we need a new arrow - place it at this balloon's end point
Increment arrow count and continue
Return total arrow count

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort by End Points

Arrange balloons by their ending positions: [1,6], [2,8], [7,12], [10,16]

First Arrow

Place arrow at position 6 (end of first balloon) - hits [1,6] and [2,8]

Check Next Balloon

Balloon [7,12] starts at 7, but our arrow is at 6 - need new arrow

Second Arrow

Place arrow at position 12 - hits [7,12] and [10,16]

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int compare(const void *a, const void *b) {
    int *arr1 = *(int**)a;
    int *arr2 = *(int**)b;
    return arr1[1] - arr2[1]; // Sort by end points
}

int findMinArrowShots(int** points, int pointsSize, int* pointsColSize) {
    if (pointsSize == 0) return 0;
    
    // Sort by end points
    qsort(points, pointsSize, sizeof(int*), compare);
    
    int arrows = 1;
    int arrowPos = points[0][1]; // Place first arrow at first balloon's end
    
    for (int i = 1; i < pointsSize; i++) {
        int start = points[i][0];
        int end = points[i][1];
        
        // If current arrow can't reach this balloon
        if (arrowPos < start) {
            arrows++;
            arrowPos = end; // Place new arrow at this balloon's end
        }
    }
    
    return arrows;
}

int main() {
    int data[][2] = {{10,16},{2,8},{1,6},{7,12}};
    int* points[4];
    int colSizes[4] = {2,2,2,2};
    
    for (int i = 0; i < 4; i++) {
        points[i] = data[i];
    }
    
    printf("%d\n", findMinArrowShots(points, 4, colSizes));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting the balloons by end points

⚡ Linearithmic

Space Complexity

O(1)

Only uses a few variables to track current state, sorting is in-place

✓ Linear Space

67.3K Views

Medium-High Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Greedy Sorting Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler