Assignment Segment Tree
(Src/DataStructure/SegmentTree/AssignmentSegmentTree.hpp)

View this file on GitHub
Last update: 2025-06-24 15:48:54+09:00
Include: #include "Src/DataStructure/SegmentTree/AssignmentSegmentTree.hpp"

概要

区間代入区間総積に特化したセグ木。特に、 $x^{p}$ が効率的に計算できない (二分累乗法を使って $\Theta(\log p)$ 回演算をする必要がある)場合は遅延セグ木よりもオーダーレベルで高速化する。

$x^{p}$ が効率的に計算できる場合(例: 加法 $xp$ なので、 $O(1)$ )でも、遅延セグ木じゃなくて普通のセグ木を使っている分定数倍が良い…気がする。

ライブラリの使い方

テンプレート引数要件、Monoid

template <Concept::Monoid Monoid>

普通のセグ木と同じものを使えば、コンパイルが通って問題なく使える。

Monoid::Element power(M::Element x, u64 p)というstaticメンバを定義すると、定数倍や場合によっては計算量が改善する実装に分岐する。中身は $x$ をoperationで $p$ 乗した値を返すようにする。

powerが無い場合は二分累乗法によって計算する。

雛形

struct M {
    using Element = ;
    static Element identity() {
    }
    static Element operation(Element l, Element r) {
    }
    static Element power(Element v, u64 exp) {
    }
};

コンストラクタ

AssignmentSegmentTree()  // (1)
AssignmentSegmentTree(usize n) // (2)
AssignmentSegmentTree(std::vector<V> dat) // (3)

(2) 長さ $n$ 、各要素が単位元列で初期化する。

(3) 列datで初期化する。VとはM::Elementのことである。Vにoperator==が定義されていると、若干定数倍が良い(多分)実装に分岐する。この分岐は、同じ値が多く連なっているような列は特に嬉しい。 ABC237 についてはコンストラクタの計算量が $O(N)$ に改善する。実際40msくらい早くなった。

計算量

(2): $O(N)$

(3): $O(N\log N)$

size

inline usize size() const noexcept

列の長さを返す。 $O(1)$

product

V product(usize l, usize r) const;

$l$ 番目から $r - 1$ 番目までの総積を返す。

計算量: $O(\log N)$

assign

V assign(usize l, usize r, V v)

$l$ 番目から $r - 1$ 番目の要素を $v$ にする。

計算量

assignを合計 $Q$ 回呼んだとすると

$O(Q\log N)$
加えてM::powerが $O(Q)$ 回呼ばれる。定義されていないときは、 M::operationが $O(Q\log N)$ 回呼ばれる。

参考

[Library Checker] Range Set Range Composite

Depends on

Verified with

Code

#pragma once

#include "../../Template/TypeAlias.hpp"
#include "../../Algebra/Monoid/MonoidConcept.hpp"
#include "./SegmentTree.hpp"

#include <cassert>
#include <vector>
#include <set>

namespace zawa {

namespace concepts {

template <class T, class U>
concept Powerable = requires {
    typename T::Element;
    { T::power(std::declval<typename T::Element>(), std::declval<U>()) }
        -> std::same_as<typename T::Element>;
};

template <class T>
concept EqualCompare = requires(T a, T b) {
    { a == b } -> std::convertible_to<bool>;
};

template <class T>
concept FastPowerableMonoid = Monoid<T> and Powerable<T, u64>;

} // namespace concepts

template <concepts::Monoid Monoid>
class AssignmentSegmentTree {
public:

    using VM = Monoid;

    using V = typename VM::Element;

    AssignmentSegmentTree() = default;

    explicit AssignmentSegmentTree(usize n) : m_seg{n}, m_dat(n, VM::identity()), m_ls{} {
        m_dat.shrink_to_fit();
        assert(n);
        m_ls.insert(0u);
        m_ls.insert(n);
    }

    explicit AssignmentSegmentTree(std::vector<V> dat) : m_seg{}, m_dat{dat}, m_ls{} {
        // dat: 区間の左端lにa_{l}^{r-l}, それ以外のiはidentity()にする -> セグ木にこれをのせる
        // m_dat: 区間の左端lにa_{l}, それ以外のiはidentity()にする
        m_dat.shrink_to_fit();
        if constexpr (concepts::EqualCompare<V>) {
            for (usize i{}, j{} ; i < m_dat.size() ; ) {
                while (j < dat.size() and dat[i] == dat[j]) j++;
                m_ls.insert(i);
                dat[i] = power(m_dat[i], j - i);
                for ( ; ++i < j ; dat[i] = m_dat[i] = VM::identity()) ;
            }
        }
        else {
            for (usize i{} ; i < m_dat.size() ; i++) m_ls.insert(i);
        }
        m_ls.insert(dat.size());
        m_seg = decltype(m_seg){dat};
    }

