在考场里,一排有 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 号座位,所以这种方法行不通。
可以单独计算学生坐在边沿的情况:
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;
}
};
这道题用了大顶堆 + 延迟删除 + 有序集合。
利用大顶堆确定了某一个时刻的最大“区间”。但是,当一个学生离开座位时,移除大顶堆中相应的区间需要 O(n),于是我们采用延迟删除策略:利用一个区间的两个端点是否都有人学生,以及这个区间的中间是否有学生,来确定这是不是一个有效的区间(isValidInterval()
)。
为了实现延迟删除的检查,用有序集合记录学生的就坐情况。