侧边栏壁纸
博主头像
Ysfun博主等级

一名热爱技术、喜欢折腾的小小程序猿

  • 累计撰写 42 篇文章
  • 累计创建 14 个标签
  • 累计收到 21 条评论

目 录CONTENT

文章目录

刷题分享:LeetCode[729,731,732]我的日程安排表

Ysfun
2022-06-17 / 0 评论 / 0 点赞 / 87 阅读 / 1,881 字

题目对应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 并且不要将该日程安排添加到日历中。

示例

输入:
["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

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)

示例

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

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

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

0

评论区