Segment Tree
(data-structure/segtree/segment_tree.hpp)

• View this file on GitHub
• Last update: 2024-01-07 20:09:47+09:00
• Include: #include "data-structure/segtree/segment_tree.hpp"

Description

セグメント木は，モノイド $(T, \cdot, e)$ の列に対する一点更新と区間取得を提供するデータ構造である．

空間計算量: $O(n)$

Operations

• SegmentTree(int n)
  • サイズnで要素がすべて単位元 $e$ のセグメント木を構築する
  • 時間計算量: $O(n)$
• SegmentTree(vector<T> v)
  • vの要素からサイズn = v.size()のセグメント木を構築する
  • 時間計算量: $O(n)$
• T operator[](int k)
  • $k$ 番目の要素を返す
  • 時間計算量: $O(1)$
• void update(int k, T x)
  • $k$ 番目の要素を $x$ に更新する
  • 時間計算量: $O(\log n)$
• T fold(int l, int r)
  • 区間 $[l, r)$ の値を fold する
  • 時間計算量: $O(\log n)$
• int find_first(int l, F cond)
  • fold(l, r) が条件 cond を満たすような最小の $r (> l)$ 返す．列の単調性を仮定する．そのような $r$ が存在しない場合は -1 を返す
  • 時間計算量: $O(\log n)$
• int find_last(int r, F cond)
  • fold(l, r) が条件 cond を満たすような最大の $l (< r)$ 返す．列の単調性を仮定する．そのような $l$ が存在しない場合は -1 を返す
  • 時間計算量: $O(\log n)$

Reference

• セグメント木について
• セグメント木をソラで書きたいあなたに
• 競技プログラマのための抽象セグメント木実装のすすめ
• Segment Tree

Required by

• 2D Segment Tree (data-structure/segtree/segment_tree_2d.hpp)
• Sortable Segment Tree (data-structure/segtree/sortable_segment_tree.hpp)
• Manhattan Minimum Spanning Tree (graph/manhattan_mst.hpp)

Verified with

• test/yosupo/manhattanmst.test.cpp
• test/yosupo/point_add_rectangle_sum.2d_segtree.test.cpp
• test/yosupo/point_set_range_composite.test.cpp
• test/yosupo/point_set_range_sort_range_composite.test.cpp
• test/yosupo/vertex_add_subtree_sum.euler_tour.test.cpp
• test/yosupo/vertex_set_path_composite.test.cpp

Code

#pragma once
#include <algorithm>
#include <bit>
#include <vector>

template <typename M>
class SegmentTree {
    using T = M::T;

   public:
    SegmentTree() = default;
    explicit SegmentTree(int n) : SegmentTree(std::vector<T>(n, M::id())) {}
    explicit SegmentTree(const std::vector<T>& v)
        : size(std::bit_ceil(v.size())), node(2 * size, M::id()) {
        std::ranges::copy(v, node.begin() + size);
        for (int i = size - 1; i > 0; --i) {
            node[i] = M::op(node[2 * i], node[2 * i + 1]);
        }
    }

    T operator[](int k) const { return node[k + size]; }

    void update(int k, const T& x) {
        k += size;
        node[k] = x;
        while (k >>= 1) node[k] = M::op(node[2 * k], node[2 * k + 1]);
    }

    T fold(int l, int r) const {
        T vl = M::id(), vr = M::id();
        for (l += size, r += size; l < r; l >>= 1, r >>= 1) {
            if (l & 1) vl = M::op(vl, node[l++]);
            if (r & 1) vr = M::op(node[--r], vr);
        }
        return M::op(vl, vr);
    }

    template <typename F>
    int find_first(int l, F cond) const {
        T v = M::id();
        for (l += size; l > 0; l >>= 1) {
            if (l & 1) {
                T nv = M::op(v, node[l]);
                if (cond(nv)) {
                    while (l < size) {
                        nv = M::op(v, node[2 * l]);
                        if (cond(nv)) {
                            l = 2 * l;
                        } else {
                            v = nv, l = 2 * l + 1;
                        }
                    }
                    return l + 1 - size;
                }
                v = nv;
                ++l;
            }
        }
        return -1;
    }

    template <typename F>
    int find_last(int r, F cond) const {
        T v = M::id();
        for (r += size; r > 0; r >>= 1) {
            if (r & 1) {
                --r;
                T nv = M::op(node[r], v);
                if (cond(nv)) {
                    while (r < size) {
                        nv = M::op(node[2 * r + 1], v);
                        if (cond(nv)) {
                            r = 2 * r + 1;
                        } else {
                            v = nv, r = 2 * r;
                        }
                    }
                    return r - size;
                }
                v = nv;
            }
        }
        return -1;
    }

   private:
    int size;
    std::vector<T> node;
};

#line 2 "data-structure/segtree/segment_tree.hpp"
#include <algorithm>
#include <bit>
#include <vector>

template <typename M>
class SegmentTree {
    using T = M::T;

   public:
    SegmentTree() = default;
    explicit SegmentTree(int n) : SegmentTree(std::vector<T>(n, M::id())) {}
    explicit SegmentTree(const std::vector<T>& v)
        : size(std::bit_ceil(v.size())), node(2 * size, M::id()) {
        std::ranges::copy(v, node.begin() + size);
        for (int i = size - 1; i > 0; --i) {
            node[i] = M::op(node[2 * i], node[2 * i + 1]);
        }
    }

    T operator[](int k) const { return node[k + size]; }

    void update(int k, const T& x) {
        k += size;
        node[k] = x;
        while (k >>= 1) node[k] = M::op(node[2 * k], node[2 * k + 1]);
    }

    T fold(int l, int r) const {
        T vl = M::id(), vr = M::id();
        for (l += size, r += size; l < r; l >>= 1, r >>= 1) {
            if (l & 1) vl = M::op(vl, node[l++]);
            if (r & 1) vr = M::op(node[--r], vr);
        }
        return M::op(vl, vr);
    }

    template <typename F>
    int find_first(int l, F cond) const {
        T v = M::id();
        for (l += size; l > 0; l >>= 1) {
            if (l & 1) {
                T nv = M::op(v, node[l]);
                if (cond(nv)) {
                    while (l < size) {
                        nv = M::op(v, node[2 * l]);
                        if (cond(nv)) {
                            l = 2 * l;
                        } else {
                            v = nv, l = 2 * l + 1;
                        }
                    }
                    return l + 1 - size;
                }
                v = nv;
                ++l;
            }
        }
        return -1;
    }

    template <typename F>
    int find_last(int r, F cond) const {
        T v = M::id();
        for (r += size; r > 0; r >>= 1) {
            if (r & 1) {
                --r;
                T nv = M::op(node[r], v);
                if (cond(nv)) {
                    while (r < size) {
                        nv = M::op(node[2 * r + 1], v);
                        if (cond(nv)) {
                            r = 2 * r + 1;
                        } else {
                            v = nv, r = 2 * r;
                        }
                    }
                    return r - size;
                }
                v = nv;
            }
        }
        return -1;
    }

   private:
    int size;
    std::vector<T> node;
};

Back to top page