proconlib
This documentation is automatically generated by online-judge-tools/verification-helper
container/lazy_segment_tree.cpp
- View this file on GitHub
- Last update: 2022-01-07 21:48:21+09:00
Depends on
- internal/enable_avx2.cpp
- utility/bit_width.cpp
- utility/ceil_log2.cpp
- utility/countl_zero.cpp
- utility/countr_zero.cpp
- utility/int_alias.cpp
- utility/rep.cpp
- utility/revrep.cpp
Verified with
Code
#pragma once
#include <cassert>
#include <vector>
#include "../utility/ceil_log2.cpp"
#include "../utility/countr_zero.cpp"
#include "../utility/rep.cpp"
#include "../utility/revrep.cpp"
template <class A> class LazySegmentTree {
using M = typename A::Monoid;
using E = typename A::Effector;
using T = typename M::Type;
using U = typename E::Type;
int internal_size, logn, seg_size;
std::vector<T> data;
std::vector<U> lazy;
void fetch(const int k) { data[k] = M::operation(data[2 * k], data[2 * k + 1]); }
void apply(const int k, const U& e) {
data[k] = A::operation(data[k], e);
if (k < seg_size) lazy[k] = E::operation(lazy[k], e);
}
void flush(const int k) {
apply(2 * k, lazy[k]);
apply(2 * k + 1, lazy[k]);
lazy[k] = E::identity();
}
void push(const int k) {
for (const int d : revrep(countr_zero(k) + 1, logn + 1)) flush(k >> d);
}
void pull(int k) {
for (k >>= countr_zero(k); k > 1;) fetch(k >>= 1);
}
public:
explicit LazySegmentTree(const int size = 0, const T& value = M::identity())
: LazySegmentTree(std::vector<T>(size, value)) {}
explicit LazySegmentTree(const std::vector<T>& vec) : internal_size(vec.size()) {
logn = ceil_log2(internal_size);
seg_size = 1 << logn;
data = std::vector<T>(2 * seg_size, M::identity());
lazy = std::vector<U>(seg_size, E::identity());
for (const int i : rep(internal_size)) data[seg_size + i] = vec[i];
for (const int i : revrep(1, seg_size)) fetch(i);
}
int size() const { return internal_size; }
void assign(int i, const T& value) {
assert(0 <= i and i < internal_size);
i += seg_size;
for (const int d : revrep(1, logn + 1)) flush(i >> d);
data[i] = value;
for (const int d : rep(1, logn + 1)) fetch(i >> d);
}
void operate(int l, int r, const U& e) {
assert(0 <= l and l <= r and r <= internal_size);
l += seg_size;
r += seg_size;
push(l);
push(r);
for (int l0 = l, r0 = r; l0 < r0; l0 >>= 1, r0 >>= 1) {
if (l0 & 1) apply(l0++, e);
if (r0 & 1) apply(--r0, e);
}
pull(l);
pull(r);
}
T fold() const { return data[1]; }
T fold(int l, int r) {
assert(0 <= l and l <= r and r <= internal_size);
l += seg_size;
r += seg_size;
push(l);
push(r);
T ret_l = M::identity(), ret_r = M::identity();
while (l < r) {
if (l & 1) ret_l = M::operation(ret_l, data[l++]);
if (r & 1) ret_r = M::operation(data[--r], ret_r);
l >>= 1;
r >>= 1;
}
return M::operation(ret_l, ret_r);
}
template <class F> int max_right(int l, const F& f) {
assert(0 <= l and l <= internal_size);
assert(f(M::identity()));
if (l == internal_size) return internal_size;
l += seg_size;
for (const int d : revrep(1, logn + 1)) flush(l >> d);
T sum = M::identity();
do {
while (!(l & 1)) l >>= 1;
if (!f(M::operation(sum, data[l]))) {
while (l < seg_size) {
flush(l);
l = 2 * l;
if (f(M::operation(sum, data[l]))) sum = M::operation(sum, data[l++]);
}
return l - seg_size;
}
sum = M::operation(sum, data[l++]);
} while ((l & -l) != l);
return internal_size;
}
template <class F> int min_left(int r, const F& f) {
assert(0 <= r and r <= internal_size);
assert(f(M::identity()));
if (r == 0) return 0;
r += seg_size;
for (const int d : revrep(1, logn + 1)) flush((r - 1) >> d);
T sum = M::identity();
do {
r -= 1;
while (r > 1 and (r & 1)) r >>= 1;
if (!f(M::operation(data[r], sum))) {
while (r < seg_size) {
flush(r);
r = 2 * r + 1;
if (f(M::operation(data[r], sum))) sum = M::operation(data[r--], sum);
}
return r + 1 - seg_size;
}
sum = M::operation(data[r], sum);
} while ((r & -r) != r);
return 0;
}
};#line 2 "container/lazy_segment_tree.cpp"
#include <cassert>
#include <vector>
#line 2 "internal/enable_avx2.cpp"
#ifdef ENABLE_AVX2
#define TARGET_AVX2 __attribute__((target("avx2")))
#else
#define TARGET_AVX2
#endif
#line 2 "utility/int_alias.cpp"
#include <cstdint>
using i32 = std::int32_t;
using u32 = std::uint32_t;
using i64 = std::int64_t;
using u64 = std::uint64_t;
using i128 = __int128_t;
using u128 = __uint128_t;
#line 4 "utility/countl_zero.cpp"
TARGET_AVX2 constexpr int countl_zero(u64 x) {
#ifdef __GNUC__
return x == 0 ? 64 : __builtin_clzll(x);
#else
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
x |= x >> 32;
return 64 - countr_zero(~x);
#endif
}
#line 4 "utility/bit_width.cpp"
TARGET_AVX2 constexpr int bit_width(const u64 x) { return 64 - countl_zero(x); }
#line 5 "utility/ceil_log2.cpp"
TARGET_AVX2 constexpr int ceil_log2(const u64 x) {
#ifdef __GNUC__
return x == 0 ? 0 : bit_width(x - 1);
#else
int e = 0;
while (((u64)1 << e) < x) ++e;
return e;
#endif
}
#line 2 "utility/countr_zero.cpp"
#include <array>
#line 5 "utility/countr_zero.cpp"
constexpr int countr_zero(u64 x) {
if (x == 0) return 64;
#ifdef __GNUC__
return __builtin_ctzll(x);
#else
constexpr std::array<int, 64> table = {0, 1, 2, 7, 3, 13, 8, 27, 4, 33, 14, 36, 9, 49, 28, 19,
5, 25, 34, 17, 15, 53, 37, 55, 10, 46, 50, 39, 29, 42, 20, 57,
63, 6, 12, 26, 32, 35, 48, 18, 24, 16, 52, 54, 45, 38, 41, 56,
62, 11, 31, 47, 23, 51, 44, 40, 61, 30, 22, 43, 60, 21, 59, 58};
return table[(x & (~x + 1)) * 0x218A7A392DD9ABF >> 58 & 0x3F];
#endif
}
#line 2 "utility/rep.cpp"
#include <algorithm>
class Range {
struct Iter {
int itr;
constexpr Iter(const int pos) noexcept : itr(pos) {}
constexpr void operator++() noexcept { ++itr; }
constexpr bool operator!=(const Iter& other) const noexcept { return itr != other.itr; }
constexpr int operator*() const noexcept { return itr; }
};
const Iter first, last;
public:
explicit constexpr Range(const int first, const int last) noexcept : first(first), last(std::max(first, last)) {}
constexpr Iter begin() const noexcept { return first; }
constexpr Iter end() const noexcept { return last; }
};
constexpr Range rep(const int l, const int r) noexcept { return Range(l, r); }
constexpr Range rep(const int n) noexcept { return Range(0, n); }
#line 3 "utility/revrep.cpp"
class ReversedRange {
struct Iter {
int itr;
constexpr Iter(const int pos) noexcept : itr(pos) {}
constexpr void operator++() noexcept { --itr; }
constexpr bool operator!=(const Iter& other) const noexcept { return itr != other.itr; }
constexpr int operator*() const noexcept { return itr; }
};
const Iter first, last;
public:
explicit constexpr ReversedRange(const int first, const int last) noexcept
: first(last - 1), last(std::min(first, last) - 1) {}
constexpr Iter begin() const noexcept { return first; }
constexpr Iter end() const noexcept { return last; }
};
constexpr ReversedRange revrep(const int l, const int r) noexcept { return ReversedRange(l, r); }
constexpr ReversedRange revrep(const int n) noexcept { return ReversedRange(0, n); }
#line 8 "container/lazy_segment_tree.cpp"
template <class A> class LazySegmentTree {
using M = typename A::Monoid;
using E = typename A::Effector;
using T = typename M::Type;
using U = typename E::Type;
int internal_size, logn, seg_size;
std::vector<T> data;
std::vector<U> lazy;
void fetch(const int k) { data[k] = M::operation(data[2 * k], data[2 * k + 1]); }
void apply(const int k, const U& e) {
data[k] = A::operation(data[k], e);
if (k < seg_size) lazy[k] = E::operation(lazy[k], e);
}
void flush(const int k) {
apply(2 * k, lazy[k]);
apply(2 * k + 1, lazy[k]);
lazy[k] = E::identity();
}
void push(const int k) {
for (const int d : revrep(countr_zero(k) + 1, logn + 1)) flush(k >> d);
}
void pull(int k) {
for (k >>= countr_zero(k); k > 1;) fetch(k >>= 1);
}
public:
explicit LazySegmentTree(const int size = 0, const T& value = M::identity())
: LazySegmentTree(std::vector<T>(size, value)) {}
explicit LazySegmentTree(const std::vector<T>& vec) : internal_size(vec.size()) {
logn = ceil_log2(internal_size);
seg_size = 1 << logn;
data = std::vector<T>(2 * seg_size, M::identity());
lazy = std::vector<U>(seg_size, E::identity());
for (const int i : rep(internal_size)) data[seg_size + i] = vec[i];
for (const int i : revrep(1, seg_size)) fetch(i);
}
int size() const { return internal_size; }
void assign(int i, const T& value) {
assert(0 <= i and i < internal_size);
i += seg_size;
for (const int d : revrep(1, logn + 1)) flush(i >> d);
data[i] = value;
for (const int d : rep(1, logn + 1)) fetch(i >> d);
}
void operate(int l, int r, const U& e) {
assert(0 <= l and l <= r and r <= internal_size);
l += seg_size;
r += seg_size;
push(l);
push(r);
for (int l0 = l, r0 = r; l0 < r0; l0 >>= 1, r0 >>= 1) {
if (l0 & 1) apply(l0++, e);
if (r0 & 1) apply(--r0, e);
}
pull(l);
pull(r);
}
T fold() const { return data[1]; }
T fold(int l, int r) {
assert(0 <= l and l <= r and r <= internal_size);
l += seg_size;
r += seg_size;
push(l);
push(r);
T ret_l = M::identity(), ret_r = M::identity();
while (l < r) {
if (l & 1) ret_l = M::operation(ret_l, data[l++]);
if (r & 1) ret_r = M::operation(data[--r], ret_r);
l >>= 1;
r >>= 1;
}
return M::operation(ret_l, ret_r);
}
template <class F> int max_right(int l, const F& f) {
assert(0 <= l and l <= internal_size);
assert(f(M::identity()));
if (l == internal_size) return internal_size;
l += seg_size;
for (const int d : revrep(1, logn + 1)) flush(l >> d);
T sum = M::identity();
do {
while (!(l & 1)) l >>= 1;
if (!f(M::operation(sum, data[l]))) {
while (l < seg_size) {
flush(l);
l = 2 * l;
if (f(M::operation(sum, data[l]))) sum = M::operation(sum, data[l++]);
}
return l - seg_size;
}
sum = M::operation(sum, data[l++]);
} while ((l & -l) != l);
return internal_size;
}
template <class F> int min_left(int r, const F& f) {
assert(0 <= r and r <= internal_size);
assert(f(M::identity()));
if (r == 0) return 0;
r += seg_size;
for (const int d : revrep(1, logn + 1)) flush((r - 1) >> d);
T sum = M::identity();
do {
r -= 1;
while (r > 1 and (r & 1)) r >>= 1;
if (!f(M::operation(data[r], sum))) {
while (r < seg_size) {
flush(r);
r = 2 * r + 1;
if (f(M::operation(data[r], sum))) sum = M::operation(data[r--], sum);
}
return r + 1 - seg_size;
}
sum = M::operation(data[r], sum);
} while ((r & -r) != r);
return 0;
}
};