刷题分享：LeetCode[729,731,732]我的日程安排表【TreeMap、查分数组、线段树】

发表于 更新于 分类于 阅读次数： 评论数： 本文字数： 5.1k

题目对应LeetCode729. 我的日程安排表 I 731. 我的日程安排表 II 732. 我的日程安排表 III

我的日程安排表I

729. 我的日程安排表 I

题目描述

实现一个 MyCalendar 类来存放你的日程安排。如果要添加的日程安排不会造成 重复预订 ，则可以存储这个新的日程安排。

当两个日程安排有一些时间上的交叉时（例如两个日程安排都在同一时间内），就会产生 重复预订 。

日程可以用一对整数 start 和 end 表示，这里的时间是半开区间，即 [start, end), 实数 x 的范围为， start <= x < end 。

实现 MyCalendar 类：

MyCalendar() 初始化日历对象。
boolean book(int start, int end) 如果可以将日程安排成功添加到日历中而不会导致重复预订，返回 true 。否则，返回 false 并且不要将该日程安排添加到日历中。

示例

1
2
3
4
5
6
7
8
9
10
11
输入：
["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】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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

731. 我的日程安排表 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)

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
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时应撤销添加日程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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

732. 我的日程安排表 III

题目描述

当 k 个日程安排有一些时间上的交叉时（例如 k 个日程安排都在同一时间内），就会产生 k 次预订。

给你一些日程安排 [start, end) ，请你在每个日程安排添加后，返回一个整数 k ，表示所有先前日程安排会产生的最大 k 次预订。

实现一个 MyCalendarThree 类来存放你的日程安排，你可以一直添加新的日程安排。

MyCalendarThree() 初始化对象。
int book(int start, int end) 返回一个整数 k ，表示日历中存在的 k 次预订的最大值。

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
输入：
["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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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;
    }
}

方法二：线段树

针对本题的线段树初级教程可以参考：线段树 – 新手篇

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
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)));
        }
    }
}

后续会出一篇关于线段树的详细教程！！！

相关文章