Minimum Number of Arrows to Burst Balloons - Problem

You are given points where points[i] = [x_start, x_end] represents balloons whose horizontal diameter stretches between x_start and x_end. You do not know the exact y-coordinates of the balloons.

Arrows can be shot up directly vertically (in the positive y-direction) from different points along the x-axis. A balloon with x_start and x_end is burst by an arrow shot at x if x_start <= x <= x_end. There is no limit to the number of arrows that can be shot. A shot arrow keeps traveling up infinitely, bursting any balloons in its path.

Given the array points, return the minimum number of arrows that must be shot to burst all balloons.

Input & Output

Example 1 — Basic Overlapping Case

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

› Output: 2

💡 Note: After sorting by end position: [[1,6],[2,8],[7,12],[10,16]]. First arrow at position 6 bursts [1,6] and [2,8]. Second arrow at position 12 bursts [7,12] and [10,16].

Example 2 — All Overlapping

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

› Output: 4

💡 Note: No balloons overlap, so we need one arrow for each balloon: 4 arrows total.

Example 3 — Single Balloon

$ Input: points = [[1,2]]

› Output: 1

💡 Note: Only one balloon, so we need exactly one arrow to burst it.

Constraints

1 ≤ points.length ≤ 10⁵
points[i].length == 2
-2³¹ ≤ x_start < x_end ≤ 2³¹ - 1

Visualization

Tap to expand

Asked in

M Microsoft 25 a Amazon 20 G Google 15

The key insight is to use a greedy approach: sort balloons by their end positions, then shoot arrows at the earliest possible position that covers the maximum number of overlapping balloons. Best approach uses greedy with sorting. Time: O(n log n), Space: O(1)

Common Approaches

✓ Brute Force - One Arrow Per Balloon

⏱️ Time: O(1) Space: O(1)

The naive approach would be to shoot one arrow for each balloon individually, completely ignoring any potential overlaps that could save arrows.

Greedy with Sorting

⏱️ Time: O(n log n) Space: O(1)

Sort balloons by their end positions, then greedily shoot arrows. For each group of overlapping balloons, shoot at the rightmost position of the first balloon in the group.

Brute Force - One Arrow Per Balloon — Algorithm Steps

Count the total number of balloons
Return that count as the number of arrows needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Balloons

Simply count total balloons

Return Count

Return balloon count as arrow count

Result

Inefficient but works

Code -

solution.c — C

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

static int points[100000][2];

int compareByEnd(const void *a, const void *b) {
    int *arr1 = (int*)a;
    int *arr2 = (int*)b;
    return arr1[1] - arr2[1];
}

int solution(int n) {
    if (n == 0) {
        return 0;
    }
    
    // Sort balloons by their end points
    qsort(points, n, sizeof(points[0]), compareByEnd);
    
    int arrows = 1;
    int arrow_pos = points[0][1];  // Place first arrow at the end of first balloon
    
    for (int i = 1; i < n; i++) {
        // If current balloon cannot be burst by the last arrow
        if (points[i][0] > arrow_pos) {
            arrows++;
            arrow_pos = points[i][1];  // Place new arrow at end of current balloon
        }
    }
    
    return arrows;
}

int main() {
    char line[1000000];
    fgets(line, sizeof(line), stdin);
    
    int n = 0;
    
    if (strstr(line, "[]") != NULL) {
        printf("0\n");
        return 0;
    }
    
    // Parse the input - look for pairs of numbers in brackets
    char *ptr = line;
    while (*ptr) {
        // Find opening bracket of inner array
        if (*ptr == '[') {
            // Check if this is an inner bracket (not the outer one)
            char *next = ptr + 1;
            while (*next == ' ') next++;
            
            // If next character after spaces is a digit or negative sign, this is an inner bracket
            if (*next == '-' || (*next >= '0' && *next <= '9')) {
                ptr = next;
                
                // Parse first number (start)
                char *endptr;
                long start = strtol(ptr, &endptr, 10);
                ptr = endptr;
                
                // Skip comma and whitespace
                while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
                
                // Parse second number (end)
                long end = strtol(ptr, &endptr, 10);
                ptr = endptr;
                
                points[n][0] = (int)start;
                points[n][1] = (int)end;
                n++;
                
                // Skip to closing bracket
                while (*ptr && *ptr != ']') ptr++;
                if (*ptr == ']') ptr++;
            } else {
                ptr++;
            }
        } else {
            ptr++;
        }
    }
    
    printf("%d\n", solution(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Just counting the balloons

⚡ Linearithmic

Space Complexity

O(1)

Only using a counter variable

✓ Linear Space

125.0K Views

Medium Frequency

~15 min Avg. Time

2.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

Minimum Number of Arrows to Burst Balloons - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - One Arrow Per Balloon — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler