leetcode 5805. 最小未被占据椅子的编号

leetcode 5805. 最小未被占据椅子的编号

有 n 个朋友在举办一个派对，这些朋友从 0 到 n - 1 编号。派对里有 无数 张椅子，编号为 0 到 infinity 。当一个朋友到达派对时，他会占据 编号最小 且未被占据的椅子。

比方说，当一个朋友到达时，如果椅子 0 ，1 和 5 被占据了，那么他会占据 2 号椅子。
当一个朋友离开派对时，他的椅子会立刻变成未占据状态。如果同一时刻有另一个朋友到达，可以立即占据这张椅子。

给你一个下标从 0 开始的二维整数数组 times ，其中 times[i] = [arrivali, leavingi] 表示第 i 个朋友到达和离开的时刻，同时给你一个整数 targetFriend 。所有到达时间 互不相同 。

请你返回编号为 targetFriend 的朋友占据的 椅子编号 。

示例 1：

输入：times = [[1,4],[2,3],[4,6]], targetFriend = 1
输出：1
解释：
朋友 0 时刻 1 到达，占据椅子 0 。
朋友 1 时刻 2 到达，占据椅子 1 。
朋友 1 时刻 3 离开，椅子 1 变成未占据。
朋友 0 时刻 4 离开，椅子 0 变成未占据。
朋友 2 时刻 4 到达，占据椅子 0 。
朋友 1 占据椅子 1 ，所以返回 1 。

示例 2：

输入：times = [[3,10],[1,5],[2,6]], targetFriend = 0
输出：2
解释：
朋友 1 时刻 1 到达，占据椅子 0 。
朋友 2 时刻 2 到达，占据椅子 1 。
朋友 0 时刻 3 到达，占据椅子 2 。
朋友 1 时刻 5 离开，椅子 0 变成未占据。
朋友 2 时刻 6 离开，椅子 1 变成未占据。
朋友 0 时刻 10 离开，椅子 2 变成未占据。
朋友 0 占据椅子 2 ，所以返回 2 。

提示：

• n == times.length
• 2 <= n <= 10^4
• times[i].length == 2
• 1 <= arrivali < leavingi <= 10^5
• 0 <= targetFriend <= n - 1
• 每个 arrivali 时刻 互不相同 。

方法一：排序 + 优先队列 + 双指针

• 将所有人的到达时间和离开时间分开处理，然后排序
• 用哈希表记录某个人所占的椅子编号，初始全为-1，表示未占用椅子
• 小顶堆存放空闲的椅子。
• 双指针l指向到达的时间序列，r指向离开的时间序列
• 当前l所指向的到达时间 < r所指向的离开时间，那么就可以占用一个空闲的椅子； 反之，r所指向的人将离开，其所占用的椅子变为空闲。
• （可以将 l 所指向的时间看作当前时间，如果当前时间大于某个离开时间，那么r所指向的人就要离开）

class Solution {
static bool cmpp(pair<int, int> &a, pair<int, int> &b) {
   return a.first < b.first;
}
public:
    int smallestChair(vector<vector<int>>& times, int targetFriend) {
        int n = times.size();
        vector<pair<int, int>> start, end;
        vector<int> hash(n, -1);  //记录i号朋友所占用的椅子
        for(int i=0; i<n; i++){
            start.push_back({times[i][0], i});  //<开始时间, 朋友编号>
            end.push_back({times[i][1], i});  //<结束时间, 朋友编号>
        }
        sort(start.begin(), start.end(), cmpp); //升序排列
        sort(end.begin(), end.end(), cmpp);
        priority_queue<int, vector<int>, greater<int> > chair;
        for(int i=0; i<n; i++){
            chair.push(i);
        }
        int l = 0, r = 0;
        while(l < n && r < n){
            //l->开始时间 小于 r->离开时间
            if(start[l].first < end[r].first){
                //l->编号朋友 占用最小号椅子
                hash[start[l].second] = chair.top();
                chair.pop();
                //如果找到目标值，结束
                if(start[l].second == targetFriend){
                     return hash[targetFriend];
                }
                l++;   //右移
            }
            else{
                int ac = hash[end[r].second];
                hash[end[r].second] = -1;
                chair.push(ac);
                r++;   
            }
        }
        return 0;
    }
};

方法二：模拟 + 优先队列

• 模拟过程，若当前时间有离开的朋友，则释放其所占椅子，并加入到椅子的队列中。若有到达的朋友，占用堆顶的椅子。

class Solution {
static bool cmpp(vector<int> &a, vector<int> &b) {
   return a[0] < b[0];
}
//离开时间较小的，在顶部
struct cmp{
    bool operator()(vector<int> &a, vector<int> &b){
        return a[1] > b[1];
    }
};
public:
    int smallestChair(vector<vector<int>>& times, int targetFriend) {
        //目标人物的到达时间
        int targettime = times[targetFriend][0];
        int n = times.size();
        //times[i]加入朋友编号和所占椅子，-1代表未占椅子
        for(int i=0; i<n; i++){
            times[i].push_back(i);
            times[i].push_back(-1);
        }
        sort(times.begin(), times.end(), cmpp);
        //当前在场的朋友，及他们所占的椅子
        priority_queue<vector<int>, vector<vector<int>>, cmp > pq;
        //空闲的椅子
        priority_queue<int, vector<int>, greater<int> > chair;
        for(int i=0; i<n; i++){
            chair.push(i);
        }
        int time = 0;   //当前时间
        int k = 0;
        //由于到达时间和离开时间可以相同，椅子先释放，后再被占用，所以优先处理离开的过程
        while(time < targettime){
            time++;
            //离开时间可以是相同的,要while
            while(!pq.empty() && pq.top()[1] == time){
                chair.push(pq.top()[3]);
                pq.pop();
            }
            //到达时间不相同，每次只来一个朋友
            if(k < n && times[k][0] == time){
                //占用栈顶的椅子
                times[k][3] = chair.top();
                chair.pop();
                pq.push(times[k]);
                if(times[k][2] == targetFriend){
                    return times[k][3];
                }
                k++;
            }
        }
        return 0;
    }
};