# 731. My Calendar II

## Description

You are implementing a program to use as your calendar. We can add a new event if adding the event will not cause a triple booking.

A triple booking happens when three events have some non-empty intersection (i.e., some moment is common to all the three events.).

The event can be represented as a pair of integers start and end that represents a booking on the half-open interval [start, end), the range of real numbers x such that start <= x < end.

Implement the MyCalendarTwo class:

• MyCalendarTwo() Initializes the calendar object.
• boolean book(int start, int end) Returns true if the event can be added to the calendar successfully without causing a triple booking. Otherwise, return false and do not add the event to the calendar.

Example 1:

Input
["MyCalendarTwo", "book", "book", "book", "book", "book", "book"]
[[], [10, 20], [50, 60], [10, 40], [5, 15], [5, 10], [25, 55]]
Output
[null, true, true, true, false, true, true]

Explanation
MyCalendarTwo myCalendarTwo = new MyCalendarTwo();
myCalendarTwo.book(10, 20); // return True, The event can be booked.
myCalendarTwo.book(50, 60); // return True, The event can be booked.
myCalendarTwo.book(10, 40); // return True, The event can be double booked.
myCalendarTwo.book(5, 15);  // return False, The event cannot be booked, because it would result in a triple booking.
myCalendarTwo.book(5, 10); // return True, The event can be booked, as it does not use time 10 which is already double booked.
myCalendarTwo.book(25, 55); // return True, The event can be booked, as the time in [25, 40) will be double booked with the third event, the time [40, 50) will be single booked, and the time [50, 55) will be double booked with the second event.


Constraints:

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

## Solutions

Use two lists to store the intervals of booking and the overlapping intervals, which are both sorted. Each time book(int start, int end) is called, loop over the list of overlaps to see whether there will be a new overlap.

• If so, then adding the new interval will cause a triple booking, so return false.
• Otherwise, add the new interval and the new overlapping intervals into the two list respectively, sort the two lists, and return true.
• class MyCalendarTwo {
private Map<Integer, Integer> tm = new TreeMap<>();

public MyCalendarTwo() {
}

public boolean book(int start, int end) {
tm.put(start, tm.getOrDefault(start, 0) + 1);
tm.put(end, tm.getOrDefault(end, 0) - 1);
int s = 0;
for (int v : tm.values()) {
s += v;
if (s > 2) {
tm.put(start, tm.get(start) - 1);
tm.put(end, tm.get(end) + 1);
return false;
}
}
return true;
}
}

/**
* Your MyCalendarTwo object will be instantiated and called as such:
* MyCalendarTwo obj = new MyCalendarTwo();
* boolean param_1 = obj.book(start,end);
*/

• class MyCalendarTwo {
public:
map<int, int> m;

MyCalendarTwo() {
}

bool book(int start, int end) {
++m[start];
--m[end];
int s = 0;
for (auto& [_, v] : m) {
s += v;
if (s > 2) {
--m[start];
++m[end];
return false;
}
}
return true;
}
};

/**
* Your MyCalendarTwo object will be instantiated and called as such:
* MyCalendarTwo* obj = new MyCalendarTwo();
* bool param_1 = obj->book(start,end);
*/

• from sortedcontainers import SortedDict

class MyCalendarTwo:
def __init__(self):
self.sd = SortedDict() # cannot be dict like self.sd={}

def book(self, start: int, end: int) -> bool:
self.sd[start] = self.sd.get(start, 0) + 1
self.sd[end] = self.sd.get(end, 0) - 1
s = 0
for v in self.sd.values():
s += v
if s > 2:
self.sd[start] -= 1
self.sd[end] += 1
return False
return True

# Your MyCalendarTwo object will be instantiated and called as such:
# obj = MyCalendarTwo()
# param_1 = obj.book(start,end)

############

class MyCalendarTwo(object):

def __init__(self):
# 每个被book了的区间
self.booked = list()
# 每个重叠了的区间
self.overlaped = list()

def book(self, start, end):
"""
:type start: int
:type end: int
:rtype: bool
"""
for os, oe in self.overlaped:
if max(os, start) < min(oe, end):
return False
for bs, be in self.booked:
ss = max(bs, start)
ee = min(be, end)
if ss < ee:
self.overlaped.append((ss, ee))
self.booked.append((start, end))
return True

# Your MyCalendarTwo object will be instantiated and called as such:
# obj = MyCalendarTwo()
# param_1 = obj.book(start,end)


• type MyCalendarTwo struct {
*redblacktree.Tree
}

func Constructor() MyCalendarTwo {
return MyCalendarTwo{redblacktree.NewWithIntComparator()}
}

func (this *MyCalendarTwo) Book(start int, end int) bool {
add := func(key, val int) {
if v, ok := this.Get(key); ok {
this.Put(key, v.(int)+val)
} else {
this.Put(key, val)
}
}
s := 0
it := this.Iterator()
for it.Next() {
s += it.Value().(int)
if s > 2 {
return false
}
}
return true
}

/**
* Your MyCalendarTwo object will be instantiated and called as such:
* obj := Constructor();
* param_1 := obj.Book(start,end);
*/