    [[nodiscard]] inline usize size() const noexcept {
        return m_dat.size();
    }

    [[nodiscard]] V product(usize l, usize r) const {
        assert(l <= r and r <= size());
        if (l == r) return VM::identity();
        const auto second_l = m_ls.upper_bound(l);
        const auto first_l = std::prev(second_l);
        if (second_l != m_ls.end() and r <= *second_l) { // 一つの区間に含まれている
            return power(m_dat[*first_l], r - l);
        }
        const auto last_l = std::prev(m_ls.upper_bound(r));
        V res = VM::operation(
                power(m_dat[*first_l], *second_l - l),
                m_seg.product(*second_l, *last_l)
                );
        if (r == *last_l) return res;
        return VM::operation(res, power(m_dat[*last_l], r - *last_l));
    }

    void assign(usize l, usize r, V v) {
        assert(l <= r and r <= m_dat.size());
        if (l == r) return;
        // assert(*it_l < n);
        auto it_l = std::prev(m_ls.upper_bound(l)), it_r = std::prev(m_ls.upper_bound(r)); 
        if (*it_l < l) m_seg.assign(*it_l, power(m_dat[*it_l], l - *it_l));
        m_seg.assign(l, power(v, r - l));
        if (*it_r < r and r < m_dat.size()) {
            m_dat[r] = m_dat[*it_r];
            m_seg.assign(r, power(m_dat[r], *std::next(it_r) - r));
            m_ls.insert(r);
        }
        m_dat[l] = v;
        for (it_l++ ; *it_l < r ; it_l = m_ls.erase(it_l)) {
            m_seg.assign(*it_l, VM::identity());
            m_dat[*it_l] = VM::identity();
        }
        m_ls.insert(l);
    }

private:

    SegmentTree<VM> m_seg;

    std::vector<V> m_dat;

    std::set<usize> m_ls; 

    static V power(V v, u32 p) requires concepts::FastPowerableMonoid<VM> {
        return VM::power(v, p);
    }

    static V power(V v, u32 p) {
        V res{VM::identity()};
        while (p) {
            if (p & 1) res = VM::operation(res, v);
            v = VM::operation(v, v);
            p >>= 1; 
        }
        return res;
    }
};

} // namespace zawa

#line 2 "Src/DataStructure/SegmentTree/AssignmentSegmentTree.hpp"

#line 2 "Src/Template/TypeAlias.hpp"

#include <cstdint>
#include <cstddef>

namespace zawa {

using i16 = std::int16_t;
using i32 = std::int32_t;
using i64 = std::int64_t;
using i128 = __int128_t;

using u8 = std::uint8_t;
using u16 = std::uint16_t;
using u32 = std::uint32_t;
using u64 = std::uint64_t;

using usize = std::size_t;

} // namespace zawa
#line 2 "Src/Algebra/Monoid/MonoidConcept.hpp"

#line 2 "Src/Algebra/Semigroup/SemigroupConcept.hpp"

#include <concepts>

namespace zawa {

namespace concepts {

template <class T>
concept Semigroup = requires {
    typename T::Element;
    { T::operation(std::declval<typename T::Element>(), std::declval<typename T::Element>()) } -> std::same_as<typename T::Element>;
};

} // namespace concepts

} // namespace zawa
#line 4 "Src/Algebra/Monoid/MonoidConcept.hpp"

#line 6 "Src/Algebra/Monoid/MonoidConcept.hpp"

namespace zawa {

namespace concepts {

template <class T>
concept Identitiable = requires {
    typename T::Element;
    { T::identity() } -> std::same_as<typename T::Element>;
};

template <class T>
concept Monoid = Semigroup<T> and Identitiable<T>;

} // namespace

} // namespace zawa
#line 2 "Src/DataStructure/SegmentTree/SegmentTree.hpp"

#line 5 "Src/DataStructure/SegmentTree/SegmentTree.hpp"

#include <vector>
#include <cassert>
#include <functional>
#include <type_traits>
#include <ostream>

namespace zawa {

template <concepts::Monoid Monoid>
class SegmentTree {
public:

    using VM = Monoid;

    using V = typename VM::Element;

