715. Range Module

Approach 1: Segment Tree

• Time:
  • Constructor: $O(1)$
  • addRange(left: int, right: int): $O(\log 10^9)$
  • queryRange(left: int, right: int): $O(\log 10^9)$
  • removeRange(left: int, right: int): $O(\log 10^9)$
• Space: $O(n)$

C++

struct SegmentTreeNode {
  int lo;
  int hi;
  bool tracked = false;
  std::unique_ptr<SegmentTreeNode> left;
  std::unique_ptr<SegmentTreeNode> right;
  SegmentTreeNode(int lo, int hi, bool tracked,
                  std::unique_ptr<SegmentTreeNode> left = nullptr,
                  std::unique_ptr<SegmentTreeNode> right = nullptr)
      : lo(lo),
        hi(hi),
        tracked(tracked),
        left(std::move(left)),
        right(std::move(right)) {}
};

class SegmentTree {
 public:
  explicit SegmentTree() : root(make_unique<SegmentTreeNode>(0, 1e9, false)) {}

  void addRange(int i, int j) {
    update(root, i, j, true);
  }

  bool queryRange(int i, int j) {
    return query(root, i, j);
  }

  void removeRange(int i, int j) {
    update(root, i, j, false);
  }

 private:
  std::unique_ptr<SegmentTreeNode> root;

  void update(std::unique_ptr<SegmentTreeNode>& root, int i, int j,
              bool tracked) {
    if (root->lo == i && root->hi == j) {
      root->tracked = tracked;
      root->left = nullptr;
      root->right = nullptr;
      return;
    }
    const int mid = root->lo + (root->hi - root->lo) / 2;
    if (root->left == nullptr) {
      root->left = make_unique<SegmentTreeNode>(root->lo, mid, root->tracked);
      root->right =
          make_unique<SegmentTreeNode>(mid + 1, root->hi, root->tracked);
    }
    if (j <= mid)
      update(root->left, i, j, tracked);
    else if (i > mid)
      update(root->right, i, j, tracked);
    else {
      update(root->left, i, mid, tracked);
      update(root->right, mid + 1, j, tracked);
    }
    root->tracked = merge(root->left->tracked, root->right->tracked);
  }

  bool query(std::unique_ptr<SegmentTreeNode>& root, int i, int j) const {
    if (root->left == nullptr)
      return root->tracked;
    if (root->lo == i && root->hi == j)
      return root->tracked;
    const int mid = root->lo + (root->hi - root->lo) / 2;
    if (j <= mid)
      return query(root->left, i, j);
    if (i > mid)
      return query(root->right, i, j);
    return merge(query(root->left, i, mid), query(root->right, mid + 1, j));
  }

  bool merge(bool left, bool right) const {
    return left && right;
  }
};

class RangeModule {
 public:
  void addRange(int left, int right) {
    tree.addRange(left, right - 1);
  }

  bool queryRange(int left, int right) {
    return tree.queryRange(left, right - 1);
  }

  void removeRange(int left, int right) {
    tree.removeRange(left, right - 1);
  }

 private:
  SegmentTree tree;
};

Approach 2: Ordered Map

• Time:
  • Constructor: $O(1)$
  • addRange(left: int, right: int): $O(k\log n)$
  • queryRange(left: int, right: int): $O(\log n)$
  • removeRange(left: int, right: int): $O(k\log n)$, where k is # of overlapping ranges
• Space: $O(n)$

C++Java

class RangeModule {
 public:
  void addRange(int left, int right) {
    const auto [l, r] = getOverlapRanges(left, right);
    if (l == r) {            // There's no overlap.
      ranges[left] = right;  // Add a new range.
      return;
    }

    auto last = r;
    const int newLeft = min(l->first, left);
    const int newRight = max((--last)->second, right);
    ranges.erase(l, r);
    ranges[newLeft] = newRight;  // Add a new range.
  }

  bool queryRange(int left, int right) {
    auto it = ranges.upper_bound(left);
    return it != ranges.begin() && (--it)->second >= right;
  }

  void removeRange(int left, int right) {
    const auto [l, r] = getOverlapRanges(left, right);
    if (l == r)  // There's no overlap.
      return;

    auto last = r;
    const int newLeft = min(l->first, left);
    const int newRight = max((--last)->second, right);
    ranges.erase(l, r);
    // Add new ranges if needed.
    if (newLeft < left)
      ranges[newLeft] = left;
    if (right < newRight)
      ranges[right] = newRight;
  }

 private:
  using IT = map<int, int>::iterator;
  map<int, int> ranges;

  pair<IT, IT> getOverlapRanges(int left, int right) {
    // Point to the first element with `second` >= `left`.
    IT l = ranges.upper_bound(left);
    // Point to the first element with `first` > `right`.
    IT r = ranges.upper_bound(right);
    if (l != ranges.begin() && (--l)->second < left)
      ++l;
    return {l, r};
  }
};

class RangeModule {
  public void addRange(int left, int right) {
    Integer l = ranges.floorKey(left);
    Integer r = ranges.floorKey(right);

    if (l != null && ranges.get(l) >= left)
      left = l;
    if (r != null && ranges.get(r) > right)
      right = ranges.get(r);

    ranges.subMap(left, right).clear();
    ranges.put(left, right);
  }

  public boolean queryRange(int left, int right) {
    Integer l = ranges.floorKey(left);
    return l == null ? false : ranges.get(l) >= right;
  }

  public void removeRange(int left, int right) {
    Integer l = ranges.floorKey(left);
    Integer r = ranges.floorKey(right);

    if (r != null && ranges.get(r) > right)
      ranges.put(right, ranges.get(r));
    if (l != null && ranges.get(l) > left)
      ranges.put(l, left);

    ranges.subMap(left, right).clear();
  }

  private TreeMap<Integer, Integer> ranges = new TreeMap<>();
}

Approach 3: Heuristic

• Time:
  • Constructor: $O(1)$
  • addRange(left: int, right: int): $O(n)$
  • queryRange(left: int, right: int): $O(\log n)$
  • removeRange(left: int, right: int): $O(n)$
• Space: $O(n)$

Python

class RangeModule:
  def __init__(self):
    self.A = []

  def addRange(self, left: int, right: int) -> None:
    i = bisect_left(self.A, left)
    j = bisect_right(self.A, right)
    self.A[i:j] = [left] * (i % 2 == 0) + [right] * (j % 2 == 0)

  def queryRange(self, left: int, right: int) -> bool:
    i = bisect_right(self.A, left)
    j = bisect_left(self.A, right)
    return i == j and i % 2 == 1

  def removeRange(self, left: int, right: int) -> None:
    i = bisect_left(self.A, left)
    j = bisect_right(self.A, right)
    self.A[i:j] = [left] * (i % 2 == 1) + [right] * (j % 2 == 1)