LeetCode in Kotlin

732. My Calendar III

Hard

A k-booking happens when k events have some non-empty intersection (i.e., there is some time that is common to all k events.)

You are given some events [start, end), after each given event, return an integer k representing the maximum k-booking between all the previous events.

Implement the MyCalendarThree class:

• MyCalendarThree() Initializes the object.
• int book(int start, int end) Returns an integer k representing the largest integer such that there exists a k-booking in the calendar.

Example 1:

Input

[“MyCalendarThree”, “book”, “book”, “book”, “book”, “book”, “book”]

[[], [10, 20], [50, 60], [10, 40], [5, 15], [5, 10], [25, 55]]

Output: [null, 1, 1, 2, 3, 3, 3]

Explanation:

MyCalendarThree myCalendarThree = new MyCalendarThree(); 
myCalendarThree.book(10, 20); // return 1, The first event can be booked and is disjoint, so the maximum k-booking is a 1-booking. 
myCalendarThree.book(50, 60); // return 1, The second event can be booked and is disjoint, so the maximum k-booking is a 1-booking. 
myCalendarThree.book(10, 40); // return 2, The third event [10, 40) intersects the first event, and the maximum k-booking is a 2-booking. 
myCalendarThree.book(5, 15); // return 3, The remaining events cause the maximum K-booking to be only a 3-booking. 
myCalendarThree.book(5, 10); // return 3 
myCalendarThree.book(25, 55); // return 3

Constraints:

• 0 <= start < end <= 109
• At most 400 calls will be made to book.

Solution

class MyCalendarThree {
    private val root: Node = Node(0, 1000000000, 0)

    fun book(start: Int, end: Int): Int {
        updateTree(root, start, end - 1)
        return root.`val`
    }

    private fun updateTree(root: Node?, start: Int, end: Int) {
        if (root == null) {
            return
        }
        if (root.low >= start && root.high <= end) {
            root.`val`++
            if (root.left != null) {
                updateTree(root.left, start, end)
            }
            if (root.right != null) {
                updateTree(root.right, start, end)
            }
            return
        }
        val mid = (root.low + root.high) / 2
        if (root.left == null) {
            root.left = Node(root.low, mid, root.`val`)
        }
        if (root.right == null) {
            root.right = Node(mid + 1, root.high, root.`val`)
        }
        if (start <= mid) {
            updateTree(root.left, start, end)
        }
        if (end > mid) {
            updateTree(root.right, start, end)
        }
        root.`val` = root.left!!.`val`.coerceAtLeast(root.right!!.`val`)
    }

    internal class Node(var low: Int, var high: Int, var `val`: Int) {
        var left: Node? = null
        var right: Node? = null
    }
}

/*
 * Your MyCalendarThree object will be instantiated and called as such:
 * var obj = MyCalendarThree()
 * var param_1 = obj.book(startTime,endTime)
 */

This site is open source. Improve this page.