855. 考场就座

ethannotlazy

已于 2023-04-05 11:31:16 修改

阅读量371

点赞数

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

于 2023-02-16 13:17:30 首次发布

本文链接：https://blog.csdn.net/weixin_43116322/article/details/129059091

版权

leetcode刷题专栏收录该内容

17 篇文章 0 订阅

订阅专栏

题目

考场就座

在考场里，一排有 N 个座位，分别编号为 0, 1, 2, …, N-1 。

当学生进入考场后，他必须坐在能够使他与离他最近的人之间的距离达到最大化的座位上。如果有多个这样的座位，他会坐在编号最小的座位上。(另外，如果考场里没有人，那么学生就坐在 0 号座位上。)

返回 ExamRoom(int N) 类，它有两个公开的函数：其中，函数 ExamRoom.seat() 会返回一个 int （整型数据），代表学生坐的位置；函数 ExamRoom.leave(int p) 代表坐在座位 p 上的学生现在离开了考场。每次调用 ExamRoom.leave§ 时都保证有学生坐在座位 p 上。

示例：

输入：[“ExamRoom”,“seat”,“seat”,“seat”,“seat”,“leave”,“seat”], [[10],[],[],[],[],[4],[]]
输出：[null,0,9,4,2,null,5]
解释：
ExamRoom(10) -> null
seat() -> 0，没有人在考场里，那么学生坐在 0 号座位上。
seat() -> 9，学生最后坐在 9 号座位上。
seat() -> 4，学生最后坐在 4 号座位上。
seat() -> 2，学生最后坐在 2 号座位上。
leave(4) -> null
seat() -> 5，学生最后坐在 5 号座位上。

提示：
1 <= N <= 10^9
在所有的测试样例中 ExamRoom.seat() 和 ExamRoom.leave() 最多被调用 10^4 次。
保证在调用 ExamRoom.leave§ 时有学生正坐在座位 p 上。

分析

寻找座位

要实时找到使间距最大化的位置，可以维护一个区间的有序集合。只要能找到最大的区间，就能够确定目标座位。
可以用左端点和右端点 [left, right] 表示一个区间，如果一个学生坐在区间的中间，那么他与两个端点的间距为 (right - left) / 2。根据题意，间距相等时优先选择序号小的座位，则排序区间的比较规则是：

若两个区间的间距不等：
	选择间距较大的区间
否则：
	选择序号较小的区间

可以将区间放到一个大顶堆中，这样就可以在 O(1) 时间复杂度下找到满足条件的最大区间 m。当一个学生坐下时，需要将 m 从大顶堆移除，并根据学生坐下的位置将新产生的区间放入到大顶堆中。假设区间为 m = [a, b]，那么学生应该坐到 c = (a+b) / 2，则新产生的区间为：[a,c] 和 [c, b]。

离开座位

至此，只分析了没有学生会离开座位的情况。如果一个学生离开了座位，那么由他坐下而产生的新区间都将失效，此外还需要将因为学生离开而产生的新区间放入到大顶堆中。

我们可以延迟删除大顶堆中失效的区间。

为了确定大顶堆中的区间是否失效，可以设置一个有序集合 set 表示当前有学生的座位号。验证一个区间 [a, b] 有效的条件为：

能从 set 里面找到 a 和 b，即两个端点都有学生；
a 和 b 之间没有其它值，即没有学生坐在这个区间里。

其它

上述分析不包含边界条件。首先想到通过在位置 -1 和位置 n 放置哨兵，避免特殊情况的判断。但题目要求第一个位置为 0 号座位，所以这种方法行不通。

可以单独计算学生坐在边沿的情况：

如果当前没有学生就座，直接选择 0 号座位；
如果边沿座位比某区间中央的座位更佳，则选择边沿座位。

代码

struct interval {
    int left, right;
};

// sort by distance and index
struct CompByLen {
    bool operator()(const interval a, const interval b) const {
        int da = a.right - a.left, db = b.right - b.left;
        return da / 2 < db / 2 || da / 2 == db / 2 && a.left > b.left;
    }
};

class ExamRoom {
public:
    ExamRoom(int n) : n_(n) {
    }

    int seat() {
        if (seat_taken_.empty()) {
            seat_taken_.insert(0);
            return 0;
        }
        // distance between the leftmost seat and the first student
        int llen = *seat_taken_.begin();
        // distance between the rightmost seat and the last student
        int rlen = n_ - 1 - *seat_taken_.rbegin();
        if (seat_taken_.size() >= 2) {
            while (true) {
                auto p = interval_by_len_.top();
                if (!isValidInterval(p)) {
                    // obsolete interval
                    interval_by_len_.pop();
                    continue;
                }
                int len = p.right - p.left;
                if (len / 2 <= llen || len / 2 < rlen) {
                    // Leftmost seat or rightmost seat is better.
                    break;
                }
                interval_by_len_.pop();
                int pos = p.left + len / 2;
                
                // create two sub-interval
                interval_by_len_.push({p.left, pos});
                interval_by_len_.push({pos, p.right});
                seat_taken_.insert(pos);
                return pos;
            }
        }
        if (llen >= rlen) {
            interval_by_len_.push({0, *seat_taken_.begin()});
            seat_taken_.insert(0);
            return 0;
        } else {
            interval_by_len_.push({*seat_taken_.rbegin(), n_ - 1});
            seat_taken_.insert(n_ - 1);
            return n_ - 1;
        }
    }

    void leave(int p) {
        auto it = seat_taken_.find(p);
        if (it != seat_taken_.begin() && it != prev(seat_taken_.end())) {
        	// implicitly combine two intervals
            interval_by_len_.push({*prev(it), *next(it)});
        }
        seat_taken_.erase(it);
    }

private:
    int n_;
    set<int> seat_taken_;
    priority_queue<interval, vector<interval>, CompByLen> interval_by_len_;

    bool isValidInterval(interval &p) {
        // Have students both sides && no student in the middle.
        return seat_taken_.count(p.left) > 0 && seat_taken_.count(p.right) > 0 &&
               *next(seat_taken_.find(p.left)) == p.right;
    }
};