732. My Calendar III

这题也是暴力解是Sweep line + TreeMap
每次把booking 拆成两个events直接丢进去。然后遍历一遍treeMap得出k就好了
时间复杂度O(N^2)
731的第一种做法在这里不是很合适了，因为要建最多k个二维数组，所以那个做法这里就不写了。
另外一种做法就是Augmented BST. 这题也是很直接吧。731里面TreeNode里面有一个boolean量叫overlap，这里面就设一个 int 变量 overlap就好了。每次update的时候traverse down每条路更新节点的overlap并更新global最大值。
先看暴力解

class MyCalendarThree {
    TreeMap treeMap;

    public MyCalendarThree() {
        treeMap = new TreeMap<>();
    }
    
    public int book(int start, int end) {
        treeMap.put(start, treeMap.getOrDefault(start, 0) + 1);
        treeMap.put(end, treeMap.getOrDefault(end, 0) - 1);
        int sum = 0;
        int ans = 0;
        for (int d : treeMap.values()) {
            sum += d;
            ans = Math.max(ans, sum);
        }
        return ans;
    }
}

下面看一下Augmented BST的写法，感觉也挺好。
长是长了点，不过都是套路。
我出了一个bug,就是在进入下一层的时候就这句，
如果start == b的话，那说明start在root.start 里面 ， 这时root.start比start可能要大。 所以这里应该比较的是start 和root.start，而不是start和b这种不伦不类的比较

if (start <= root.start) { 
        //我在这里出了一个bug，我把条件写成了 start <= b wrong
            root.left = insert(root.left, a, b, rep);
        } else {
            root.left = insert(root.left, a, b, root.count);
        }

class MyCalendarThree {
    TreeNode root;
    int globalMax;
    public MyCalendarThree() {
        root = null;
        globalMax = 0;
    }
    
    public int book(int start, int end) {
        root = insert(root, start, end, 1);
        return globalMax;
    }
    private TreeNode insert(TreeNode root, int start, int end, int rep) {
        if (start >= end) {
            
            return root;
        }
        if (root == null) {
            globalMax = Math.max(rep, globalMax);
            //globalMax = Math.max(globalMax, root.count);
            return new TreeNode(start, end, rep);
        } 
       
        if (root.end <= start) {
            root.right = insert(root.right, start, end, rep);
            globalMax = Math.max(globalMax, root.count);
            return root;
        }
        if (root.start >= end) {
            root.left = insert(root.left, start, end, rep);
            globalMax = Math.max(globalMax, root.count);
            return root;
        }
        int a = Math.min(start, root.start);
        int b = Math.max(start, root.start);
        int c = Math.min(end, root.end);
        int d = Math.max(end, root.end);
        if (start <= root.start) { 
        //我在这里出了一个bug，我把条件写成了 start <= b wrong
            root.left = insert(root.left, a, b, rep);
        } else {
            root.left = insert(root.left, a, b, root.count);
        }
        if (end >= root.end) {
            root.right = insert(root.right, c, d, rep);
        } else {
            root.right = insert(root.right, c, d, root.count);
        }
        
        root.start = b;
        root.end = c;
        
        if(b < c) root.count += rep;
        globalMax = Math.max(globalMax, root.count);
        return root;
    }
}

class TreeNode{
    int start, end, count;
    TreeNode left, right;
    TreeNode(int start, int end, int count) {
        this.start = start;
        this.end = end;
        this.count = count;
    }
}

Segment Tree 的解法，我看讨论区大家都用Segment tree + Lazy propagation, 是时候学一下这个技巧了。 等我很快补上这个解法。