proconlib
This documentation is automatically generated by online-judge-tools/verification-helper
container/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/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/rep.cpp"
#include "../utility/revrep.cpp"
template <class M> class SegmentTree {
using T = typename M::Type;
int internal_size, seg_size;
std::vector<T> data;
void fetch(const int k) { data[k] = M::operation(data[2 * k], data[2 * k + 1]); }
public:
explicit SegmentTree(const int size = 0, const T& value = M::identity())
: SegmentTree(std::vector<T>(size, value)) {}
explicit SegmentTree(const std::vector<T>& vec) : internal_size(vec.size()) {
seg_size = 1 << ceil_log2(internal_size);
data = std::vector<T>(2 * seg_size, M::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;
data[i] = value;
while (i > 1) {
i >>= 1;
fetch(i);
}
}
T fold() const { return data[1]; }
T fold(int l, int r) const {
assert(0 <= l and l <= r and r <= internal_size);
l += seg_size;
r += seg_size;
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) const {
assert(0 <= l and l <= internal_size);
assert(f(M::identity()));
if (l == internal_size) return internal_size;
l += seg_size;
T sum = M::identity();
do {
while (!(l & 1)) l >>= 1;
if (!f(M::operation(sum, data[l]))) {
while (l < seg_size) {
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) const {
assert(0 <= r and r <= internal_size);
assert(f(M::identity()));
if (r == 0) return 0;
r += seg_size;
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) {
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/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/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 7 "container/segment_tree.cpp"
template <class M> class SegmentTree {
using T = typename M::Type;
int internal_size, seg_size;
std::vector<T> data;
void fetch(const int k) { data[k] = M::operation(data[2 * k], data[2 * k + 1]); }
public:
explicit SegmentTree(const int size = 0, const T& value = M::identity())
: SegmentTree(std::vector<T>(size, value)) {}
explicit SegmentTree(const std::vector<T>& vec) : internal_size(vec.size()) {
seg_size = 1 << ceil_log2(internal_size);
data = std::vector<T>(2 * seg_size, M::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;
data[i] = value;
while (i > 1) {
i >>= 1;
fetch(i);
}
}
T fold() const { return data[1]; }
T fold(int l, int r) const {
assert(0 <= l and l <= r and r <= internal_size);
l += seg_size;
r += seg_size;
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) const {
assert(0 <= l and l <= internal_size);
assert(f(M::identity()));
if (l == internal_size) return internal_size;
l += seg_size;
T sum = M::identity();
do {
while (!(l & 1)) l >>= 1;
if (!f(M::operation(sum, data[l]))) {
while (l < seg_size) {
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) const {
assert(0 <= r and r <= internal_size);
assert(f(M::identity()));
if (r == 0) return 0;
r += seg_size;
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) {
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;
}
};