【LeetCode】每日一题：拼车——2023.12.2

题目链接：拼车

题干解析：

车上一共有capacity个座位，trips中记录了一系列旅途信息（有numPassengers个乘客从from位置乘坐到to位置），判断汽车能否把trips中所有的乘客都送达目的地；

思路分析：

这里提供一个和官方差分法题解不一样的思路：

首先trips中给出的一系列trip的上车顺序是混乱的，我们需要先对trips进行一个关于上车顺序的排序，其次遍历trips数组，实时判断此时车上的乘客数是否超过容量，若超过，返回false；

如何实现对车上的乘客数量进行实时判断呢？用一个整型变量num_in_car维护车上的人数，用一个优先队列out_tree维护车上乘客的下车地点，每遍历到一个trip，都会有乘客上车，同时out_tree中所有在该trip地点前的乘客都会下车，由此即可得到该trip乘客上车时车上的总人数。由此一直遍历trips，只要每次有乘客上车时，车上的乘客人数不超过总容量，汽车即可成功将所有乘客都送达目的地。

代码：

class Solution {
public:
    void swap(vector<vector<int>>& trips, int i, int j){
        vector<int> temp = trips[i];
        trips[i] = trips[j];
        trips[j] = temp;
    }
    void partition(vector<vector<int>>& trips, int left, int right){//哨兵分割
        if(left > right){
            return;
        }
        int i = left, j = right;
        while(i < j){
            while(i < j && trips[j][1] >= trips[left][1]){
                j --;
            }
            while(i < j && trips[i][1] <= trips[left][1]){
                i ++;
            }
            swap(trips, i, j);
        }
        swap(trips, left, i);
        partition(trips, left, i - 1);
        partition(trips, i + 1, right);
    }
    bool carPooling(vector<vector<int>>& trips, int capacity) {
        vector<int> out_pos(1001);
        priority_queue<int, vector<int>, greater<int>> out_tree;
        int num_in_car = 0;

        partition(trips, 0, trips.size() - 1);//使用快排

        for(auto t : trips){
            // cout<< t[1] << endl;
            
            while(!out_tree.empty() && t[1] >= out_tree.top()){
                num_in_car -= out_pos[out_tree.top()] ;
                cout<< out_pos[out_tree.top()] << endl;
                out_pos[out_tree.top()] = 0;
                out_tree.pop();
            }
            out_tree.push(t[2]);
            out_pos[t[2]] += t[0];
            num_in_car += t[0];

            cout << num_in_car << endl;
            if(num_in_car > capacity){
                return false;
            }
        }
        return true;
    }
};

附上官方解法（差分数组）：

class Solution {
public:
    bool carPooling(vector<vector<int>>& trips, int capacity) {
        int to_max = 0;
        for (const auto& trip: trips) {
            to_max = max(to_max, trip[2]);
        }

        vector<int> diff(to_max + 1);
        for (const auto& trip: trips) {
            diff[trip[1]] += trip[0];
            diff[trip[2]] -= trip[0];
        }

        int count = 0;
        for (int i = 0; i <= to_max; ++i) {
            count += diff[i];
            if (count > capacity) {
                return false;
            }
        }
        return true;
    }
};

作者：力扣官方题解
链接：https://leetcode.cn/problems/car-pooling/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。