# Solving Leetcode Interviews in Seconds with AI: My Calendar II


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "731" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> 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 startTime and endTime that represents a booking on the half-open interval [startTime, endTime), the range of real numbers x such that startTime <= x < endTime. Implement the MyCalendarTwo class:  MyCalendarTwo() Initializes the calendar object. boolean book(int startTime, int endTime) 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.  

	# Explanation
	Here's the solution approach, complexity analysis, and Python code for the `MyCalendarTwo` problem:

*   **Differential Arrays:** Use two sorted lists (or ordered dictionaries if available in the language, but sorted lists with binary search offer similar performance in Python) to track booking counts. One list `bookings` keeps track of all bookings (single and double). The other list `overlaps` keeps track of only the double bookings (overlaps).
*   **Increment/Decrement Counts:** When a new event comes in, iterate through existing `overlaps`. If the new event overlaps with any existing double booking, it leads to a triple booking, and we reject the event. Otherwise, add the event to the `bookings` list. Then, iterate through the existing `bookings` and identify newly formed double bookings with the current event and add it to the `overlaps` list. Maintain `bookings` and `overlaps` in sorted order.

*   **Complexity:**
    *   Runtime: O(n^2) in the worst case due to nested loops for finding overlaps, where n is the number of bookings. Using binary search in sorted lists to find overlaps reduces the average time complexity.
    *   Storage: O(n) to store booking intervals.

	
	# Code
	```python
	class MyCalendarTwo:

    def __init__(self):
        self.bookings = []
        self.overlaps = []

    def book(self, start: int, end: int) -> bool:
        for s, e in self.overlaps:
            if start < e and end > s:
                return False

        for s, e in self.bookings:
            if start < e and end > s:
                self.overlaps.append((max(start, s), min(end, e)))

        self.bookings.append((start, end))
        return True
	```