LeetCode Daily: My Calendar II Solution in Java | September 27, 2024 #coding #computerscience

🔍 LeetCode Problem of the Day: My Calendar II

In today's LeetCode daily challenge, we solve the My Calendar II problem, where we extend the basic calendar functionality to allow double bookings but prevent triple bookings. The solution is implemented in Java.

👉 Solution: Pinned in the comments.

🌟 Problem Description:
You need to implement a calendar that allows double bookings but not triple bookings. The task is to implement the book method, which returns true if the event can be added without causing a triple booking, and false otherwise.

🔑 Key Points:
Double Booking: The calendar allows events to overlap once (double booking), but not twice (triple booking).
Overlap Tracking: Overlaps are stored in a separate list to track regions where two events overlap.
Triple Booking Prevention: Before booking a new event, it checks for any overlap with existing double-booked intervals.

📝 Code Explanation:
Event and Overlap Lists: Two lists are maintained — one for storing all events and another for storing the overlapping intervals.
Triple Booking Check: For each new event, it checks if it would cause a triple booking by checking overlaps.
Double Booking Logic: If no triple booking is caused, the event is added to the calendar, and new overlaps are recorded if they exist with previous events.

📅 Daily Solutions:
Subscribe for daily LeetCode solutions explained step-by-step in Java!

👥 Join the Community:
Share your thoughts on the problem in the comments. Discuss different approaches with fellow coders. Like, share, and subscribe for more daily coding challenges!

#LeetCode #Coding #Programming #TechInterview #DailyChallenge #EventScheduling #TripleBooking #Calendar #Java

[AlgoXploration]

class MyCalendarTwo {
List<int[]> events;
List<int[]> overlaps;

public MyCalendarTwo() {
events = new ArrayList<>();
overlaps = new ArrayList<>();
}

public boolean book(int start, int end) {
for (int[] overlap : overlaps) {
if (overlap[0] < end && start < overlap[1])
return false;
}
for (int[] event : events) {
if (event[0] < end && start < event[1])
overlaps.add(new int[] {Math.max(start, event[0]), Math.min(end, event[1])});
}
events.add(new int[] {start, end});
return true;
}
}