Destroying Asteroids

Destroying Asteroids - Problem

You're given a planet with an initial mass and an array of asteroids where each asteroid has its own mass. The planet can collide with asteroids in any order you choose.

Collision Rules:

If planet_mass ≥ asteroid_mass: The asteroid is destroyed and the planet absorbs the asteroid's mass
If planet_mass < asteroid_mass: The planet is destroyed and the game ends

Your goal is to determine if there exists an order of collisions such that all asteroids can be destroyed.

Example: Planet mass = 10, asteroids = [3, 9, 19, 5, 21]
One winning strategy: destroy asteroids in order [3, 5, 9, 19, 21]
Mass progression: 10 → 13 → 18 → 27 → 46 → 67

Input & Output

example_1.py — Basic Success Case

$ Input: mass = 10, asteroids = [3, 9, 19, 5, 21]

› Output: true

💡 Note: Sort to [3, 5, 9, 19, 21]. Planet can destroy all: 10→13→18→27→46→67. The greedy strategy works perfectly here.

example_2.py — Impossible Case

$ Input: mass = 5, asteroids = [4, 9, 23, 4]

› Output: false

💡 Note: Sort to [4, 4, 9, 23]. Planet progresses: 5→9→13→22, but 22 < 23. Cannot destroy the largest asteroid.

example_3.py — Edge Case: Single Large Asteroid

$ Input: mass = 1, asteroids = [2]

› Output: false

💡 Note: Planet mass 1 is less than asteroid mass 2. Planet gets destroyed immediately.

Constraints

1 ≤ mass ≤ 10⁵
1 ≤ asteroids.length ≤ 10⁵
1 ≤ asteroids[i] ≤ 10⁵
Important: Planet mass can grow beyond initial constraints after absorbing asteroids

Visualization

Tap to expand

Understanding the Visualization

Sort enemies by strength

Arrange asteroids from weakest (smallest mass) to strongest (largest mass)

Fight in optimal order

Always challenge the weakest opponent you can currently defeat

Grow stronger with victories

Each victory adds the defeated asteroid's mass to your planet

Check if all can be defeated

If you can defeat every asteroid in this order, return true

Key Takeaway

🎯 Key Insight: The greedy approach works because destroying smaller asteroids first maximizes our future potential. This is a classic example of how local optimal choices lead to a globally optimal solution.

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal solution uses a greedy approach: sort the asteroids in ascending order and destroy them from smallest to largest. This maximizes the planet's mass growth potential, giving it the best chance to handle larger asteroids later. Time complexity is O(n log n) due to sorting, with O(1) extra space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Permutations)	O(n! × n)	O(n)	Generate all possible orders of destroying asteroids and check if any works
Greedy Approach (Optimal)	O(n log n)	O(1)	Sort asteroids and destroy them in ascending order of mass

Brute Force (Try All Permutations) — Algorithm Steps

Generate all n! permutations of the asteroids array
For each permutation, simulate the collision process
Track the planet's mass as it collides with each asteroid in order
If any permutation allows destroying all asteroids, return true
If no permutation works, return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate all permutations

Create all n! possible orders of destroying asteroids

Test each permutation

For each order, simulate the collision process

Find valid path

Return true if any permutation allows destroying all asteroids

Code -

solution.c — C

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

bool canDestroy(int* order, int size, long long initialMass) {
    long long currentMass = initialMass;
    for (int i = 0; i < size; i++) {
        if (currentMass >= order[i]) {
            currentMass += order[i];
        } else {
            return false;
        }
    }
    return true;
}

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

bool permute(int* arr, int start, int end, int mass) {
    if (start == end) {
        return canDestroy(arr, end + 1, mass);
    }
    
    for (int i = start; i <= end; i++) {
        swap(&arr[start], &arr[i]);
        if (permute(arr, start + 1, end, mass)) {
            return true;
        }
        swap(&arr[start], &arr[i]); // backtrack
    }
    return false;
}

bool asteroidDestruction(int mass, int* asteroids, int size) {
    return permute(asteroids, 0, size - 1, mass);
}

int main() {
    int mass = 10;
    int asteroids[] = {3, 9, 19, 5, 21};
    int size = 5;
    printf("%s\n", asteroidDestruction(mass, asteroids, size) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! permutations, each taking O(n) time to simulate

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack and current permutation

⚡ Linearithmic Space

27.8K Views

Medium Frequency

~15 min Avg. Time

856 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