    using OM = Monoid;

    using O = typename OM::Element;

    SegmentTree() = default;

    explicit SegmentTree(usize n) : m_n{ n }, m_dat(n << 1, VM::identity()) {}

    explicit SegmentTree(const std::vector<V>& dat) : m_n{ dat.size() }, m_dat(dat.size() << 1, VM::identity()) {
        for (usize i{} ; i < m_n ; i++) {
            m_dat[i + m_n] = dat[i];
        }
        for (usize i{m_n} ; i-- ; i) {
            m_dat[i] = VM::operation(m_dat[left(i)], m_dat[right(i)]);
        }
    }

    [[nodiscard]] inline usize size() const noexcept {
        return m_n;
    }

    [[nodiscard]] V get(usize i) const {
        assert(i < size());
        return m_dat[i + m_n];
    }

    [[nodiscard]] V operator[](usize i) const {
        assert(i < size());
        return m_dat[i + m_n];
    }

    void operation(usize i, const O& value) {
        assert(i < size());
        i += size();
        m_dat[i] = OM::operation(m_dat[i], value);
        while (i = parent(i), i) {
            m_dat[i] = VM::operation(m_dat[left(i)], m_dat[right(i)]);
        }
    }

    void assign(usize i, const V& value) {
        assert(i < size());
        i += size();
        m_dat[i] = value;
        while (i = parent(i), i) {
            m_dat[i] = VM::operation(m_dat[left(i)], m_dat[right(i)]);
        }
    }

    [[nodiscard]] V product(u32 l, u32 r) const {
        assert(l <= r and r <= size());
        V L{ VM::identity() }, R{ VM::identity() };
        for (l += size(), r += size() ; l < r ; l = parent(l), r = parent(r)) {
            if (l & 1) {
                L = VM::operation(L, m_dat[l++]);
            }
            if (r & 1) {
                R = VM::operation(m_dat[--r], R);
            }
        }
        return VM::operation(L, R);
    }

    template <class Function>
    [[nodiscard]] usize maxRight(usize l, const Function& f) {
        assert(l < size());
        static_assert(std::is_convertible_v<decltype(f), std::function<bool(V)>>, "maxRight's argument f must be function bool(T)");
        assert(f(VM::identity()));
        usize res{l}, width{1};
        V prod{ VM::identity() };
        // 現在の見ている頂点の幅をwidthで持つ
        // 境界がある頂点を含む部分木の根を探す
        // (折り返す時は必要以上の幅を持つ根になるが、widthを持っているのでオーバーしない)
        for (l += size() ; res + width <= size() ; l = parent(l), width <<= 1) if (l & 1) {
            if (not f(VM::operation(prod, m_dat[l]))) break; 
            res += width;
            prod = VM::operation(prod, m_dat[l++]);
        }
        // 根から下って、境界を発見する
        while (l = left(l), width >>= 1) {
            if (res + width <= size() and f(VM::operation(prod, m_dat[l]))) {
                res += width;
                prod = VM::operation(prod, m_dat[l++]);
            } 
        }
        return res;
    }

    template <class Function>
    [[nodiscard]] usize minLeft(usize r, const Function& f) const {
        assert(r <= size());
        static_assert(std::is_convertible_v<decltype(f), std::function<bool(V)>>, "minLeft's argument f must be function bool(T)");
        assert(f(VM::identity()));
        usize res{r}, width{1};
        V prod{ VM::identity() };
        for (r += size() ; res >= width ; r = parent(r), width <<= 1) if (r & 1) {
            if (not f(VM::operation(m_dat[r - 1], prod))) break;
            res -= width;
            prod = VM::operation(prod, m_dat[--r]);
        }
        while (r = left(r), width >>= 1) {
            if (res >= width and f(VM::operation(m_dat[r - 1], prod))) {
                res -= width;
                prod = VM::operation(m_dat[--r], prod);
            }
        }
        return res;
    }

    friend std::ostream& operator<<(std::ostream& os, const SegmentTree& st) {
        for (usize i{1} ; i < 2 * st.size() ; i++) {
            os << st.m_dat[i] << (i + 1 == 2 * st.size() ? "" : " ");
        }
        return os;
    }

private:

    constexpr u32 left(u32 v) const {
        return v << 1;
    }

    constexpr u32 right(u32 v) const {
        return v << 1 | 1;
    }

    constexpr u32 parent(u32 v) const {
        return v >> 1;
    }

    usize m_n;

