Leetcode力扣秋招刷题路-0853

最新推荐文章于 2024-08-26 22:22:22 发布

fffffffyy

最新推荐文章于 2024-08-26 22:22:22 发布

阅读量747

点赞数

分类专栏： Leetcode 文章标签： leetcode 算法

本文链接：https://blog.csdn.net/qq_43022896/article/details/130444908

版权

Leetcode 专栏收录该内容

110 篇文章 1 订阅

订阅专栏

文章介绍了如何解决一个关于车队的算法问题，给定车辆的位置和速度，计算到达目的地时的车队数量。解决方案包括创建一个Data类，存储位置和速度，对数据排序，然后判断车辆能否追上前车形成车队。关键在于判断两车能否在目标位置之前相遇。

摘要由CSDN通过智能技术生成

从0开始的秋招刷题路，记录下所刷每道题的题解，帮助自己回顾总结

853. 车队

在一条单行道上，有 n 辆车开往同一目的地。目的地是几英里以外的 target 。

给定两个整数数组 position 和 speed ，长度都是 n ，其中 position[i] 是第 i 辆车的位置， speed[i] 是第 i 辆车的速度(单位是英里/小时)。

一辆车永远不会超过前面的另一辆车，但它可以追上去，并与前车以相同的速度紧接着行驶。此时，我们会忽略这两辆车之间的距离，也就是说，它们被假定处于相同的位置。

车队是一些由行驶在相同位置、具有相同速度的车组成的非空集合。注意，一辆车也可以是一个车队。

即便一辆车在目的地才赶上了一个车队，它们仍然会被视作是同一个车队。

返回到达目的地的车队数量。

示例 1：
输入：target = 12, position = [10,8,0,5,3], speed = [2,4,1,1,3]
输出：3
解释：
从 10 和 8 开始的车会组成一个车队，它们在 12 处相遇。
从 0 处开始的车无法追上其它车，所以它自己就是一个车队。
从 5 和 3 开始的车会组成一个车队，它们在 6 处相遇。
请注意，在到达目的地之前没有其它车会遇到这些车队，所以答案是 3。

示例 2:
输入: target = 10, position = [3], speed = [3]
输出: 1
解释: 只有一辆车，因此只有一个车队。

示例 3:
输入: target = 100, position = [0,2,4], speed = [4,2,1]
输出: 1
解释:
以0(速度4)和2(速度2)出发的车辆组成车队，在4点相遇。舰队以2的速度前进。
然后，车队(速度2)和以4(速度1)出发的汽车组成一个车队，在6点相遇。舰队以1的速度前进，直到到达目标。

提示：
n == position.length == speed.length
1 <= n <= $10^5$
0 < target <= $10^6$
0 <= position[i] < target
position 中每个值都不同
0 < speed[i] <= $10^6$

思路

新建一个类Data，包含pos和speed两个属性，然后新建这个类对象数组datas；
对datas根据pos从小到大排序；
然后从大到小遍历datas数组，不断的判断当前车是否能够与行驶在前面的车队相遇，若能相遇，则将其并到前面车队中，否则当前车另起一个车队。
如何判断是否能够相遇

位置小的车要超过行驶在前面位置大的车，必须速度大一点，然后判断相遇的地点是否在终点target之前，若在target之前，说明能够相遇。
注意事项题目说了一辆车永远不会超过前面的另一辆车，但它可以追上去，并与前车以相同的速度紧接着行驶，因此，在从位置大的往位置小遍历过程中，我们只需要判断是否能追的上最近的车队即可。因为，假设当前车前面有[车队A，车队B]，既然是两个车队，说明车队A追不上车队B，因此假设当前车追不上车队A，那么他一定追不上车队B。

public class Problem853 {

    class Data {
        int position;
        int speed;
        Data(int position, int speed) {
            this.position = position;
            this.speed = speed;
        }
    }

    private boolean isMeet(Data data1, Data data2, int target) {
        if (data1.speed <= data2.speed) {
            return false;
        }

        double t = (data2.position - data1.position) * 1.0 / (data1.speed - data2.speed);
        return data1.speed * t + data1.position <= target;
    }

    public int carFleet(int target, int[] position, int[] speed) {
        int len = position.length;
        if (len == 0) {
            return 0;
        }
        Data[] datas = new Data[len];

        for (int i = 0; i < len; i++) {
            datas[i] = new Data(position[i], speed[i]);
        }

        Arrays.sort(datas, Comparator.comparingInt(o -> o.position));

        int ans = 1;
        Data frontCar = datas[len - 1];
        for (int i = len - 2; i >= 0; i--) {
            if (!isMeet(datas[i], frontCar, target)) {
                ans++;
                frontCar = datas[i];
            }
        }

        return ans;
    }

}

复杂度分析时间复杂度：O(nlogn)。因为存在排序。空间复杂度：O(n)。