LeetCode 853. Car Fleet

LeetCode 853. Car Fleet

传送门

题目分析

N cars are going to the same destination along a one lane road. The destination is target miles away.

Each car i has a constant speed speed[i] (in miles per hour), and initial position position[i] miles towards the target along the road.

A car can never pass another car ahead of it, but it can catch up to it, and drive bumper to bumper at the same speed.

The distance between these two cars is ignored - they are assumed to have the same position.

A car fleet is some non-empty set of cars driving at the same position and same speed. Note that a single car is also a car fleet.

If a car catches up to a car fleet right at the destination point, it will still be considered as one car fleet.

How many car fleets will arrive at the destination?

Example 1:

Input: target = 12, position = [10,8,0,5,3], speed = [2,4,1,1,3]
Output: 3
Explanation:
The cars starting at 10 and 8 become a fleet, meeting each other at 12.
The car starting at 0 doesn't catch up to any other car, so it is a fleet by itself.
The cars starting at 5 and 3 become a fleet, meeting each other at 6.
Note that no other cars meet these fleets before the destination, so the answer is 3.

Note:

1. 0 <= N <= 10 ^ 4
2. 0 < target <= 10 ^ 6
3. 0 < speed[i] <= 10 ^ 6
4. 0 <= position[i] < target
5. All initial positions are different.

说实话，这道题挺让我头疼的，题目意思有些迷迷糊糊，最终在百度翻译的帮助下还是顺利理解了题意，给你一个目的地，几辆车的初始位置和速度，判断最后会剩几个车队，相遇的车变成一个。

思考

确实挺头疼，首先可以确定是从离终点较远的位置开始，一个一个向起点位置逼近，两辆车想撞的条件就是一辆车在前面并且到达结束位置的时在前的车用时较长，这样把每辆车都和前面的车相比，如果这辆车不会和前面的相撞，那么它就会成为下一个车队。

代码实现

using ll = long long;

struct Node {
    int position;
    int speed;
    double use_time;
    friend bool operator<(const Node &a, const Node &b) {
        // 怎么排序
        return a.position >= b.position;
    }

    friend bool operator==(const Node &a, const Node &b) {
        // 实际上不能用==，不满足重写==的3个条件，为了方便先这么写吧
        // a就是前面的车，b是后面的
        return a.position >= b.position && a.use_time >= b.use_time;
    }
};

class Solution {
public:
    int carFleet(int target, vector<int>& position, vector<int>& speed) {
        if (position.size() == 0) {
            return 0;
        }
        // 直接模拟需要从前向后模拟吧，如果一辆车可以
        int size = position.size();
        vector<Node> nodes;
        Node n;
        for (int i = 0; i < size; ++i) {
            n.position = position[i];
            n.speed = speed[i];
            n.use_time = 1.0 * (target - n.position) / n.speed;
            nodes.push_back(n);
        }
        sort(nodes.begin(), nodes.end());
        // 开始判断能否追上
        int result = 1;
        Node old = nodes[0];
        for (int i = 1; i < size; ++i) {
            // 不能在一个车队中
            if (!(old == nodes[i])) {
                old = nodes[i];
                ++result;
            }
        }

        return result;
    }
};

感想

。。。