Asteroid Collision

LeetCode 735 | Difficulty: Medium

Medium

Problem Description

We are given an array asteroids of integers representing asteroids in a row. The indices of the asteroid in the array represent their relative position in space.

For each asteroid, the absolute value represents its size, and the sign represents its direction (positive meaning right, negative meaning left). Each asteroid moves at the same speed.

Find out the state of the asteroids after all collisions. If two asteroids meet, the smaller one will explode. If both are the same size, both will explode. Two asteroids moving in the same direction will never meet.

Example 1:

Input: asteroids = [5,10,-5]
Output: [5,10]
Explanation: The 10 and -5 collide resulting in 10. The 5 and 10 never collide.

Example 2:

Input: asteroids = [8,-8]
Output: []
Explanation: The 8 and -8 collide exploding each other.

Example 3:

Input: asteroids = [10,2,-5]
Output: [10]
Explanation: The 2 and -5 collide resulting in -5. The 10 and -5 collide resulting in 10.

Example 4:

Input: asteroids = [3,5,-6,2,-1,4]​​​​​​​
Output: [-6,2,4]
Explanation: The asteroid -6 makes the asteroid 3 and 5 explode, and then continues going left. On the other side, the asteroid 2 makes the asteroid -1 explode and then continues going right, without reaching asteroid 4.

Constraints:

- `2 <= asteroids.length <= 10^4`

- `-1000 <= asteroids[i] <= 1000`

- `asteroids[i] != 0`

Topics: Array, Stack, Simulation

---

Approach

Stack

Use a stack (LIFO) to track elements that need future processing. Process elements when a "trigger" condition is met (e.g., finding a smaller/larger element). Monotonic stack maintains elements in sorted order for next greater/smaller element problems.

When to use

Matching brackets, next greater element, evaluating expressions, backtracking history.

---

Solutions

Solution 1: C# (Best: 255 ms)

Metric	Value
Runtime	255 ms
Memory	42.1 MB
Date	2022-01-10

Solution

public class Solution {
    public int[] AsteroidCollision(int[] asteroids) {
    Stack<int> s = new Stack<int>();
    foreach (var asteroid  in asteroids)
    {
        if (asteroid > 0)
        {
            s.Push(asteroid);
            continue;
        }
        while(s.Count > 0 && s.Peek() > 0 && s.Peek() < -asteroid)
        {
            s.Pop();
        }
        if(s.Count == 0 || s.Peek() < 0)
        s.Push(asteroid);
        else if(s.Peek() == -asteroid)
        {
            s.Pop();
        }       
    }
    return s.Reverse().ToArray();
    }
}

---

Complexity Analysis

Approach	Time	Space
Stack	$O(n)$	$O(n)$

---

Interview Tips

Key Points

• Discuss the brute force approach first, then optimize. Explain your thought process.
• Think about what triggers a pop: is it finding a match, or finding a smaller/larger element?
• LeetCode provides 1 hint(s) for this problem — try solving without them first.

💡 Hints

Hint 1: Say a row of asteroids is stable. What happens when a new asteroid is added on the right?