    std::vector<V> m_dat;
};

} // namespace zawa
#line 6 "Src/DataStructure/SegmentTree/AssignmentSegmentTree.hpp"

#line 9 "Src/DataStructure/SegmentTree/AssignmentSegmentTree.hpp"
#include <set>

namespace zawa {

namespace concepts {

template <class T, class U>
concept Powerable = requires {
    typename T::Element;
    { T::power(std::declval<typename T::Element>(), std::declval<U>()) }
        -> std::same_as<typename T::Element>;
};

template <class T>
concept EqualCompare = requires(T a, T b) {
    { a == b } -> std::convertible_to<bool>;
};

template <class T>
concept FastPowerableMonoid = Monoid<T> and Powerable<T, u64>;

} // namespace concepts

template <concepts::Monoid Monoid>
class AssignmentSegmentTree {
public:

    using VM = Monoid;

    using V = typename VM::Element;

    AssignmentSegmentTree() = default;

    explicit AssignmentSegmentTree(usize n) : m_seg{n}, m_dat(n, VM::identity()), m_ls{} {
        m_dat.shrink_to_fit();
        assert(n);
        m_ls.insert(0u);
        m_ls.insert(n);
    }

    explicit AssignmentSegmentTree(std::vector<V> dat) : m_seg{}, m_dat{dat}, m_ls{} {
        // dat: 区間の左端lにa_{l}^{r-l}, それ以外のiはidentity()にする -> セグ木にこれをのせる
        // m_dat: 区間の左端lにa_{l}, それ以外のiはidentity()にする
        m_dat.shrink_to_fit();
        if constexpr (concepts::EqualCompare<V>) {
            for (usize i{}, j{} ; i < m_dat.size() ; ) {
                while (j < dat.size() and dat[i] == dat[j]) j++;
                m_ls.insert(i);
                dat[i] = power(m_dat[i], j - i);
                for ( ; ++i < j ; dat[i] = m_dat[i] = VM::identity()) ;
            }
        }
        else {
            for (usize i{} ; i < m_dat.size() ; i++) m_ls.insert(i);
        }
        m_ls.insert(dat.size());
        m_seg = decltype(m_seg){dat};
    }

    [[nodiscard]] inline usize size() const noexcept {
        return m_dat.size();
    }

    [[nodiscard]] V product(usize l, usize r) const {
        assert(l <= r and r <= size());
        if (l == r) return VM::identity();
        const auto second_l = m_ls.upper_bound(l);
        const auto first_l = std::prev(second_l);
        if (second_l != m_ls.end() and r <= *second_l) { // 一つの区間に含まれている
            return power(m_dat[*first_l], r - l);
        }
        const auto last_l = std::prev(m_ls.upper_bound(r));
        V res = VM::operation(
                power(m_dat[*first_l], *second_l - l),
                m_seg.product(*second_l, *last_l)
                );
        if (r == *last_l) return res;
        return VM::operation(res, power(m_dat[*last_l], r - *last_l));
    }

    void assign(usize l, usize r, V v) {
        assert(l <= r and r <= m_dat.size());
        if (l == r) return;
        // assert(*it_l < n);
        auto it_l = std::prev(m_ls.upper_bound(l)), it_r = std::prev(m_ls.upper_bound(r)); 
        if (*it_l < l) m_seg.assign(*it_l, power(m_dat[*it_l], l - *it_l));
        m_seg.assign(l, power(v, r - l));
        if (*it_r < r and r < m_dat.size()) {
            m_dat[r] = m_dat[*it_r];
            m_seg.assign(r, power(m_dat[r], *std::next(it_r) - r));
            m_ls.insert(r);
        }
        m_dat[l] = v;
        for (it_l++ ; *it_l < r ; it_l = m_ls.erase(it_l)) {
            m_seg.assign(*it_l, VM::identity());
            m_dat[*it_l] = VM::identity();
        }
        m_ls.insert(l);
    }

private:

    SegmentTree<VM> m_seg;

    std::vector<V> m_dat;

    std::set<usize> m_ls; 

    static V power(V v, u32 p) requires concepts::FastPowerableMonoid<VM> {
        return VM::power(v, p);
    }

    static V power(V v, u32 p) {
        V res{VM::identity()};
        while (p) {
            if (p & 1) res = VM::operation(res, v);
            v = VM::operation(v, v);
            p >>= 1; 
        }
        return res;
    }
};

} // namespace zawa

Assignment Segment Tree (Src/DataStructure/SegmentTree/AssignmentSegmentTree.hpp)

概要