LeetCode每日一题 1921. 消灭怪物的最大数量

题目描述

你正在玩一款电子游戏，在游戏中你需要保护城市免受怪物侵袭。给你一个 下标从 0 开始 且长度为 n 的整数数组 dist ，其中 dist[i] 是第 i 个怪物与城市的 初始距离（单位：米）。

怪物以 恒定 的速度走向城市。给你一个长度为 n 的整数数组 speed 表示每个怪物的速度，其中 speed[i] 是第 i 个怪物的速度（单位：米/分）。

怪物从 第 0 分钟 时开始移动。你有一把武器，并可以 选择 在每一分钟的开始时使用，包括第 0 分钟。但是你无法在一分钟的中间使用武器。这种武器威力惊人，一次可以消灭任一还活着的怪物。

一旦任一怪物到达城市，你就输掉了这场游戏。如果某个怪物 恰 在某一分钟开始时到达城市，这会被视为 输掉 游戏，在你可以使用武器之前，游戏就会结束。

返回在你输掉游戏前可以消灭的怪物的 最大 数量。如果你可以在所有怪物到达城市前将它们全部消灭，返回 n 。

方法一

这个问题可以通过以下步骤来解决：

1. 创建一个空的 time 向量来存储每个怪物到达城市所需的时间。

2. 使用 for 循环遍历每个怪物，并计算每个怪物到达城市所需的时间，然后将这个时间添加到 time 向量中。这里使用了 static_cast(dist[i]) / speed[i] 来确保时间被存储为 double 类型。

3. 对 time 向量进行排序，以便最早到达城市的怪物排在前面。

4. 使用一个 for 循环遍历 time 向量中的元素，查找在第 i 分钟时，time[i] 的值是否小于等于 i。如果找到第一个满足条件的怪物，返回 i，表示在第 i 分钟结束游戏。

5. 如果没有找到满足条件的情况，说明你可以在所有怪物到达城市前将它们全部消灭，返回 n，表示所有怪物都可以被消灭。

class Solution {
public:
    int eliminateMaximum(vector<int>& dist, vector<int>& speed) {
        int n = dist.size();
        vector<double> time(n);

        // 计算每个怪物到达城市所需的时间
        for (int i = 0; i < n; i++) {
            time[i] = static_cast<double>(dist[i]) / speed[i];
        }

        // 按到达时间升序排序
        sort(time.begin(), time.end());

        // 遍历时间数组，查找最多可以消灭的怪物数量
        for (int i = 0; i < n; i++) {
            if (time[i] <= i) {
                // 在怪物到达城市之前使用武器
                return i;
            }
        }

        // 所有怪物都能被消灭
        return n;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

方法二

方法一里time存储了double类型的数据，在比较时，由于我方的攻击时间为整数，因此也可以将怪物到达时间向上取整，即time.push_back((dist[i] - 1) / speed[i] + 1)可以达到避免浮点数误差的效果。

class Solution {
public:
    int eliminateMaximum(vector<int>& dist, vector<int>& speed) {
        vector<int> time;
        int n = dist.size();

        for (int i = 0; i < n; i++) {
            time.push_back((dist[i] - 1) / speed[i] + 1);
        }

        sort(time.begin(), time.end());

        for (int i = 0; i < n; i++) {
            if (time[i] <= i) {
                return i;
            }
        }
        
        return n;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

方法三

由于以上方法用到了sort进行排序，所以时间复杂度为O(nlogn)，其中n是怪物的数量。此题也可以在O(n)的时间复杂度内解决。只需遍历两次数组并新增一个数组和变量。

• count 数组：用于记录每个时间点（从1分钟到n分钟）有多少怪物到达。数组的索引表示时间点，而数组的值表示在该时间点到达的怪物数量。我们在遍历怪物的到达时间时，将根据每只怪物的到达时间增加相应时间点的计数。

• eliminated 变量：用于记录已经被消灭的怪物数量。在遍历时间点并检查怪物到达时，我们会检查 eliminated 是否大于等于当前时间点。如果是，说明在当前时间点之前已经消灭了足够的怪物，游戏结束，我们返回当前时间点；否则，我们会将当前时间点到达的怪物数量加到 eliminated 上，继续检查下一个时间点。

通过维护这两个变量，我们可以在遍历时间点的过程中实时更新已经消灭的怪物数量，并根据游戏规则判断是否游戏结束。这使得我们能够高效地找到最大可消灭怪物的数量，并返回答案。

class Solution {
public:
    int eliminateMaximum(vector<int>& dist, vector<int>& speed) {
        int n = dist.size();
        vector<int> time(n);

        // 计算每个怪物到达城市所需的时间（使用整数除法）
        for (int i = 0; i < n; i++) {
            time[i] = (dist[i] - 1) / speed[i] + 1;
        }

        vector<int> count(n + 1, 0); // 用来记录每个时间点有多少怪物到达
        for (int i = 0; i < n; i++) {
            if (time[i] <= n) {
                count[time[i]]++;
            }
        }

        int eliminated = 0;
        for (int i = 1; i <= n; i++) {
            if (eliminated >= i) {
                return i - 1;
            }
            eliminated += count[i];
        }

        return n;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29