LeetCode每日一题(715. Range Module)

A Range Module is a module that tracks ranges of numbers. Design a data structure to track the ranges represented as half-open intervals and query about them.

A half-open interval [left, right) denotes all the real numbers x where left <= x < right.

Implement the RangeModule class:

RangeModule() Initializes the object of the data structure.
void addRange(int left, int right) Adds the half-open interval [left, right), tracking every real number in that interval. Adding an interval that partially overlaps with currently tracked numbers should add any numbers in the interval [left, right) that are not already tracked.
boolean queryRange(int left, int right) Returns true if every real number in the interval [left, right) is currently being tracked, and false otherwise.
void removeRange(int left, int right) Stops tracking every real number currently being tracked in the half-open interval [left, right).

Example 1:

Input:
[“RangeModule”, “addRange”, “removeRange”, “queryRange”, “queryRange”, “queryRange”]
[[], [10, 20], [14, 16], [10, 14], [13, 15], [16, 17]]
Output:
[null, null, null, true, false, true]

Explanation
RangeModule rangeModule = new RangeModule();
rangeModule.addRange(10, 20);
rangeModule.removeRange(14, 16);
rangeModule.queryRange(10, 14); // return True,(Every number in [10, 14) is being tracked)
rangeModule.queryRange(13, 15); // return False,(Numbers like 14, 14.03, 14.17 in [13, 15) are not being tracked)
rangeModule.queryRange(16, 17); // return True, (The number 16 in [16, 17) is still being tracked, despite the remove operation)

Constraints:

• 1 <= left < right <= 109
• At most 104 calls will be made to addRange, queryRange, and removeRange.

---

还是 Segment Tree, 这次自己实现了一个， 感觉从中受益不少。

这题没法预先知道 ranges 的值， 所以 coordinate compression 是没法用了， 但是 range 的取值范围又是 1 到 10^9, 所以如果直接用数组形式来表现 Segment Tree 的话, 估计栈会爆掉或者报内存超限。

所以我想着还是需要实现一个 lazy 的 Segment Tree, 只有在我们需要建立节点的时候才新建节点， 必要的时候还需要移除节点

几点重要的规则:

1. add_range 时， 如果 start <= node.start && end >= node.end, 即查询范围完全覆盖当前节点范围， 我们只需要将当前节点的 is_tracked 设为 true， 然后将当前节点的 left_child 和 right_child 都设为 None, 因为当前节点已经是 tracked 的了， 所以所有子节点也理所当然都是 tracked 的， 这样将子节点都设为 None 的操作可以使得我们后面的查询操作在遇到子节点为 None 的情况时可以以当前节点的 is_tracked 为结果直接返回， 这样可以减少节点数量和查询深度。另外需要注意的一点是， 当子节点都 add_range 之后， 我们需要根据子节点 is_tracked 的状态来更新当前节点的 is_tracked, 如果子节点都是 tracked 的， 那当前节点也自然是 tracked 的。这一点开始被我忽略了， 后来测试总是通不过， 费了半天劲才发现是这里的问题。

2. remove_range 时基本与 add_range 相同, 但是要注意一点， 更新当前节点 is_tracked 的时候不用考虑子节点的 is_tracked, 只要参数范围与当前节点的范围有交集， 那当前节点的 is_tracked 就一定是 false, 因为有任何一个子节点是 untracked 的， 那当前节点就是 untracked 的， 题目里对此有交代

3. 查询的时候， 如果 start >= node.end || end <= node.start, 需要返回 true, 这个 true 不是代表范围内的数都是 tracked 的， 而是告诉上层的调用函数， 最终结果与当前结果无关， 这样我们就可以在递归查询的时候使用 left_result && right_result 来作为当前层的查询结果。

---

use std::cell::RefCell;
use std::rc::Rc;

#[derive(Debug)]
struct Node {
    start: i32,
    end: i32,
    is_tracked: bool,
    left: Option<Rc<RefCell<Node>>>,
    right: Option<Rc<RefCell<Node>>>,
}

impl Node {
    fn new(start: i32, end: i32, is_tracked: bool) -> Self {
        Self {
            start,
            end,
            is_tracked,
            left: None,
            right: None,
        }
    }

    fn add(&mut self, start: i32, end: i32) {
        if start >= self.end || end <= self.start {
            return;
        }
        if start <= self.start && end >= self.end {
            self.is_tracked = true;
            self.left = None;
            self.right = None;
            return;
        }
        if let Some(left) = &mut self.left {
            left.borrow_mut().add(start, end);
        } else {
            let mut left = Node::new(self.start, (self.start + self.end) / 2, self.is_tracked);
            left.add(start, end);
            self.left = Some(Rc::new(RefCell::new(left)));
        }
        if let Some(right) = &mut self.right {
            right.borrow_mut().add(start, end);
        } else {
            let mut right = Node::new((self.start + self.end) / 2, self.end, self.is_tracked);
            right.add(start, end);
            self.right = Some(Rc::new(RefCell::new(right)));
        }
        self.is_tracked = self.left.as_ref().unwrap().borrow().is_tracked && self.right.as_ref().unwrap().borrow().is_tracked;
    }

    fn remove(&mut self, start: i32, end: i32) {
        if start >= self.end || end <= self.start {
            return;
        }
        if start <= self.start && end >= self.end {
            self.is_tracked = false;
            self.left = None;
            self.right = None;
            return;
        }
        if let Some(left) = &mut self.left {
            left.borrow_mut().remove(start, end);
        } else {
            let mut left = Node::new(self.start, (self.start + self.end) / 2, self.is_tracked);
            left.remove(start, end);
            self.left = Some(Rc::new(RefCell::new(left)));
        }
        if let Some(right) = &mut self.right {
            right.borrow_mut().remove(start, end);
        } else {
            let mut right = Node::new((self.start + self.end) / 2, self.end, self.is_tracked);
            right.remove(start, end);
            self.right = Some(Rc::new(RefCell::new(right)));
        }
        self.is_tracked = false;
    }

    fn query(&self, start: i32, end: i32) -> bool {
        if start >= self.end || end <= self.start {
            return true;
        }
        if start <= self.start && end >= self.end {
            return self.is_tracked;
        }
        let is_left_tracked = if let Some(left) = &self.left { left.borrow().query(start, end) } else { self.is_tracked };
        let is_right_tracked = if let Some(right) = &self.right { right.borrow().query(start, end) } else { self.is_tracked };
        is_left_tracked && is_right_tracked
    }
}

struct RangeModule {
    tree: Node,
}

/**
 * `&self` means the method takes an immutable reference.
 * If you need a mutable reference, change it to `&mut self` instead.
 */
impl RangeModule {
    fn new() -> Self {
        Self {
            tree: Node::new(1, 10i32.pow(9), false),
        }
    }

    fn add_range(&mut self, left: i32, right: i32) {
        self.tree.add(left, right);
    }

    fn query_range(&mut self, left: i32, right: i32) -> bool {
        self.tree.query(left, right)
    }

    fn remove_range(&mut self, left: i32, right: i32) {
        self.tree.remove(left, right);
    }
}