LeetCode 2126. 摧毁小行星

2126. 摧毁小行星

给你一个整数 mass ，它表示一颗行星的初始质量。再给你一个整数数组 asteroids ，其中 asteroids[i] 是第 i 颗小行星的质量。

你可以按 任意顺序 重新安排小行星的顺序，然后让行星跟它们发生碰撞。如果行星碰撞时的质量 大于等于 小行星的质量，那么小行星被 摧毁 ，并且行星会 获得 这颗小行星的质量。否则，行星将被摧毁。

如果所有小行星 都 能被摧毁，请返回 true ，否则返回 false 。

示例 1：

输入：mass = 10, asteroids = [3,9,19,5,21]
输出：true
解释：一种安排小行星的方式为 [9,19,5,3,21] ：
- 行星与质量为 9 的小行星碰撞。新的行星质量为：10 + 9 = 19
- 行星与质量为 19 的小行星碰撞。新的行星质量为：19 + 19 = 38
- 行星与质量为 5 的小行星碰撞。新的行星质量为：38 + 5 = 43
- 行星与质量为 3 的小行星碰撞。新的行星质量为：43 + 3 = 46
- 行星与质量为 21 的小行星碰撞。新的行星质量为：46 + 21 = 67
所有小行星都被摧毁。

示例 2：

输入：mass = 5, asteroids = [4,9,23,4]
输出：false
解释：
行星无论如何没法获得足够质量去摧毁质量为 23 的小行星。
行星把别的小行星摧毁后，质量为 5 + 4 + 9 + 4 = 22 。
它比 23 小，所以无法摧毁最后一颗小行星。

提示：

• 1 <= mass <= 10^5
• 1 <= asteroids.length <= 10^5
• 1 <= asteroids[i] <= 10^5

提示 1

Choosing the asteroid to collide with can be done greedily.

---

提示 2

If an asteroid will destroy the planet, then every bigger asteroid will also destroy the planet.

---

提示 3

You only need to check the smallest asteroid at each collision. If it will destroy the planet, then every other asteroid will also destroy the planet.

---

提示 4

Sort the asteroids in non-decreasing order by mass, then greedily try to collide with the asteroids in that order.

解法1：贪心

提示 1

对于两个不同质量的小行星，优先摧毁质量较小的小行星可以摧毁更多的小行星。

提示 1 解释

我们假设质量较小的小行星质量为 m1，较大的为 m2。

对于优先摧毁质量较小的小行星的情况，摧毁第一颗的充要条件为：

mass ≥ m1,

（在摧毁第一颗的前提下）摧毁第二颗的充要条件是：

mass + m1 ≥ m2,

将上述条件结合，可以发现能够摧毁两颗的充要条件为：

mass≥max(m1, m2 − m1);
同理，对于优先摧毁质量较大小行星的情况，摧毁第一颗的充要条件为

mass ≥ m2 ,
能够摧毁两颗的充要条件为（注意到 m1 < m2）：

mass ≥ max(m2，m1 ​− m2) = m 2 ​ .

由于 m1 ​< m2 ​ ，显然有：

m2 ​ > max(m1, m2 ​− m1 ​). 
因此，无论是摧毁第一颗还是全部摧毁，「优先摧毁质量较小的小行星」这一方案对行星质量的要求都更低。这也意味着优先摧毁质量较小的小行星能够摧毁更多的小行星。

思路与算法

我们可以类似 提示 1 对所有行星的最优摧毁顺序建立全序关系，即质量从小到大。那么，我们对数组 asteroids 升序排序，并从左至右模拟并维护行星质量 mass，进而判断是否可以摧毁全部小行星。

具体地，遍历到下标 i 时，我们首先比较当前小行星质量 asteroids[i] 与 mass 的关系，此时有两种情况：

• mass≥asteroids[i]，此时行星可以摧毁该小行星，摧毁后行星质量变为 mass+asteroids[i]；
• mass<asteroids[i]，此时行星无法摧毁该小行星，我们返回 false。

如果遍历完成，则说明所有小行星均可摧毁，此时我们返回 true。

细节

所有小行星的质量总和可能超过 32 位有符号整数的上界，因此对于 Java 等语言，我们可以考虑使用 64 位整数来维护行星的质量。

Java版：

class Solution {
    public boolean asteroidsDestroyed(int mass, int[] asteroids) {
        Arrays.sort(asteroids);
        long m = (long) mass;
        for (int aster : asteroids) {
            if (m >= aster) {
                m += aster;
            } else {
                return false;
            }
        }
        return true;
    }
}

Python3版：

class Solution:
    def asteroidsDestroyed(self, mass: int, asteroids: List[int]) -> bool:
        asteroids.sort()
        for aster in asteroids:
            if mass >= aster:
                mass += aster
            else:
                return False
        return True

复杂度分析

• 时间复杂度：O(n)，其中 n 为数组 asteroids 的长度。对数组 asteroids 排序的时间复杂度为 O(nlogn)，判断是否可以摧毁全部小行星的时间复杂度为 O(n)。
• 空间复杂度：O(logn)，即为排序的栈空间开销。