Destroying Asteroids

Destroying Asteroids - Problem

You are given an integer mass, which represents the original mass of a planet. You are further given an integer array asteroids, where asteroids[i] is the mass of the ith asteroid.

You can arrange for the planet to collide with the asteroids in any arbitrary order. If the mass of the planet is greater than or equal to the mass of the asteroid, the asteroid is destroyed and the planet gains the mass of the asteroid. Otherwise, the planet is destroyed.

Return true if all asteroids can be destroyed. Otherwise, return false.

Input & Output

Example 1 — Basic Success

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

› Output: true

💡 Note: Sort to [3,5,9,19,21]. Planet: 10→13→18→27→46→67. All asteroids destroyed successfully.

Example 2 — Impossible Case

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

› Output: false

💡 Note: Sort to [4,4,9,23]. Planet: 5→9→13→22. Cannot destroy asteroid 23 (mass 22 < 23).

Example 3 — Edge Case

$ Input: mass = 10, asteroids = []

› Output: true

💡 Note: No asteroids to destroy, so automatically return true.

Constraints

1 ≤ mass ≤ 10⁵
1 ≤ asteroids.length ≤ 10⁵
1 ≤ asteroids[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that we should always destroy the smallest asteroid we can handle first. This greedy approach maximizes our mass growth, giving us the best chance to handle larger asteroids later. Best approach is greedy sorting. Time: O(n log n), Space: O(1)

Common Approaches

✓ Optimized

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

Greedy - Sort Ascending

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

Sort asteroids in ascending order and attempt to destroy them from smallest to largest. This greedy approach maximizes our chances since we gain mass early to handle larger asteroids later.

Try All Permutations

⏱️ Time: O(n! × n) Space: O(n)

Generate every possible permutation of asteroids and simulate each collision sequence. If any permutation allows destroying all asteroids, return true.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int** solution(int** grid, int m, int n, int* returnSize, int** returnColumnSizes) {
    *returnSize = m;
    *returnColumnSizes = (int*)malloc(m * sizeof(int));
    
    // Precompute ones in each row
    int* rowOnes = (int*)calloc(m, sizeof(int));
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            rowOnes[i] += grid[i][j];
        }
    }
    
    // Precompute ones in each column
    int* colOnes = (int*)calloc(n, sizeof(int));
    for (int j = 0; j < n; j++) {
        for (int i = 0; i < m; i++) {
            colOnes[j] += grid[i][j];
        }
    }
    
    // Build result matrix
    int** diff = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        (*returnColumnSizes)[i] = n;
        diff[i] = (int*)malloc(n * sizeof(int));
        
        for (int j = 0; j < n; j++) {
            int onesRow = rowOnes[i];
            int zerosRow = n - onesRow;
            int onesCol = colOnes[j];
            int zerosCol = m - onesCol;
            diff[i][j] = onesRow + onesCol - zerosRow - zerosCol;
        }
    }
    
    free(rowOnes);
    free(colOnes);
    return diff;
}

int main() {
    int m, n;
    scanf("%d %d", &m, &n);
    
    int** grid = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        grid[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            scanf("%d", &grid[i][j]);
        }
    }
    
    int returnSize, *returnColumnSizes;
    int** result = solution(grid, m, n, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d", result[i][j]);
            if (j < returnColumnSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    // Free memory
    for (int i = 0; i < m; i++) {
        free(grid[i]);
        free(result[i]);
    }
    free(grid);
    free(result);
    free(returnColumnSizes);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.4K 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