【宫水三叶的刷题日记】732. 我的日程安排表 III

题目描述

这是 LeetCode 上的 「732. 我的日程安排表 III」 ，难度为 「困难」。

Tag : 「线段树（动态开点）」、「分块」、「线段树」

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

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

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

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

示例：

输入：["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); // 返回 3myCalendarThree.book(25, 55); // 返回 3

提示：

每个测试用例，调用 book 函数最多不超过次

线段树（动态开点）

和 731. 我的日程安排表 II 几乎完全一致，只需要将对「线段树」所维护的节点信息进行调整即可。

线段树维护的节点信息包括：

ls/rs: 分别代表当前节点的左右子节点在线段树数组 tr 中的下标；
add: 懒标记；
max: 为当前区间的最大值。

对于常规的线段树实现来说，都是一开始就调用 build 操作创建空树，而线段树一般以「满二叉树」的形式用数组存储，因此需要的空间，并且这些空间在起始 build 空树的时候已经锁死。

如果一道题仅仅是「值域很大」的离线题（提前知晓所有的询问），我们还能通过「离散化」来进行处理，将值域映射到一个小空间去，从而解决 MLE 问题。

但对于本题而言，由于「强制在线」的原因，我们无法进行「离散化」，同时值域大小达到级别，因此如果我们想要使用「线段树」进行求解，只能采取「动态开点」的方式进行。

动态开点的优势在于，不需要事前构造空树，而是在插入操作 add 和查询操作 query 时根据访问需要进行「开点」操作。由于我们不保证查询和插入都是连续的，因此对于父节点而言，我们不能通过 u << 1 和 u << 1 | 1 的固定方式进行访问，而要将节点的左右节点所在 tr 数组的下标进行存储，分别记为 ls 和 rs 属性。对于和则是代表子节点尚未被创建，当需要访问到它们，而又尚未创建的时候，则将其进行创建。

由于存在「懒标记」，线段树的插入和查询都是的，因此我们在单次操作的时候，最多会创建数量级为的点，因此空间复杂度为，而不是，而开点数的预估需不能仅仅根据来进行，还要对常熟进行分析，才能得到准确的点数上界。

动态开点相比于原始的线段树实现，本质仍是使用「满二叉树」的形式进行存储，只不过是按需创建区间，如果我们是按照连续段进行查询或插入，最坏情况下仍然会占到的空间，因此盲猜的常数在左右，保守一点可以直接估算到，因此我们可以估算点数为，其中和分别代表值域大小和查询次数。

当然一个比较实用的估点方式可以「尽可能的多开点数」，利用题目给定的空间上界和我们创建的自定义类（结构体）的大小，尽可能的多开（ Java 的 128M 可以开到以上）。

代码：

class MyCalendarThree {    class Node {        int ls, rs, add, max;    }    int N = (int)1e9, M = 4 * 400 * 20, cnt = 1;    Node[] tr = new Node[M];    void update(int u, int lc, int rc, int l, int r, int v) {        if (l <= lc && rc <= r) {            tr[u].add += v;            tr[u].max += v;            return ;        }        lazyCreate(u);        pushdown(u);        int mid = lc + rc >> 1;        if (l <= mid) update(tr[u].ls, lc, mid, l, r, v);        if (r > mid) update(tr[u].rs, mid + 1, rc, l, r, v);        pushup(u);    }    int query(int u, int lc, int rc, int l, int r) {        if (l <= lc && rc <= r) return tr[u].max;        lazyCreate(u);        pushdown(u);        int mid = lc + rc >> 1, ans = 0;        if (l <= mid) ans = query(tr[u].ls, lc, mid, l, r);        if (r > mid) ans = Math.max(ans, query(tr[u].rs, mid + 1, rc, l, r));        return ans;    }    void lazyCreate(int u) {        if (tr[u] == null) tr[u] = new Node();        if (tr[u].ls == 0) {            tr[u].ls = ++cnt;            tr[tr[u].ls] = new Node();        }        if (tr[u].rs == 0) {            tr[u].rs = ++cnt;            tr[tr[u].rs] = new Node();        }    }    void pushdown(int u) {        tr[tr[u].ls].add += tr[u].add; tr[tr[u].rs].add += tr[u].add;        tr[tr[u].ls].max += tr[u].add; tr[tr[u].rs].max += tr[u].add;        tr[u].add = 0;    }    void pushup(int u) {        tr[u].max = Math.max(tr[tr[u].ls].max, tr[tr[u].rs].max);    }    public int book(int start, int end) {        update(1, 1, N + 1, start + 1, end, 1);        return query(1, 1, N + 1, 1, N + 1);    }}

时间复杂度：令为值域大小，本题固定为，线段树的查询和增加复杂度均为
空间复杂度：令询问数量为，复杂度为

带懒标记的分块（TLE）

实际上，还存在另外一种十分值得学习的算法：分块。

但该做法被奇怪的测评机制卡掉，是给每个样例都定了执行用时吗