Detonate the Maximum Bombs

Detonate the Maximum Bombs - Problem

Array Math Depth-First Search Breadth-First Search Graph Geometry Medium

You are given a list of bombs. The range of a bomb is defined as the area where its effect can be felt. This area is in the shape of a circle with the center as the location of the bomb.

The bombs are represented by a 0-indexed 2D integer array bombs where bombs[i] = [xi, yi, ri]. xi and yi denote the X-coordinate and Y-coordinate of the location of the ith bomb, whereas ri denotes the radius of its range.

You may choose to detonate a single bomb. When a bomb is detonated, it will detonate all bombs that lie in its range. These bombs will further detonate the bombs that lie in their ranges.

Given the list of bombs, return the maximum number of bombs that can be detonated if you are allowed to detonate only one bomb.

Input & Output

Example 1 — Chain Reaction

$ Input: bombs = [[2,1,3],[6,1,4]]

› Output: 2

💡 Note: Starting with bomb 0 at (2,1) with radius 3: it cannot reach bomb 1 at (6,1) since distance = 4 > radius 3. Starting with bomb 1 at (6,1) with radius 4: it can reach bomb 0 at (2,1) since distance = 4 ≤ radius 4. So maximum is 2 bombs when starting with bomb 1.

Example 2 — No Chain Reaction

$ Input: bombs = [[1,1,5],[10,10,5]]

› Output: 1

💡 Note: The two bombs are too far apart. Distance between (1,1) and (10,10) is √((10-1)² + (10-1)²) = √162 ≈ 12.7, which is greater than either bomb's radius of 5. No chain reaction possible, so maximum is 1.

Example 3 — Multiple Chain Reactions

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

› Output: 5

💡 Note: Starting from the right bomb and working backwards, we can create a chain reaction that detonates all 5 bombs due to their overlapping ranges.

Constraints

1 ≤ bombs.length ≤ 100
bombs[i].length == 3
1 ≤ x_i, y_i, r_i ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 8 a Amazon 5 f Meta 3 Apple 2

The key insight is to model this as a graph problem where bombs can detonate other bombs within their radius. Build a directed graph and use DFS/BFS to find the maximum reachable bombs from any starting point. Best approach is DFS with graph construction: Time O(n²), Space O(n²).

Common Approaches

✓ Hash Map

⏱️ Time: N/A Space: N/A

BFS with Queue

⏱️ Time: O(n³) Space: O(n)

For each potential starting bomb, use BFS with a queue to simulate the chain reaction. This explores bombs level by level, first detonating immediate neighbors, then their neighbors, ensuring we count all reachable bombs.

Brute Force Simulation

⏱️ Time: O(n³) Space: O(n)

For each bomb, simulate the detonation process by repeatedly checking all undetonated bombs to see if they're within range of any already detonated bomb. Continue until no more bombs can be detonated.

DFS with Graph Construction

⏱️ Time: O(n² + n²) Space: O(n²)

First construct a directed graph where edge i→j exists if bomb i can detonate bomb j. Then perform DFS from each bomb to count reachable bombs, avoiding redundant distance calculations.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_BOMBS 100

static int bombs[MAX_BOMBS][3]; // [x, y, radius]
static int n;
static int visited[MAX_BOMBS];

int canDetonate(int i, int j) {
    long long dx = bombs[i][0] - bombs[j][0];
    long long dy = bombs[i][1] - bombs[j][1];
    long long distSq = dx * dx + dy * dy;
    long long radiusSq = (long long)bombs[i][2] * bombs[i][2];
    return distSq <= radiusSq;
}

int dfs(int bomb) {
    visited[bomb] = 1;
    int count = 1;
    
    for (int i = 0; i < n; i++) {
        if (!visited[i] && canDetonate(bomb, i)) {
            count += dfs(i);
        }
    }
    
    return count;
}

int maxBombsDetonated() {
    int maxCount = 0;
    
    for (int i = 0; i < n; i++) {
        // Reset visited array
        for (int j = 0; j < n; j++) {
            visited[j] = 0;
        }
        
        int count = dfs(i);
        if (count > maxCount) {
            maxCount = count;
        }
    }
    
    return maxCount;
}

int parseInput(const char* input) {
    const char* ptr = input;
    int bombCount = 0;
    
    // Skip whitespace and find first '['
    while (*ptr && *ptr != '[') ptr++;
    if (!*ptr) return 0;
    ptr++; // Skip '['
    
    // Skip whitespace
    while (*ptr && isspace(*ptr)) ptr++;
    
    // Check for empty array
    if (*ptr == ']') return 0;
    
    while (*ptr && bombCount < MAX_BOMBS) {
        // Find start of bomb array
        while (*ptr && *ptr != '[') ptr++;
        if (!*ptr) break;
        ptr++; // Skip '['
        
        // Parse x coordinate
        while (*ptr && isspace(*ptr)) ptr++;
        int x = 0;
        int negative = 0;
        if (*ptr == '-') {
            negative = 1;
            ptr++;
        }
        while (*ptr && isdigit(*ptr)) {
            x = x * 10 + (*ptr - '0');
            ptr++;
        }
        if (negative) x = -x;
        bombs[bombCount][0] = x;
        
        // Skip comma
        while (*ptr && *ptr != ',') ptr++;
        if (*ptr == ',') ptr++;
        
        // Parse y coordinate
        while (*ptr && isspace(*ptr)) ptr++;
        int y = 0;
        negative = 0;
        if (*ptr == '-') {
            negative = 1;
            ptr++;
        }
        while (*ptr && isdigit(*ptr)) {
            y = y * 10 + (*ptr - '0');
            ptr++;
        }
        if (negative) y = -y;
        bombs[bombCount][1] = y;
        
        // Skip comma
        while (*ptr && *ptr != ',') ptr++;
        if (*ptr == ',') ptr++;
        
        // Parse radius
        while (*ptr && isspace(*ptr)) ptr++;
        int r = 0;
        while (*ptr && isdigit(*ptr)) {
            r = r * 10 + (*ptr - '0');
            ptr++;
        }
        bombs[bombCount][2] = r;
        
        // Skip to end of this bomb array
        while (*ptr && *ptr != ']') ptr++;
        if (*ptr == ']') ptr++;
        
        bombCount++;
        
        // Skip comma and whitespace
        while (*ptr && (*ptr == ',' || isspace(*ptr))) ptr++;
        
        // Check if we've reached the end
        if (*ptr == ']') break;
    }
    
    return bombCount;
}

int main() {
    char input[10000];
    if (fgets(input, sizeof(input), stdin)) {
        n = parseInput(input);
        int result = maxBombsDetonated();
        printf("%d\n", result);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

32.2K Views

Medium Frequency

~25 min Avg. Time

847 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