[Swift]LeetCode855. 考场就座 | Exam Room

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址： https://www.cnblogs.com/strengthen/p/10594220.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

In an exam room, there are N seats in a single row, numbered 0, 1, 2, ..., N-1.

When a student enters the room, they must sit in the seat that maximizes the distance to the closest person.  If there are multiple such seats, they sit in the seat with the lowest number.  (Also, if no one is in the room, then the student sits at seat number 0.)

Return a class ExamRoom(int N) that exposes two functions: ExamRoom.seat() returning an int representing what seat the student sat in, and ExamRoom.leave(int p) representing that the student in seat number p now leaves the room.  It is guaranteed that any calls to ExamRoom.leave(p) have a student sitting in seat p. 

Example 1:

Input: ["ExamRoom","seat","seat","seat","seat","leave","seat"], [[10],[],[],[],[],[4],[]]
Output: [null,0,9,4,2,null,5]
Explanation:
ExamRoom(10) -> null
seat() -> 0, no one is in the room, then the student sits at seat number 0.
seat() -> 9, the student sits at the last seat number 9.
seat() -> 4, the student sits at the last seat number 4.
seat() -> 2, the student sits at the last seat number 2.
leave(4) -> null
seat() -> 5, the student sits at the last seat number 5.​​​​​​​

Note:

1. 1 <= N <= 10^9
2. ExamRoom.seat() and ExamRoom.leave() will be called at most 10^4 times across all test cases.
3. Calls to ExamRoom.leave(p) are guaranteed to have a student currently sitting in seat number p.

---

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

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

返回 ExamRoom(int N) 类，它有两个公开的函数：其中，函数 ExamRoom.seat() 会返回一个 int （整型数据），代表学生坐的位置；函数 ExamRoom.leave(int p) 代表坐在座位 p上的学生现在离开了考场。请确保每次调用 ExamRoom.leave(p) 时都有学生坐在座位 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. 1 <= N <= 10^9
2. 在所有的测试样例中 ExamRoom.seat() 和 ExamRoom.leave() 最多被调用 10^4 次。
3. 调用 ExamRoom.leave(p) 时需要确保当前有学生坐在座位 p 上。

---

336ms

class ExamRoom {    
    var students: [Int]
    let N: Int

    init(_ N: Int) {
        students = [Int]()
        self.N = N
    }
    
    // with sort it's O(PlogP), with index it's O(P)
    func seat() -> Int {
        var student = 0
        var index = 0
        if students.count > 0 {
            var prev: Int? = nil
            var dist = students.first ?? 0
            for (i, studentPos) in students.enumerated() {
                if let prev = prev {
                    let d: Int = (studentPos - prev) / 2
                    if d > dist {
                        dist = d
                        student = prev + d
                        index = i
                    }
                }
                prev = studentPos
            }
            if N - 1 - (students.last ?? 0) > dist {
                student = N - 1
                index = students.count
            }
        }
        students.insert(student, at: index)
        return student
    }
    
    // O(P), because of remove.
    func leave(_ p: Int) {
        for i in 0..<students.count {
            if students[i] == p {
                students.remove(at: i)
                return
            }
        }
    }
}

// wrong
class ExamRoom1 {
    
    var seats: [Bool]

    init(_ N: Int) {
        seats = Array(repeating: false, count: N)
    }
    
    func seat() -> Int {
        let index = findSeat(0, seats.count - 1)
        seats[index] = true
        return index
    }
    
    func leave(_ p: Int) {
        seats[p] = false
    }
    
    private func findSeat(_ l: Int, _ r: Int) -> Int {
        if seats[l] == false {
            return 0
        }
        if seats[r] == false {
            return r
        }
        let m = (l + r) / 2
        if seats[m] == false {
            return m
        }
        let lh = findSeat(l, m)  
        if seats[lh] == false {
            return lh
        }
        
        let rh = findSeat(m, r)
        if seats[rh] == false {
            return rh
        }
        return -1
    }
}

/**
 * Your ExamRoom object will be instantiated and called as such:
 * let obj = ExamRoom(N)
 * let ret_1: Int = obj.seat()
 * obj.leave(p)
 */ 

---

Runtime: 2084 ms

Memory Usage: 20.1 MB

class ExamRoom {
    static var N:Int = 0
    var pq:[Interval] = [Interval]()

    init(_ N: Int) {
        ExamRoom.N = N
        pq.append(Interval(-1, N))       
    }
    
    func seat() -> Int {
        var seat:Int = 0
        var interval:Interval = pq.removeFirst()
        if interval.x == -1 {seat = 0}
        else if interval.y == ExamRoom.N {seat = ExamRoom.N - 1}
        else {seat = (interval.x + interval.y) / 2}
        offer(Interval(interval.x, seat))
        offer(Interval(seat, interval.y))
        return seat      
    }
    
    func leave(_ p: Int) {
        var head:Interval? = nil
        var tail:Interval? = nil
        for interval in pq
        {
            if interval.x == p {tail = interval}
            if interval.y == p {head = interval}
            if head != nil && tail != nil {break}
        }
        removeEle(head!)
        removeEle(tail!)
        offer(Interval(head!.x, tail!.y))
    }
    
    func removeEle(_ interval:Interval)
    {
        for i in (0..<pq.count).reversed()
        {
            if pq[i].x == interval.x && pq[i].y == interval.y && pq[i].dist == interval.dist
            {
                pq.remove(at:i)
            }
        }
    }

    func offer(_ interval:Interval)
    {
        pq.append(interval)
        pq.sort(by:{(a:Interval,b:Interval) -> Bool in 
                if a.dist == b.dist
                {
                    return a.x <= b.x
                }
                else
                {
                    return a.dist > b.dist
                }
        })
    }
}

class Interval{
    var x:Int
    var y:Int
    var dist:Int
    init(_ x:Int,_ y:Int)
    {
        self.x = x
        self.y = y
        if x == -1
        {
            self.dist = y
        }
        else if y == ExamRoom.N
        {
            self.dist = ExamRoom.N - 1 - x
        }
        else
        {
            self.dist = abs(x - y) / 2
        }
    }
}

/**
 * Your ExamRoom object will be instantiated and called as such:
 * let obj = ExamRoom(N)
 * let ret_1: Int = obj.seat()
 * obj.leave(p)
 */