题目对应LeetCode729. 我的日程安排表 I 731. 我的日程安排表 II 732. 我的日程安排表 III
我的日程安排表I
题目描述
实现一个 MyCalendar 类来存放你的日程安排。如果要添加的日程安排不会造成 重复预订 ，则可以存储这个新的日程安排。
当两个日程安排有一些时间上的交叉时（例如两个日程安排都在同一时间内），就会产生 重复预订 。
日程可以用一对整数 start 和 end 表示，这里的时间是半开区间，即 [start, end), 实数 x 的范围为， start <= x < end 。
实现 MyCalendar 类：
MyCalendar() 初始化日历对象。
boolean book(int start, int end) 如果可以将日程安排成功添加到日历中而不会导致重复预订，返回 true 。否则，返回 false 并且不要将该日程安排添加到日历中。
示例
输入：
["MyCalendar", "book", "book", "book"]
[[], [10, 20], [15, 25], [20, 30]]
输出：
[null, true, false, true]
解释：
MyCalendar myCalendar = new MyCalendar();
myCalendar.book(10, 20); // return True
myCalendar.book(15, 25); // return False ，这个日程安排不能添加到日历中，因为时间 15 已经被另一个日程安排预订了。
myCalendar.book(20, 30); // return True ，这个日程安排可以添加到日历中，因为第一个日程安排预订的每个时间都小于 20 ，且不包含时间 20 。
题解【TreeMap】
class MyCalendar {
TreeMap<Integer, Integer> treeMap;
public MyCalendar() {
treeMap = new TreeMap<>();
}
public boolean book(int start, int end) {
Map.Entry<Integer, Integer> floor = treeMap.floorEntry(start);
Map.Entry<Integer, Integer> ceiling = treeMap.ceilingEntry(start);
if (floor != null && floor.getValue() > start) {
return false;
}
if (ceiling != null && ceiling.getKey() < end) {
return false;
}
treeMap.put(start, end);
return true;
}
}
复杂度分析
在book()方法中，TreeMap是排序二叉树，treeMap.floorEntry()和treeMap.ceilingEntry()都是通过二分查找实现的，时间复杂度都是o (log n).
我的日程安排表II
题目描述
实现一个 MyCalendar 类来存放你的日程安排。如果要添加的时间内不会导致三重预订时，则可以存储这个新的日程安排。
MyCalendar 有一个 book(int start, int end)方法。它意味着在 start 到 end 时间内增加一个日程安排，注意，这里的时间是半开区间，即 [start, end), 实数 x 的范围为， start <= x < end。
当三个日程安排有一些时间上的交叉时（例如三个日程安排都在同一时间内），就会产生三重预订。
每次调用 MyCalendar.book方法时，如果可以将日程安排成功添加到日历中而不会导致三重预订，返回 true。否则，返回 false 并且不要将该日程安排添加到日历中。
请按照以下步骤调用MyCalendar 类: MyCalendar cal = new MyCalendar(); MyCalendar.book(start, end)
示例
MyCalendar();
MyCalendar.book(10, 20); // returns true
MyCalendar.book(50, 60); // returns true
MyCalendar.book(10, 40); // returns true
MyCalendar.book(5, 15); // returns false
MyCalendar.book(5, 10); // returns true
MyCalendar.book(25, 55); // returns true
解释：
前两个日程安排可以添加至日历中。 第三个日程安排会导致双重预订，但可以添加至日历中。
第四个日程安排活动（5,15）不能添加至日历中，因为它会导致三重预订。
第五个日程安排（5,10）可以添加至日历中，因为它未使用已经双重预订的时间10。
第六个日程安排（25,55）可以添加至日历中，因为时间 [25,40] 将和第三个日程安排双重预订；
时间 [40,50] 将单独预订，时间 [50,55）将和第二个日程安排双重预订
题解【差分数组思想、TreeMap】
边界计数，边界开始时计数加一delta[start]++，边界计数时计数减一delta[end]--，按照排序从小到达统计count之和，一旦count==3则表明当前区间有三次重叠。考虑到需要排序结构，delta使用TreeMap。
图解：
注意：当count==3时应撤销添加日程
class MyCalendarTwo {
TreeMap<Integer, Integer> treeMap;
public MyCalendarTwo() {
treeMap = new TreeMap<>();
}
public boolean book(int start, int end) {
treeMap.put(start, treeMap.getOrDefault(start, 0)+1);
treeMap.put(end, treeMap.getOrDefault(end, 0)-1);
int sum = 0;
for (int count : treeMap.values()) {
sum += count;
if (sum >= 3) {
// 出现三重预定，取消将该日程添加到日历
treeMap.put(start, treeMap.getOrDefault(start, 0)-1);
treeMap.put(end, treeMap.getOrDefault(end, 0)+1);
return false;
}
}
return true;
}
}
我的日程安排表III
题目描述
当 k 个日程安排有一些时间上的交叉时（例如 k 个日程安排都在同一时间内），就会产生 k 次预订。
给你一些日程安排 [start, end) ，请你在每个日程安排添加后，返回一个整数 k ，表示所有先前日程安排会产生的最大 k 次预订。
实现一个 MyCalendarThree 类来存放你的日程安排，你可以一直添加新的日程安排。
MyCalendarThree() 初始化对象。
int book(int start, int end) 返回一个整数 k ，表示日历中存在的 k 次预订的最大值。
示例
输入：
["MyCalendarThree", "book", "book", "book", "book", "book", "book"]
[[], [10, 20], [50, 60], [10, 40], [5, 15], [5, 10], [25, 55]]
输出：
[null, 1, 1, 2, 3, 3, 3]
解释：
MyCalendarThree myCalendarThree = new MyCalendarThree();
myCalendarThree.book(10, 20); // 返回 1 ，第一个日程安排可以预订并且不存在相交，所以最大 k 次预订是 1 次预订。
myCalendarThree.book(50, 60); // 返回 1 ，第二个日程安排可以预订并且不存在相交，所以最大 k 次预订是 1 次预订。
myCalendarThree.book(10, 40); // 返回 2 ，第三个日程安排 [10, 40) 与第一个日程安排相交，所以最大 k 次预订是 2 次预订。
myCalendarThree.book(5, 15); // 返回 3 ，剩下的日程安排的最大 k 次预订是 3 次预订。
myCalendarThree.book(5, 10); // 返回 3
myCalendarThree.book(25, 55); // 返回 3
题解【线段树】
方法一：差分数组
采用差分数组解法，同我的日程安排表II
class MyCalendarThree {
TreeMap<Integer, Integer> delta;
public MyCalendarThree() {
delta = new TreeMap<>();
}
public int book(int start, int end) {
delta.put(start, delta.getOrDefault(start, 0)+1);
delta.put(end, delta.getOrDefault(end, 0)-1);
int count = 0, maxCount = 0;
for (int val : delta.values()) {
count += val;
maxCount = Math.max(count, maxCount);
}
return maxCount;
}
}
方法二：线段树
针对本题的线段树初级教程可以参考：线段树 – 新手篇
class MyCalendarThree {
private Map<Integer, Integer> tree;
private Map<Integer, Integer> lazy;
public MyCalendarThree() {
tree = new HashMap<Integer, Integer>();
lazy = new HashMap<Integer, Integer>();
}
public int book(int start, int end) {
update(start, end - 1, 0, 1000000000, 1);
return tree.getOrDefault(1, 0);
}
public void update(int start, int end, int l, int r, int idx) {
if (r < start || end < l) {
return;
}
if (start <= l && r <= end) {
tree.put(idx, tree.getOrDefault(idx, 0) + 1);
lazy.put(idx, lazy.getOrDefault(idx, 0) + 1);
} else {
int mid = (l + r) >> 1;
update(start, end, l, mid, 2 * idx);
update(start, end, mid + 1, r, 2 * idx + 1);
tree.put(idx, lazy.getOrDefault(idx, 0) + Math.max(tree.getOrDefault(2 * idx, 0), tree.getOrDefault(2 * idx + 1, 0)));
}
}
}
后续会出一篇关于线段树的详细教程！！！
评论区