Detonate the Maximum Bombs - Practice Coding Problems

Detonate the Maximum Bombs - Problem

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

The Chain Reaction Challenge!

Imagine you're a demolitions expert working on a controlled explosion site. You have multiple bombs placed at different locations, each with its own blast radius. Here's the exciting part: when you detonate one bomb, it can trigger a chain reaction!

How it works:
• Each bomb is located at coordinates (x, y) with a circular blast radius r
• When a bomb explodes, it detonates ALL bombs within its blast radius
• Those newly detonated bombs will also explode, potentially triggering even more bombs
• This creates a cascading chain reaction!

Your Mission: Choose the optimal starting bomb to maximize the total number of bombs that explode in the chain reaction. You can only manually detonate one bomb initially - the rest must be triggered by the chain reaction.

Input: A 2D array where bombs[i] = [xi, yi, ri] represents the x-coordinate, y-coordinate, and blast radius of the i-th bomb.

Output: The maximum number of bombs that can be detonated by choosing the optimal starting bomb.

Input & Output

example_1.py — Basic Chain Reaction

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

› Output: 2

💡 Note: The optimal choice is to detonate bomb 0. Bomb 0 detonates bombs 1, which forms a chain reaction that detonates bomb 1. So 2 bombs are detonated.

example_2.py — Complex Chain

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

› Output: 1

💡 Note: Detonating either bomb will only destroy 1 bomb (itself) because they are too far apart to trigger each other.

example_3.py — Maximum Chain Reaction

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

› Output: 5

💡 Note: Starting from bomb 0 creates a chain reaction that eventually detonates all bombs: 0→1, 0→2→3→4. Total: 5 bombs.

Constraints

1 ≤ bombs.length ≤ 100
bombs[i].length == 3
1 ≤ x_i, y_i, r_i ≤ 10⁵
Important: Use long long to avoid integer overflow when calculating distances

Visualization

Tap to expand

Understanding the Visualization

Map Blast Zones

Each bomb has a circular blast radius - identify which bombs are within range of others

Build Connection Graph

Create directed edges from each bomb to all bombs it can detonate

Test Each Starting Point

For each bomb, simulate the complete chain reaction using graph traversal

Find Maximum Impact

Return the starting bomb that produces the largest chain reaction

Key Takeaway

🎯 Key Insight: Convert the geometric bomb detonation problem into a graph connectivity problem. Pre-compute which bombs can trigger others, then use DFS/BFS to find the maximum reachable bombs from any starting point.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal approach treats this as a graph traversal problem. First, build an adjacency list showing which bombs can detonate others based on distance calculations. Then, for each bomb as a potential starting point, perform DFS/BFS to count the total reachable bombs through chain reactions. The key insight is transforming the geometric problem into a graph connectivity problem with O(n²) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Graph-Based Approach (Optimal)	O(n²)	O(n²)	Build adjacency graph first, then use DFS/BFS from each starting point

Graph-Based Approach (Optimal) — Algorithm Steps

Build adjacency graph: for each bomb i, find all bombs j that can be detonated by i
Store relationships in adjacency list or matrix
For each bomb as starting point:
Perform DFS/BFS traversal following the detonation graph
Use visited set to avoid counting bombs multiple times
Count total reachable bombs from this starting point
Return the maximum count across all starting points

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list showing which bombs can trigger others

DFS Traversal

From each starting bomb, follow all possible detonation paths

Count Reachable

Track visited bombs to count total detonations

Find Maximum

Return the starting point with maximum chain reaction

Code -

solution.c — C

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

typedef struct Node {
    int val;
    struct Node* next;
} Node;

typedef struct {
    Node** adj;
    int size;
} Graph;

Graph* createGraph(int n) {
    Graph* g = (Graph*)malloc(sizeof(Graph));
    g->adj = (Node**)calloc(n, sizeof(Node*));
    g->size = n;
    return g;
}

void addEdge(Graph* g, int from, int to) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->val = to;
    newNode->next = g->adj[from];
    g->adj[from] = newNode;
}

int dfs(Graph* g, int start, bool* visited) {
    visited[start] = true;
    int count = 1;
    
    Node* curr = g->adj[start];
    while (curr) {
        if (!visited[curr->val]) {
            count += dfs(g, curr->val, visited);
        }
        curr = curr->next;
    }
    
    return count;
}

int maximumDetonation(int** bombs, int bombsSize, int* bombsColSize) {
    Graph* graph = createGraph(bombsSize);
    
    // Build adjacency graph
    for (int i = 0; i < bombsSize; i++) {
        long long x1 = bombs[i][0], y1 = bombs[i][1], r1 = bombs[i][2];
        for (int j = 0; j < bombsSize; j++) {
            if (i != j) {
                long long x2 = bombs[j][0], y2 = bombs[j][1];
                long long distSq = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
                if (distSq <= r1 * r1) {
                    addEdge(graph, i, j);
                }
            }
        }
    }
    
    int maxBombs = 0;
    for (int i = 0; i < bombsSize; i++) {
        bool* visited = (bool*)calloc(bombsSize, sizeof(bool));
        int count = dfs(graph, i, visited);
        if (count > maxBombs) {
            maxBombs = count;
        }
        free(visited);
    }
    
    return maxBombs;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n²) to build the adjacency graph + O(n²) for DFS/BFS from each starting point in worst case

⚠ Quadratic Growth

Space Complexity

O(n²)

Adjacency list can have O(n²) edges in worst case when every bomb can detonate every other bomb

⚠ Quadratic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

892 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

Graph-Based Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler