#line 2 "include/data_structures.hpp"
#line 2 "data_structure/adaptor/set.hpp"
#include <cstdint>
#include <optional>
#include <type_traits>
#include <iterator>
#include <concepts>
#include <ranges>
#line 2 "internal/dev_env.hpp"
#ifdef LOCAL_JUDGE
inline constexpr bool DEV_ENV = true;
inline constexpr bool NO_EXCEPT = false;
#else
inline constexpr bool DEV_ENV = false;
inline constexpr bool NO_EXCEPT = true;
#endif // LOCAL_JUDGE
#if __cplusplus >= 202100L
#define CPP20 true
#define CPP23 true
#elif __cplusplus >= 202002L
#define CPP20 true
#define CPP23 false
#else
#define CPP20 false
#define CPP23 false
#endif
#line 2 "internal/types.hpp"
#line 4 "internal/types.hpp"
namespace uni {
namespace internal {
using size_t = std::int64_t;
using int128_t = __int128_t;
using uint128_t = __uint128_t;
} // namesapce internal
} // namespace uni
#line 2 "internal/concepts.hpp"
#line 7 "internal/concepts.hpp"
#include <limits>
#include <functional>
namespace uni {
namespace internal {
template<class R, class T>
concept convertibel_range = std::convertible_to<std::ranges::range_value_t<R>, T>;
template<class T, class V>
concept item_or_convertible_range = std::convertible_to<T, V> || convertibel_range<T, V>;
template<class Structure>
concept available =
requires () {
typename Structure;
};
template<
template<class...> class Structure,
class... TemplateParameters
>
concept available_with = available<Structure<TemplateParameters...>>;
template<class T> concept arithmetic = std::is_arithmetic_v<T>;
template<class T> concept pointer = std::is_pointer_v<T>;
template<class T> concept structural = std::is_class_v<T>;
template<class Large, class Small>
concept has_double_digits_of = (std::numeric_limits<Large>::digits == 2 * std::numeric_limits<Small>::digits);
template<class Large, class Small>
concept has_more_digits_than = (std::numeric_limits<Large>::digits > std::numeric_limits<Small>::digits);
template<class Large, class Small>
concept has_or_more_digits_than = (std::numeric_limits<Large>::digits >= std::numeric_limits<Small>::digits);
template<class T>
concept has_static_zero = requires { T::zero; };
template<class T>
concept has_static_one = requires { T::one; };
template<class L, class R = L>
concept weakly_bitand_calcurable = requires (L lhs, R rhs) { lhs & rhs; };
template<class L, class R = L>
concept weakly_bitor_calcurable = requires (L lhs, R rhs) { lhs | rhs; };
template<class L, class R = L>
concept weakly_bitxor_calcurable = requires (L lhs, R rhs) { lhs ^ rhs; };
template<class L, class R = L>
concept weakly_addable = requires (L lhs, R rhs) { lhs + rhs; };
template<class L, class R = L>
concept weakly_subtractable = requires (L lhs, R rhs) { lhs - rhs; };
template<class L, class R = L>
concept weakly_multipliable = requires (L lhs, R rhs) { lhs * rhs; };
template<class L, class R = L>
concept weakly_divisable = requires (L lhs, R rhs) { lhs / rhs; };
template<class L, class R = L>
concept weakly_remainder_calculable = requires (L lhs, R rhs) { lhs % rhs; };
template<class L, class R = L>
concept weakly_bitand_assignable = requires (L lhs, R rhs) { lhs += rhs; };
template<class L, class R = L>
concept weakly_bitor_assignable = requires (L lhs, R rhs) { lhs |= rhs; };
template<class L, class R = L>
concept weakly_bitxor_assignable = requires (L lhs, R rhs) { lhs ^= rhs; };
template<class L, class R = L>
concept weakly_addition_assignable = requires (L lhs, R rhs) { lhs += rhs; };
template<class L, class R = L>
concept weakly_subtraction_assignable = requires (L lhs, R rhs) { lhs -= rhs; };
template<class L, class R = L>
concept weakly_multipliation_assignalbe = requires (L lhs, R rhs) { lhs *= rhs; };
template<class L, class R = L>
concept weakly_division_assignable = requires (L lhs, R rhs) { lhs /= rhs; };
template<class L, class R = L>
concept weakly_remainder_assignable = requires (L lhs, R rhs) { lhs /= rhs; };
template<class L, class R = L>
concept bitand_calculable =
weakly_bitand_calcurable<L, R> &&
weakly_bitand_calcurable<std::invoke_result_t<std::bit_and<>&, L, R>, R> &&
weakly_bitand_calcurable<L, std::invoke_result_t<std::bit_and<>&, L, R>> &&
weakly_bitand_calcurable<std::invoke_result_t<std::bit_and<>&, L, R>, std::invoke_result_t<std::bit_and<>&, L, R>>;
template<class L, class R = L>
concept bitor_calculable =
weakly_bitor_calcurable<L, R> &&
weakly_bitor_calcurable<std::invoke_result_t<std::bit_or<>&, L, R>, R> &&
weakly_bitor_calcurable<L, std::invoke_result_t<std::bit_or<>&, L, R>> &&
weakly_bitor_calcurable<std::invoke_result_t<std::bit_or<>&, L, R>, std::invoke_result_t<std::bit_or<>&, L, R>>;
template<class L, class R = L>
concept bitxor_calculable =
weakly_bitxor_calcurable<L, R> &&
weakly_bitxor_calcurable<std::invoke_result_t<std::bit_xor<>&, L, R>, R> &&
weakly_bitxor_calcurable<L, std::invoke_result_t<std::bit_xor<>&, L, R>> &&
weakly_bitxor_calcurable<std::invoke_result_t<std::bit_xor<>&, L, R>, std::invoke_result_t<std::bit_xor<>&, L, R>>;
template<class L, class R = L>
concept addable =
weakly_addable<L, R> &&
weakly_addable<std::invoke_result_t<std::plus<>&, L, R>, R> &&
weakly_addable<L, std::invoke_result_t<std::plus<>&, L, R>> &&
weakly_addable<std::invoke_result_t<std::plus<>&, L, R>, std::invoke_result_t<std::plus<>&, L, R>>;
template<class L, class R = L>
concept subtractable =
weakly_subtractable<L, R> &&
weakly_subtractable<std::invoke_result_t<std::minus<>&, L, R>, R> &&
weakly_subtractable<L, std::invoke_result_t<std::minus<>&, L, R>> &&
weakly_subtractable<std::invoke_result_t<std::minus<>&, L, R>, std::invoke_result_t<std::minus<>&, L, R>>;
template<class L, class R = L>
concept multipliable =
weakly_multipliable<L, R> &&
weakly_multipliable<std::invoke_result_t<std::multiplies<>&, L, R>, R> &&
weakly_multipliable<L, std::invoke_result_t<std::multiplies<>&, L, R>> &&
weakly_multipliable<std::invoke_result_t<std::multiplies<>&, L, R>, std::invoke_result_t<std::multiplies<>&, L, R>>;
template<class L, class R = L>
concept divisable =
weakly_divisable<L, R> &&
weakly_divisable<std::invoke_result_t<std::divides<>&, L, R>, R> &&
weakly_divisable<L, std::invoke_result_t<std::divides<>&, L, R>> &&
weakly_divisable<std::invoke_result_t<std::divides<>&, L, R>, std::invoke_result_t<std::divides<>&, L, R>>;
template<class L, class R = L>
concept remainder_calculable =
weakly_remainder_calculable<L, R> &&
weakly_remainder_calculable<std::invoke_result_t<std::modulus<>&, L, R>, R> &&
weakly_remainder_calculable<L, std::invoke_result_t<std::modulus<>&, L, R>> &&
weakly_remainder_calculable<std::invoke_result_t<std::modulus<>&, L, R>, std::invoke_result_t<std::modulus<>&, L, R>>;
template<class L, class R = L>
concept bitand_assignable =
weakly_bitand_assignable<L, R> &&
weakly_bitand_assignable<std::invoke_result_t<std::bit_and<>&, L, R>, R> &&
weakly_bitand_assignable<L, std::invoke_result_t<std::bit_and<>&, L, R>> &&
weakly_bitand_assignable<std::invoke_result_t<std::bit_and<>&, L, R>, std::invoke_result_t<std::bit_and<>&, L, R>>;
template<class L, class R = L>
concept bitor_assignable =
weakly_bitor_calcurable<L, R> &&
weakly_bitor_calcurable<std::invoke_result_t<std::bit_or<>&, L, R>, R> &&
weakly_bitor_calcurable<L, std::invoke_result_t<std::bit_or<>&, L, R>> &&
weakly_bitor_calcurable<std::invoke_result_t<std::bit_or<>&, L, R>, std::invoke_result_t<std::bit_or<>&, L, R>>;
template<class L, class R = L>
concept bitxor_assignable =
weakly_bitxor_calcurable<L, R> &&
weakly_bitxor_calcurable<std::invoke_result_t<std::bit_xor<>&, L, R>, R> &&
weakly_bitxor_calcurable<L, std::invoke_result_t<std::bit_xor<>&, L, R>> &&
weakly_bitxor_calcurable<std::invoke_result_t<std::bit_xor<>&, L, R>, std::invoke_result_t<std::bit_xor<>&, L, R>>;
template<class L, class R = L>
concept addition_assignable =
weakly_addition_assignable<L, R> &&
weakly_addition_assignable<std::remove_cvref_t<std::invoke_result_t<std::plus<>&, L, R>>, R> &&
weakly_addition_assignable<L, std::invoke_result_t<std::plus<>&, L, R>> &&
weakly_addition_assignable<std::remove_cvref_t<std::invoke_result_t<std::plus<>&, L, R>>, std::invoke_result_t<std::plus<>&, L, R>>;
template<class L, class R = L>
concept subtraction_assignable =
weakly_subtraction_assignable<L, R> &&
weakly_subtraction_assignable<std::remove_cvref_t<std::invoke_result_t<std::minus<>&, L, R>>, R> &&
weakly_subtraction_assignable<L, std::invoke_result_t<std::minus<>&, L, R>> &&
weakly_subtraction_assignable<std::remove_cvref_t<std::invoke_result_t<std::minus<>&, L, R>>, std::invoke_result_t<std::minus<>&, L, R>>;
template<class L, class R = L>
concept multipliation_assignalbe =
weakly_multipliation_assignalbe<L, R> &&
weakly_multipliation_assignalbe<std::remove_cvref_t<std::invoke_result_t<std::multiplies<>&, L, R>>, R> &&
weakly_multipliation_assignalbe<L, std::invoke_result_t<std::multiplies<>&, L, R>> &&
weakly_multipliation_assignalbe<std::remove_cvref_t<std::invoke_result_t<std::multiplies<>&, L, R>>, std::invoke_result_t<std::multiplies<>&, L, R>>;
template<class L, class R = L>
concept division_assignable =
weakly_division_assignable<L, R> &&
weakly_division_assignable<std::remove_cvref_t<std::invoke_result_t<std::divides<>&, L, R>>, R> &&
weakly_division_assignable<L, std::invoke_result_t<std::divides<>&, L, R>> &&
weakly_division_assignable<std::remove_cvref_t<std::invoke_result_t<std::divides<>&, L, R>>, std::invoke_result_t<std::divides<>&, L, R>>;
template<class L, class R = L>
concept remainder_assignable =
weakly_remainder_assignable<L, R> &&
weakly_remainder_assignable<std::remove_cvref_t<std::invoke_result_t<std::modulus<>&, L, R>>, R> &&
weakly_remainder_assignable<L, std::invoke_result_t<std::modulus<>&, L, R>> &&
weakly_remainder_assignable<std::remove_cvref_t<std::invoke_result_t<std::modulus<>&, L, R>>, std::invoke_result_t<std::modulus<>&, L, R>>;
template<class T>
concept weakly_incrementable =
std::movable<T> &&
requires (T v) {
{ ++v } -> std::same_as<T&>;
v++;
};
template<class T>
concept weakly_decrementable =
std::movable<T> &&
requires (T v) {
{ --v } -> std::same_as<T&>;
v--;
};
template<class T>
concept incrementable =
std::regular<T> &&
weakly_incrementable<T> &&
requires (T v) {
{ v++ } -> std::same_as<T>;
};
template<class T>
concept decrementable =
std::regular<T> &&
weakly_decrementable<T> &&
requires (T v) {
{ v-- } -> std::same_as<T>;
};
template<class L, class R = L>
concept weakly_arithmetic_operable =
weakly_addable<L, R> &&
weakly_subtractable<L, R> &&
weakly_multipliable<L, R> &&
weakly_divisable<L, R>;
template<class L, class R = L>
concept weakly_arithmetic_operation_assignable =
weakly_addition_assignable<L, R> &&
weakly_subtraction_assignable<L, R> &&
weakly_multipliation_assignalbe<L, R> &&
weakly_division_assignable<L, R>;
template<class L, class R = L>
concept arithmetic_operable =
weakly_arithmetic_operable<L, R> &&
addable<L, R> &&
subtractable<L, R> &&
multipliable<L, R> &&
divisable<L, R>;
template<class L, class R = L>
concept arithmetic_operation_assignable =
weakly_arithmetic_operation_assignable<L, R> &&
addition_assignable<L, R> &&
subtraction_assignable<L, R> &&
multipliation_assignalbe<L, R> &&
division_assignable<L, R>;
template<class T>
concept unary_addable =
requires (T v) {
{ +v } -> std::same_as<T>;
};
template<class T>
concept unary_subtractable =
requires (T v) {
{ -v } -> std::same_as<T>;
};
template<class T>
concept numeric =
std::regular<T> &&
arithmetic_operable<T> &&
arithmetic_operation_assignable<T> &&
weakly_incrementable<T> &&
unary_addable<T> &&
unary_subtractable<T>;
} // namespace internal
} // namespace uni
#line 15 "data_structure/adaptor/set.hpp"
#line 2 "global/constants.hpp"
#line 6 "global/constants.hpp"
#include <utility>
#include <cmath>
#line 2 "snippet/aliases.hpp"
#line 6 "snippet/aliases.hpp"
#include <vector>
#line 8 "snippet/aliases.hpp"
#line 2 "snippet/internal/types.hpp"
#line 4 "snippet/internal/types.hpp"
namespace uni {
using i16 = std::int16_t;
using u16 = std::uint16_t;
using i32 = std::int32_t;
using u32 = std::uint32_t;
using i64 = std::int64_t;
using u64 = std::uint64_t;
#ifdef __GNUC__
using i128 = __int128_t;
using u128 = __uint128_t;
using f128 = __float128;
#endif
using uint = unsigned;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
} // namespace uni
#line 12 "snippet/aliases.hpp"
#define until(...) while(!(__VA_ARGS__))
#define CONTINUE(...) { __VA_ARGS__; continue; }
#define BREAK(...) { __VA_ARGS__; break; }
#define ALL(x) std::ranges::begin((x)),std::ranges::end((x))
#define RALL(x) std::ranges::rbegin((x)),std::ranges::rend((x))
#define $F first
#define $S second
namespace uni {
constexpr char LN = '\n';
constexpr char SPC = ' ';
constexpr std::pair<int,int> DIRS4[] = { { -1, 0 }, { 0, 1 }, { 1, 0 }, { 0, -1 } };
constexpr std::pair<int,int> DIRS4P[] = { { -1, 0 }, { 0, 1 }, { 1, 0 }, { 0, -1 }, { 0, 0 } };
constexpr std::pair<int,int> DIRS8[] = { { -1, 0 }, { -1, 1 }, { 0, 1 }, { 1, 1 }, { 1, 0 }, { 1, -1 }, { 0, -1 }, { -1, -1 } };
constexpr std::pair<int,int> DIRS8P[] = { { -1, 0 }, { -1, 1 }, { 0, 1 }, { 1, 1 }, { 1, 0 }, { 1, -1 }, { 0, -1 }, { -1, -1 }, { 0, 0 } };
template<class T> using spair = std::pair<T,T>;
} // namespace uni
namespace std {
using bit_reference = std::vector<bool>::reference;
bit_reference operator |= (bit_reference a, const bool b) noexcept(NO_EXCEPT) { return a = a | b; }
bit_reference operator &= (bit_reference a, const bool b) noexcept(NO_EXCEPT) { return a = a & b; }
}
#line 11 "global/constants.hpp"
#line 2 "internal/type_traits.hpp"
#include <iostream>
#line 7 "internal/type_traits.hpp"
#include <algorithm>
#line 9 "internal/type_traits.hpp"
#line 12 "internal/type_traits.hpp"
namespace uni {
namespace internal {
template<class... Ts> struct tuple_or_pair { using type = std::tuple<Ts...>; };
template<class T, class U> struct tuple_or_pair<T,U> { using type = std::pair<T, U>; };
template <class... Ts> using tuple_or_pair_t = typename tuple_or_pair<Ts...>::type;
template<class T>
constexpr std::underlying_type_t<T> to_underlying(const T& v) noexcept(NO_EXCEPT) {
return static_cast<std::underlying_type_t<T>>(v);
}
template<class T, class... Ts>
using are_same = std::conjunction<std::is_same<T, Ts>...>;
template<class T, class... Ts>
inline constexpr bool are_same_v = are_same<T, Ts...>::value;
template<class T, class... Ts>
using is_same_as_any_of = std::disjunction<std::is_same<T, Ts>...>;
template<class T, class... Ts>
inline constexpr bool is_same_as_any_of_v = is_same_as_any_of<T, Ts...>::value;
template<class T, class... Ts>
concept same_as_any_of = is_same_as_any_of_v<T, Ts...>;
template<class Base, class... Derived>
using is_base_of_all = std::conjunction<std::is_base_of<Base, Derived>...>;
template<class Base, class... Derived>
inline constexpr bool is_base_of_all_v = is_base_of_all<Base, Derived...>::value;
template<class Base, class... Derived>
using is_base_of_any = std::disjunction<std::is_base_of<Base, Derived>...>;
template<class Base, class... Derived>
inline constexpr bool is_base_of_any_v = is_base_of_any<Base, Derived...>::value;
template<class T> struct remove_cvref {
using type = typename std::remove_cv_t<std::remove_reference_t<T>>;
};
template<class T> using remove_cvref_t = typename remove_cvref<T>::type;
template<class T> struct literal_operator { static constexpr const char* value = ""; };
template<> struct literal_operator<unsigned> { static constexpr const char* value = "U"; };
template<> struct literal_operator<long> { static constexpr const char* value = "L"; };
template<> struct literal_operator<unsigned long> { static constexpr const char* value = "UL"; };
template<> struct literal_operator<long long> { static constexpr const char* value = "LL"; };
template<> struct literal_operator<unsigned long long> { static constexpr const char* value = "ULL"; };
template<> struct literal_operator<float> { static constexpr const char* value = "F"; };
template<> struct literal_operator<double> { static constexpr const char* value = "D"; };
template<> struct literal_operator<long double> { static constexpr const char* value = "LD"; };
#ifdef __SIZEOF_INT128__
template<> struct literal_operator<__int128_t> { static constexpr const char* value = "LLL"; };
template<> struct literal_operator<__uint128_t> { static constexpr const char* value = "ULLL"; };
#endif
template<class T> inline constexpr auto literal_operator_v = literal_operator<T>::value;
template <std::size_t N, typename... Types>
struct nth_type {};
template <class Head, class... Tail>
struct nth_type<0, Head, Tail...> {
using type = Head;
};
template <std::size_t N, class Head, class... Tail>
struct nth_type<N, Head, Tail...> : public nth_type<N - 1, Tail...> {};
template <std::size_t N, typename... Types>
using nth_type_t = typename nth_type<N, Types...>::type;
template<template <class...> class, class> struct is_template_of : std::false_type {};
template<template <class...> class Template, class... Args> struct is_template_of<Template, Template<Args...>> : std::true_type {};
template<template <class...> class Template, class Type>
inline constexpr bool is_template_of_v = is_template_of<Template, Type>::value;
template<class Type, template <class...> class Template>
concept substituted_from = is_template_of_v<Template, Type>;
template<template <class...> class Base, class Derived>
struct _is_basic_tempalte_of
{
template<class... Ts>
static constexpr std::true_type test(const Base<Ts...> *);
static constexpr std::false_type test(...);
using type = decltype(test(std::declval<Derived*>()));
};
template<template <class...> class Base, class Derived>
using is_basic_tempalte_of = _is_basic_tempalte_of<Base, Derived>::type;
template<template <class...> class Base, class Derived>
inline constexpr bool is_basic_tempalte_of_v = is_basic_tempalte_of<Base, Derived>::value;
template<class Derived, template <class...> class Base>
concept derived_from_template = is_basic_tempalte_of_v<Base, Derived>;
template<class T> struct is_loggable {
template<class U>
static constexpr auto External(U &&v) -> decltype(_debug(v), std::true_type());
static constexpr std::false_type External(...);
template<class U>
static constexpr auto Member(U &&v) -> decltype(v._debug(), std::true_type());
static constexpr std::false_type Member(...);
static constexpr bool value = (
decltype(External(std::declval<T>()))::value ||
decltype(Member(std::declval<T>()))::value
);
};
template<class T>
inline constexpr auto is_loggable_v = is_loggable<T>::value;
template<class T>
concept loggable = is_loggable_v<T>;
template<class T> struct _has_iterator {
template<class U>
static constexpr auto ADL(U &&v) -> decltype(begin(v), end(v), std::true_type());
static constexpr std::false_type ADL(...);
template<class U>
static constexpr auto STL(U &&v) -> decltype(std::begin(v), std::end(v), std::true_type());
static constexpr std::false_type STL(...);
template<class U>
static constexpr auto Member(U &&v) -> decltype(v.begin(), v.end(), std::true_type());
static constexpr std::false_type Member(...);
};
template<class T> struct has_iterator {
struct ADL : decltype(_has_iterator<T>::ADL(std::declval<T>())) {};
struct STL : decltype(_has_iterator<T>::STL(std::declval<T>())) {};
struct Member : decltype(_has_iterator<T>::Member(std::declval<T>())) {};
static constexpr auto adl_v = ADL::value;
static constexpr auto stl_v = STL::value;
static constexpr auto member_v = Member::value;
};
template<class T>
struct is_iterable {
static constexpr bool value = has_iterator<T>::adl_v || has_iterator<T>::stl_v || has_iterator<T>::member_v;
};
template<class T>
inline constexpr auto is_iterable_v = is_iterable<T>::value;
template<class T>
concept iterable = is_iterable_v<T>;
namespace iterator_resolver {
template<class T>
inline constexpr auto begin(T&& v) noexcept(NO_EXCEPT) {
static_assert(is_iterable_v<T>);
if constexpr(has_iterator<T>::member_v) {
return v.begin();
}
else { // ADL
using std::begin;
return begin(std::forward<T>(v));
}
}
template<class T>
inline constexpr auto end(T&& v) noexcept(NO_EXCEPT) {
static_assert(is_iterable_v<T>);
if constexpr(has_iterator<T>::member_v) {
return v.end();
}
else { // ADL
using std::end;
return end(std::forward<T>(v));
}
}
};
template<class C> using iterator_t = decltype(iterator_resolver::begin(std::declval<C&>()));
template<class C> using container_size_t = decltype(std::size(std::declval<C&>()));
template<bool Const, class T>
using maybe_const_t = std::conditional_t<Const, const T, T>;
template<class T> using with_ref = T&;
template<class T> concept can_reference = requires { typename with_ref<T>; };
} // namespace internal
} // namespace uni
#line 2 "internal/exception.hpp"
namespace uni {
namespace internal {
template<class... T> inline constexpr bool EXCEPTION_ON_TYPE = false;
template<auto T> inline constexpr bool EXCEPTION_ON_VALUE = false;
} // namespace internal
} // namespace uni
#line 14 "global/constants.hpp"
#line 2 "numeric/limits.hpp"
#line 6 "numeric/limits.hpp"
#line 9 "numeric/limits.hpp"
#line 11 "numeric/limits.hpp"
namespace uni {
template<class T>
struct numeric_limits : std::numeric_limits<T> {
static constexpr long double FLOAT_EPSILON = 1E-14;
static constexpr T arithmetic_infinity() noexcept(NO_EXCEPT) {
return std::numeric_limits<T>::max() / 2 - 1;
}
static constexpr T arithmetic_negative_infinity() noexcept(NO_EXCEPT) {
return std::numeric_limits<T>::lowest() / 2 + 1;
}
static constexpr T arithmetic_epsilon() noexcept(NO_EXCEPT) {
if constexpr(std::is_floating_point_v<T>) {
return numeric_limits::FLOAT_EPSILON;
}
else {
return 0;
}
}
};
constexpr i32 INF32 = numeric_limits<i32>::arithmetic_infinity();
constexpr i64 INF64 = numeric_limits<i64>::arithmetic_infinity();
template<class T>
constexpr T INF = numeric_limits<T>::arithmetic_infinity();
template<class T>
constexpr T EPSILON = numeric_limits<T>::arithmetic_epsilon();
} // namespace uni
#line 16 "global/constants.hpp"
namespace uni {
namespace internal {
template<class T>
consteval auto get_pi() {
if constexpr(std::integral<T>) {
return static_cast<T>(3);
}
else if constexpr(std::same_as<T, float>) {
return M_PIf;
}
else if constexpr(std::same_as<T, double>) {
return M_PI;
}
else if constexpr(std::same_as<T, ld>) {
return M_PIl;
}
else {
static_assert(EXCEPTION_ON_TYPE<T>);
}
}
} // namespace internal
template<class T = ld>
constexpr auto PI = internal::get_pi<T>();
enum class comparison : std::uint8_t {
equal_to,
not_equal_to,
equals = equal_to,
eq = equal_to,
under,
over,
or_under,
or_over,
less = under,
more = over,
less_than = under,
more_than = over,
not_less_than = or_over,
not_more_than = or_under,
leq = or_under,
geq = or_over
};
enum class interval_notation : std::uint8_t {
right_open,
left_open,
open,
closed,
};
enum class replacement_policy : std::uint8_t {
insert_sync,
overwrite_sync,
overwrite_async
};
enum class rotation : std::int8_t {
clockwise,
counter_clockwise,
anti_clockwise = counter_clockwise,
};
enum class positional_relation : std::int8_t {
clockwise,
counter_clockwise,
anti_clockwise = counter_clockwise,
backward,
forward,
in,
on,
out,
included = in,
inscribed,
intersecting,
circumscribed,
distant,
};
enum class alignment : std::int8_t {
left,
center,
right
};
} // namespace uni
#line 17 "data_structure/adaptor/set.hpp"
#line 2 "data_structure/segment_tree.hpp"
#include <cassert>
#line 10 "data_structure/segment_tree.hpp"
#include <bit>
#line 2 "snippet/iterations.hpp"
#line 2 "macro/overload.hpp"
#define $OVERLOAD2(arg0, arg1, cmd, ...) cmd
#define $OVERLOAD3(arg0, arg1, arg2, cmd, ...) cmd
#define $OVERLOAD4(arg0, arg1, arg2, arg3, cmd, ...) cmd
#define $OVERLOAD5(arg0, arg1, arg2, arg3, arg4, cmd, ...) cmd
#define $OVERLOAD6(arg0, arg1, arg2, arg3, arg4, arg5, cmd, ...) cmd
#line 2 "macro/basic.hpp"
#define TO_STRING_AUX(x) #x
#define TO_STRING(x) TO_STRING_AUX(x)
#define CONCAT_AUX(x, y) x##y
#define CONCAT(x, y) CONCAT_AUX(x, y)
#define UNPAREN_AUX(...) __VA_ARGS__
#define UNPAREN(...) __VA_ARGS__
#line 6 "snippet/iterations.hpp"
#define LOOP(n) REPI(CONCAT(_$, __COUNTER__), n)
#define REPI(i,n) for(std::remove_cvref_t<decltype(n)> i=0, CONCAT(i, $)=(n); i<CONCAT(i, $); ++i)
#define REPF(i,l,r) for(std::common_type_t<std::remove_cvref_t<decltype(l)>,std::remove_cvref_t<decltype(r)>> i=(l), CONCAT(i, $)=(r); i<CONCAT(i, $); ++i)
#define REPIS(i,l,r,s) for(std::common_type_t<std::remove_cvref_t<decltype(l)>,std::remove_cvref_t<decltype(r)>,std::remove_cvref_t<decltype(s)>> i=(l), CONCAT(i, $)=(r); i<CONCAT(i, $); i+=(s))
#define REPR(i,n) for(auto i=(n); --i>=0;)
#define REPB(i,l,r) for(std::common_type_t<std::remove_cvref_t<decltype(l)>,std::remove_cvref_t<decltype(r)>> i=(r), CONCAT(i, $)=(l); --i>=CONCAT(i, $);)
#define REPRS(i,l,r,s) for(std::common_type_t<std::remove_cvref_t<decltype(l)>,std::remove_cvref_t<decltype(r)>,std::remove_cvref_t<decltype(s)>> i=(l)+((r)-(l)-1)/(s)*(s), CONCAT(i, $)=(l); i>=CONCAT(i, $); (i-=(s)))
#define REP(...) $OVERLOAD4(__VA_ARGS__, REPIS, REPF, REPI, LOOP)(__VA_ARGS__)
#define REPD(...) $OVERLOAD4(__VA_ARGS__, REPRS, REPB, REPR)(__VA_ARGS__)
#define FORO(i,n) for(int i=0, CONCAT(i, $)=static_cast<int>(n); i<=CONCAT(i, $); ++i)
#define FORI(i,l,r) for(std::common_type_t<std::remove_cvref_t<decltype(l)>,std::remove_cvref_t<decltype(r)>> i=(l), CONCAT(i, $)=(r); i<=CONCAT(i, $); ++i)
#define FORIS(i,l,r,s) for(std::common_type_t<std::remove_cvref_t<decltype(l)>,std::remove_cvref_t<decltype(r)>,std::remove_cvref_t<decltype(s)>> i=(l), CONCAT(i, $)=(r); i<=CONCAT(i, $); i+=(s))
#define FORRO(i,n) for(auto i=(n); i>=0; --i)
#define FORR(i,l,r) for(std::common_type_t<std::remove_cvref_t<decltype(l)>,std::remove_cvref_t<decltype(r)>> i=(r), CONCAT(i, $)=(l); i>=CONCAT(i, $); --i)
#define FORRS(i,l,r,s) for(std::common_type_t<std::remove_cvref_t<decltype(l)>,std::remove_cvref_t<decltype(r)>,std::remove_cvref_t<decltype(s)>> i=(l)+((r)-(l))/(s)*(s), CONCAT(i, $)=(l); i>=CONCAT(i, $); i-=(s))
#define FOR(...) $OVERLOAD4(__VA_ARGS__, FORIS, FORI, FORO)(__VA_ARGS__)
#define FORD(...) $OVERLOAD4(__VA_ARGS__, FORRS, FORR, FORRO)(__VA_ARGS__)
#define ITR1(e0,v) for(const auto &e0 : (v))
#define ITRP1(e0,v) for(auto e0 : (v))
#define ITRR1(e0,v) for(auto &e0 : (v))
#define ITR2(e0,e1,v) for(const auto [e0, e1] : (v))
#define ITRP2(e0,e1,v) for(auto [e0, e1] : (v))
#define ITRR2(e0,e1,v) for(auto &[e0, e1] : (v))
#define ITR3(e0,e1,e2,v) for(const auto [e0, e1, e2] : (v))
#define ITRP3(e0,e1,e2,v) for(auto [e0, e1, e2] : (v))
#define ITRR3(e0,e1,e2,v) for(auto &[e0, e1, e2] : (v))
#define ITR4(e0,e1,e2,e3,v) for(const auto [e0, e1, e2, e3] : (v))
#define ITRP4(e0,e1,e2,e3,v) for(auto [e0, e1, e2, e3] : (v))
#define ITRR4(e0,e1,e2,e3,v) for(auto &[e0, e1, e2, e3] : (v))
#define ITR5(e0,e1,e2,e3,e4,v) for(const auto [e0, e1, e2, e3, e4] : (v))
#define ITRP5(e0,e1,e2,e3,e4,v) for(auto [e0, e1, e2, e3, e4] : (v))
#define ITRR5(e0,e1,e2,e3,e4,v) for(auto &[e0, e1, e2, e3, e4] : (v))
#define ITR(...) $OVERLOAD6(__VA_ARGS__, ITR5, ITR4, ITR3, ITR2, ITR1)(__VA_ARGS__)
#define ITRP(...) $OVERLOAD6(__VA_ARGS__, ITRP5, ITRP4, ITRP3, ITRP2, ITRP1)(__VA_ARGS__)
#define ITRR(...) $OVERLOAD6(__VA_ARGS__, ITRR5, ITRR4, ITRR3, ITRR2, ITRR1)(__VA_ARGS__)
#line 14 "data_structure/segment_tree.hpp"
#line 2 "internal/iterator.hpp"
#line 7 "internal/iterator.hpp"
#include <variant>
#include <compare>
#line 10 "internal/iterator.hpp"
#line 13 "internal/iterator.hpp"
#line 16 "internal/iterator.hpp"
namespace uni {
namespace internal {
template<class T>
struct iterator_interface {
using iterator_category = std::output_iterator_tag;
using difference_type = size_t;
using value_type = T;
using pointer = T*;
using reference = T&;
// virtual T operator*() const noexcept(NO_EXCEPT) { return 0; };
};
template<class T>
struct forward_iterator : iterator_interface<T> {
using iterator_category = std::forward_iterator_tag;
// virtual bidirectional_iterator_interface& operator++() = 0;
};
template<class T>
struct bidirectional_iterator_interface : forward_iterator<T> {
using iterator_category = std::bidirectional_iterator_tag;
// virtual bidirectional_iterator_interface& operator--() = 0;
};
template<class T>
struct random_access_iterator_base : bidirectional_iterator_interface<T> {
using iterator_category = std::random_access_iterator_tag;
using difference_type = typename bidirectional_iterator_interface<T>::difference_type;
public:
// virtual random_access_iterator_base& operator+=(const difference_type count) = 0;
// virtual random_access_iterator_base& operator-=(const difference_type count) = 0;
friend inline random_access_iterator_base operator+(random_access_iterator_base itr, const difference_type count) noexcept(NO_EXCEPT) { return itr += count, itr; }
friend inline random_access_iterator_base operator-(random_access_iterator_base itr, const difference_type count) noexcept(NO_EXCEPT) { return itr -= count, itr; }
};
template<class T, class Container, class Derived>
struct container_iterator_interface : random_access_iterator_base<T> {
using difference_type = std::make_signed_t<typename Container::size_type>;
private:
using derived = std::remove_cvref_t<Derived>;
Container* _ref;
difference_type _pos;
static_assert(std::three_way_comparable<difference_type>);
inline auto* _derived() noexcept(NO_EXCEPT) {
return static_cast<derived*>(this);
}
inline const auto* _derived() const noexcept(NO_EXCEPT) {
return static_cast<const derived*>(this);
}
public:
container_iterator_interface() noexcept = default;
container_iterator_interface(Container *const ref, const difference_type pos) noexcept(NO_EXCEPT) : _ref(ref), _pos(pos) {}
inline auto ref() const noexcept(NO_EXCEPT) { return this->_ref; }
inline auto pos() const noexcept(NO_EXCEPT) { return this->_pos; }
inline auto& pos() { return this->_pos; }
inline auto& operator++() noexcept(NO_EXCEPT) { return ++this->_pos, *this->_derived(); }
inline auto& operator--() noexcept(NO_EXCEPT) { return --this->_pos, *this->_derived(); }
inline auto operator++(int) noexcept(NO_EXCEPT) { auto res = *this->_derived(); return ++this->_pos, res; }
inline auto operator--(int) noexcept(NO_EXCEPT) { auto res = *this->_derived(); return --this->_pos, res; }
inline auto& operator+=(const difference_type count) noexcept(NO_EXCEPT) { return this->_pos += count, *this->_derived(); }
inline auto& operator-=(const difference_type count) noexcept(NO_EXCEPT) { return this->_pos -= count, *this->_derived(); }
inline auto operator*() const noexcept(NO_EXCEPT) { return this->ref()->get(this->_pos); }
inline auto operator[](const difference_type count) const noexcept(NO_EXCEPT) { return *(*this->_derived() + count); }
inline auto operator-(const derived& other) const noexcept(NO_EXCEPT) { return this->_pos - other._pos; }
friend inline bool operator==(const derived& lhs, const derived& rhs) noexcept(NO_EXCEPT) {
if(lhs.ref() == rhs.ref()) return lhs._pos == rhs._pos;
return false;
}
friend inline std::partial_ordering operator<=>(const derived& lhs, const derived& rhs) noexcept(NO_EXCEPT) {
if(lhs.ref() != rhs.ref()) return std::partial_ordering::unordered;
return lhs._pos <=> rhs._pos;
}
};
namespace iterator_impl {
template<class... Tags>
using is_all_random_access_iterator = is_base_of_all<std::random_access_iterator_tag,Tags...>;
template<class... Tags>
using is_all_bidirectional_iterator = is_base_of_all<std::bidirectional_iterator_tag,Tags...>;
template<class... Tags>
using is_all_forward_iterator = is_base_of_all<std::forward_iterator_tag,Tags...>;
template<class... Tags>
using is_all_input_iterator = is_base_of_all<std::input_iterator_tag,Tags...>;
template<class... Tags>
constexpr auto _most_primitive_iterator_tag() {
if constexpr(is_all_random_access_iterator<Tags...>::value) {
return std::random_access_iterator_tag{};
}
else if constexpr(is_all_bidirectional_iterator<Tags...>::value) {
return std::bidirectional_iterator_tag{};
}
else if constexpr(is_all_forward_iterator<Tags...>::value) {
return std::forward_iterator_tag{};
}
else {
return std::input_iterator_tag{};
}
}
} // namespace iterator_impl
template<class... Tags>
using most_primitive_iterator_tag = decltype(iterator_impl::_most_primitive_iterator_tag<Tags...>());
template<class T, class = void>
struct is_iterator {
static constexpr bool value = false;
};
template<class T>
struct is_iterator<T, typename std::enable_if<!std::is_same<typename std::iterator_traits<T>::value_type, void>::value>::type> {
static constexpr bool value = true;
};
template<class T>
inline constexpr bool is_iterator_v = is_iterator<T>::value;
template<class T>
using is_iterator_t = std::enable_if_t<is_iterator_v<T>>;
template<class T>
using iota_diff_t = std::make_signed_t<T>;
} // namespace internal
} // namespace uni
#line 2 "internal/point_reference.hpp"
#line 6 "internal/point_reference.hpp"
#line 9 "internal/point_reference.hpp"
#line 11 "internal/point_reference.hpp"
namespace uni {
namespace internal {
template<class Super, std::integral SizeType = typename Super::size_type>
struct point_reference {
using size_type = SizeType;
using iterator = typename Super::iterator;
protected:
Super *const _super;
const size_type _pos;
point_reference(Super *const super, const size_type pos) noexcept(NO_EXCEPT) : _super(super), _pos(pos) {}
inline auto index() noexcept(NO_EXCEPT) { return this->_pos; }
};
} // namespace internal
} // namespace uni
#line 2 "internal/range_reference.hpp"
#line 8 "internal/range_reference.hpp"
#line 11 "internal/range_reference.hpp"
#line 13 "internal/range_reference.hpp"
namespace uni {
namespace internal {
template<class Super, std::integral SizeType = typename Super::size_type>
struct range_reference {
using size_type = SizeType;
using iterator = Super::iterator;
protected:
Super *const _super;
const size_type _begin, _end;
range_reference(Super *const super, const size_type begin, const size_type end) noexcept(NO_EXCEPT) : _super(super), _begin(begin), _end(end) {}
public:
inline auto begin() const noexcept(NO_EXCEPT) { return std::ranges::next(std::ranges::begin(*this->_super), this->_begin); }
inline auto end() const noexcept(NO_EXCEPT) { return std::ranges::next(std::ranges::begin(*this->_super), this->_end); }
inline auto size() const noexcept(NO_EXCEPT) { return this->_end - this->_begin; }
inline auto interval() const noexcept(NO_EXCEPT) { return std::make_pair(this->_begin, this->_end); }
protected:
inline auto sub_range(size_type l, size_type r) const noexcept(NO_EXCEPT) {
l = _super->_positivize_index(l), r = _super->_positivize_index(r);
assert(0 <= l and l <= r and r <= this->size());
return range_reference(_super, this->_begin + l, this->_begin + r);
}
public:
template<uni::interval_notation rng = uni::interval_notation::right_open>
inline auto range(const size_type l, const size_type r) const noexcept(NO_EXCEPT) {
if constexpr(rng == uni::interval_notation::right_open) return this->sub_range(l, r);
if constexpr(rng == uni::interval_notation::left_open) return this->sub_range(l+1, r+1);
if constexpr(rng == uni::interval_notation::open) return this->sub_range(l+1, r);
if constexpr(rng == uni::interval_notation::closed) return this->sub_range(l, r+1);
}
inline auto range() const noexcept(NO_EXCEPT) { return range_reference(this->_begin, this->_end); }
inline auto operator()(const size_type l, const size_type r) const noexcept(NO_EXCEPT) { return this->sub_range(l, r); }
inline auto subseq(const size_type p, const size_type c) const noexcept(NO_EXCEPT) { return this->sub_range(p, p+c); }
inline auto subseq(const size_type p) const noexcept(NO_EXCEPT) { return this->sub_range(p, this->size()); }
};
} // namespace internal
} // namespace uni
#line 2 "internal/unconstructible.hpp"
namespace uni {
namespace internal {
struct unconstructible {
private:
template<class... Args>
unconstructible(Args...) = delete;
};
} // namespace internal
} // namespace uni
#line 21 "data_structure/segment_tree.hpp"
#line 2 "numeric/bit.hpp"
#include <immintrin.h>
#line 8 "numeric/bit.hpp"
#include <cstddef>
#line 13 "numeric/bit.hpp"
#line 16 "numeric/bit.hpp"
#line 2 "numeric/arithmetic.hpp"
#line 5 "numeric/arithmetic.hpp"
#include <cstring>
#line 7 "numeric/arithmetic.hpp"
#include <string>
#line 14 "numeric/arithmetic.hpp"
#include <atcoder/math>
#line 21 "numeric/arithmetic.hpp"
#line 25 "numeric/arithmetic.hpp"
#line 2 "utility/internal/functional_base.hpp"
namespace uni {
template<class P>
requires
requires(P p) {
p.first;
p.second;
}
inline P swapped(P& pair) {
return P{ pair.second, pair.first };
}
} // namespace uni
#line 27 "numeric/arithmetic.hpp"
#line 2 "numeric/internal/number_base.hpp"
#line 6 "numeric/internal/number_base.hpp"
#include <string_view>
#line 14 "numeric/internal/number_base.hpp"
#line 18 "numeric/internal/number_base.hpp"
#line 2 "adaptor/string.hpp"
#line 6 "adaptor/string.hpp"
#line 2 "adaptor/internal/advanced_container.hpp"
#line 8 "adaptor/internal/advanced_container.hpp"
#line 11 "adaptor/internal/advanced_container.hpp"
#line 15 "adaptor/internal/advanced_container.hpp"
#line 2 "numeric/internal/mod.hpp"
#line 6 "numeric/internal/mod.hpp"
namespace uni {
template<class T, class R>
requires
internal::remainder_calculable<T, R> &&
internal::subtractable<T, R> &&
internal::unary_subtractable<T>
inline T mod(T x, const R& r) noexcept(NO_EXCEPT) {
if(x >= 0) return x % r;
x = -x % r;
if(x != 0) x = r - x;
return x;
}
} // namespace uni
#line 2 "iterable/internal/operation_base.hpp"
#line 6 "iterable/internal/operation_base.hpp"
#include <sstream>
#include <numeric>
#line 11 "iterable/internal/operation_base.hpp"
namespace uni {
template<std::input_iterator I, std::sentinel_for<I> S>
std::string join(I first, S last, const char* sep = "") noexcept(NO_EXCEPT) {
if(first == last) return "";
std::ostringstream res;
while(true) {
res << *first;
std::ranges::advance(first, 1);
if(first == last) break;
res << sep;
}
return res.str();
}
template<std::ranges::input_range R>
std::string join(R&& range, const char* sep = "") noexcept(NO_EXCEPT) {
return join(ALL(range), sep);
}
template<class I, class T = std::iter_value_t<I>>
requires std::sentinel_for<I, I>
T sum(I first, I last, const T& base = T()) noexcept(NO_EXCEPT) {
return std::accumulate(first, last, base);
}
template<std::ranges::input_range R, class T = std::ranges::range_value_t<R>>
auto sum(R&& range, T base = T()) noexcept(NO_EXCEPT) {
auto&& r = range | std::views::common;
return sum(ALL(r), base);
}
} // namesapce uni
#line 18 "adaptor/internal/advanced_container.hpp"
#define UNI_ADVANCED_CONTAINER_OPERATOR(op_assign, op, concepts) \
auto& operator op_assign(const value_type& v) noexcept(NO_EXCEPT) \
requires concepts<value_type> \
{ \
if constexpr(concepts<Base, value_type>) { \
this->Base::operator op_assign(v); \
} \
else { \
REP(itr, ALL(*this)) *itr op_assign v; \
} \
return *this; \
} \
\
auto& operator op_assign(const advanced_container& rhs) noexcept(NO_EXCEPT) \
requires concepts<value_type> \
{ \
if constexpr(concepts<Base>) { \
this->Base::operator op_assign(*rhs._base()); \
} \
else { \
auto itr = std::ranges::begin(*this), rhs_itr = std::ranges::begin(rhs); \
auto end = std::ranges::end(*this); \
for(; itr != end; ++itr, ++rhs_itr) { \
*itr op_assign *rhs_itr; \
} \
} \
return *this; \
} \
\
template<class T = value_type> \
requires \
concepts<value_type> && \
(std::convertible_to<T, value_type> || std::same_as<T, advanced_container>) \
friend auto operator op(advanced_container lhs, const T& rhs) noexcept(NO_EXCEPT) { \
return lhs op_assign rhs; \
} \
\
template<class T = value_type> \
requires \
concepts<value_type> && std::convertible_to<T, value_type> \
friend auto operator op(const T& lhs, advanced_container rhs) noexcept(NO_EXCEPT) { \
return advanced_container(rhs.size(), lhs) op_assign rhs; \
}
namespace uni {
namespace internal {
template<class Base>
struct advanced_container : Base {
private:
inline Base* _base() noexcept(NO_EXCEPT) {
return static_cast<Base*>(this);
}
inline const Base* _base() const noexcept(NO_EXCEPT) {
return static_cast<const Base*>(this);
}
public:
using Base::Base;
advanced_container(const Base& base) : Base(base) {}
using size_type = decltype(std::ranges::size(std::declval<Base>()));
using value_type = Base::value_type;
inline auto ssize() const noexcept(NO_EXCEPT) { return std::ranges::ssize(*this->_base()); }
inline const auto& operator[](internal::size_t p) const noexcept(NO_EXCEPT) {
p = p < 0 ? p + this->size() : p;
assert(0 <= p && p < this->ssize());
return this->Base::operator[](p);
}
inline auto& operator[](internal::size_t p) noexcept(NO_EXCEPT) {
p = p < 0 ? p + this->size() : p;
assert(0 <= p && p < this->ssize());
return this->Base::operator[](p);
}
inline auto& fill(const value_type& v) noexcept(NO_EXCEPT) {
std::ranges::fill(*this, v);
return *this;
}
inline auto& swap(const size_type i, const size_type j) noexcept(NO_EXCEPT) {
std::swap(this->operator[](i), this->operator[](j));
return *this;
}
inline auto& sort() noexcept(NO_EXCEPT) {
std::ranges::sort(*this);
return *this;
}
template<class F>
inline auto& sort(F&& f) noexcept(NO_EXCEPT) {
std::ranges::sort(*this, std::forward<F>(f));
return *this;
}
inline auto& stable_sort() noexcept(NO_EXCEPT) {
std::ranges::stable_sort(*this);
return *this;
}
template<class F>
inline auto& stable_sort(F&& f) noexcept(NO_EXCEPT) {
std::ranges::stable_sort(*this, std::forward<F>(f));
return *this;
}
inline auto& reverse() noexcept(NO_EXCEPT) {
std::ranges::reverse(*this);
return *this;
}
inline auto count(const value_type& v) const noexcept(NO_EXCEPT) {
return std::ranges::count(*this, v);
}
template<class F>
inline auto count_if(F&& f) const noexcept(NO_EXCEPT) {
return std::ranges::count_if(*this, std::forward<F>(f));
}
inline auto& resize(const size_type k) noexcept(NO_EXCEPT) {
this->Base::resize(k);
return *this;
}
inline auto& resize(const size_type k, const value_type v) noexcept(NO_EXCEPT) {
this->Base::resize(k, v);
return *this;
}
template<class F>
inline auto& shuffle(F&& f) noexcept(NO_EXCEPT) {
std::ranges::shuffle(*this, std::forward<F>(f));
return *this;
}
inline auto& unique() noexcept(NO_EXCEPT) {
const auto rest = std::ranges::unique(*this);
this->erase(ALL(rest));
return *this;
}
template<class T>
inline auto binary_search(const T& v) noexcept(NO_EXCEPT) {
return std::ranges::binary_search(*this, v);
}
template<class T>
inline auto lower_bound(const T& v) noexcept(NO_EXCEPT) {
return std::ranges::lower_bound(*this, v);
}
template<class T>
inline auto upper_bound(const T& v) noexcept(NO_EXCEPT) {
return std::ranges::upper_bound(*this, v);
}
inline auto join(const char* sep = "") noexcept(NO_EXCEPT) {
return uni::join(*this, sep);
}
inline auto sum() const noexcept(NO_EXCEPT) { return uni::sum(*this); }
inline auto max() const noexcept(NO_EXCEPT) { return std::ranges::max(*this->_base()); }
inline auto min() const noexcept(NO_EXCEPT) { return std::ranges::min(*this); }
inline auto begin() noexcept(NO_EXCEPT) { return std::ranges::begin(*this->_base()); }
inline auto begin() const noexcept(NO_EXCEPT) { return std::ranges::begin(*this->_base()); }
inline auto end() noexcept(NO_EXCEPT) { return std::ranges::end(*this->_base()); }
inline auto end() const noexcept(NO_EXCEPT) { return std::ranges::end(*this->_base()); }
UNI_ADVANCED_CONTAINER_OPERATOR(+=, +, internal::weakly_addition_assignable)
UNI_ADVANCED_CONTAINER_OPERATOR(-=, -, internal::weakly_subtraction_assignable)
UNI_ADVANCED_CONTAINER_OPERATOR(*=, *, internal::weakly_multipliation_assignalbe)
UNI_ADVANCED_CONTAINER_OPERATOR(/=, /, internal::weakly_division_assignable)
UNI_ADVANCED_CONTAINER_OPERATOR(%=, %, internal::weakly_remainder_assignable)
UNI_ADVANCED_CONTAINER_OPERATOR(&=, &, internal::weakly_bitand_assignable)
UNI_ADVANCED_CONTAINER_OPERATOR(|=, |, internal::weakly_bitor_assignable)
UNI_ADVANCED_CONTAINER_OPERATOR(^=, ^, internal::weakly_bitxor_assignable)
};
} // namespace internal
} // namespace uni
#undef UNI_ADVANCED_CONTAINER_OPERATOR
#line 8 "adaptor/string.hpp"
namespace uni {
using string = internal::advanced_container<std::string>;
} // namespace uni
namespace std {
template<>
struct hash<uni::string> {
inline auto operator()(const uni::string& key) const noexcept(NO_EXCEPT) {
return std::hash<std::string>{}(static_cast<std::string>(key));
}
};
}
#line 2 "adaptor/vector.hpp"
#line 6 "adaptor/vector.hpp"
#line 9 "adaptor/vector.hpp"
namespace uni {
template<class... Args>
using vector = internal::advanced_container<std::vector<Args...>>;
} // namespace uni
#line 21 "numeric/internal/number_base.hpp"
namespace uni {
template<std::size_t B, class T>
uni::string to_base_n_string(T v) noexcept(NO_EXCEPT) {
constexpr std::string_view CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
static_assert(0 < B and B <= std::ranges::size(CHARS));
assert(0 <= v);
uni::string res;
while(v > 0) {
res += CHARS[v%B];
v /= B;
}
std::reverse(ALL(res));
return res;
}
template<class T>
uni::string to_base_n_string(T v, const uni::internal::size_t b) noexcept(NO_EXCEPT) {
constexpr std::string_view CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
assert(1 < b && b <= std::ranges::ssize(CHARS));
assert(0 <= v);
if(v == 0) return "0";
uni::string res;
while(v > 0) {
res += CHARS[v % b];
v /= b;
}
std::reverse(ALL(res));
return res;
}
template<class T>
uni::vector<T> to_base_n_vector(T v, const uni::internal::size_t b) noexcept(NO_EXCEPT) {
assert(1 < b);
assert(0 <= v);
uni::vector<T> res;
while(v > 0) {
res.push_back(v%b);
v /= b;
}
return res;
}
template<std::bidirectional_iterator I, class T = typename std::iterator_traits<I>::value_type>
T from_base_n_sequence(I begin, I end, const uni::internal::size_t b) noexcept(NO_EXCEPT) {
assert(1 < b);
if(begin == end) return 0;
T res = 0;
for(auto itr=end; itr-- != begin; ) {
res *= b;
res += *itr;
}
return res;
}
template<class T, std::forward_iterator I>
T from_base_n_string(I begin, I end, const uni::internal::size_t b) noexcept(NO_EXCEPT) {
assert(1 < b);
if(begin == end) return 0;
T sgn = 1;
if(*begin == '-') {
sgn = -1;
++begin;
}
T res = 0;
for(auto itr=begin; itr != end; ++itr) {
res *= b;
if('0' <= *itr && *itr <= '9') {
res += *itr - '0';
}
else if('a' <= *itr && *itr <= 'z') {
res += *itr - 'a' + 10;
}
else if('A' <= *itr && *itr <= 'Z'){
res += *itr - 'A' + 10;
}
else {
assert(false);
}
}
return res * sgn;
}
template<std::ranges::bidirectional_range R, class T = std::ranges::range_value_t<R>>
requires std::ranges::common_range<R>
T from_base_n_sequence(R range, const uni::internal::size_t b) noexcept(NO_EXCEPT) {
return from_base_n_sequence(std::ranges::begin(range), std::ranges::end(range), b);
}
template<class T, std::ranges::bidirectional_range R>
requires std::ranges::common_range<R>
T from_base_n_string(R range, const uni::internal::size_t b) noexcept(NO_EXCEPT) {
return from_base_n_string<T>(std::ranges::begin(range), std::ranges::end(range), b);
}
} // namespace uni
#line 29 "numeric/arithmetic.hpp"
#line 2 "iterable/operation.hpp"
#line 6 "iterable/operation.hpp"
#include <initializer_list>
#line 9 "iterable/operation.hpp"
#include <valarray>
#line 17 "iterable/operation.hpp"
#line 21 "iterable/operation.hpp"
#line 2 "internal/ranges.hpp"
#line 6 "internal/ranges.hpp"
#include <tuple>
#line 11 "internal/ranges.hpp"
namespace uni {
namespace internal {
template<class Range>
concept resizable_range
= std::ranges::range<Range> &&
requires (Range& r) { r.resize(0); };
template<class range>
concept simple_view
= std::ranges::view<range> && std::ranges::range<const range> &&
std::same_as<std::ranges::iterator_t<range>, std::ranges::iterator_t<const range>> &&
std::same_as<std::ranges::sentinel_t<range>, std::ranges::sentinel_t<const range>>;
template<class... Ranges>
concept zip_is_common = (sizeof...(Ranges) == 1 && (std::ranges::common_range<Ranges> && ...))
|| (!(std::ranges::bidirectional_range<Ranges> && ...) && (std::ranges::common_range<Ranges> && ...))
|| ((std::ranges::random_access_range<Ranges> && ...) && (std::ranges::sized_range<Ranges> && ...));
template<bool Const, class... Views>
concept all_contiguous = (std::ranges::contiguous_range<maybe_const_t<Const, Views>> && ...);
template<bool Const, class... Views>
concept all_random_access = (std::ranges::random_access_range<maybe_const_t<Const, Views>> && ...);
template<bool Const, class... Views>
concept all_bidirectional = (std::ranges::bidirectional_range<maybe_const_t<Const, Views>> && ...);
template<bool Const, class... Views>
concept all_forward = (std::ranges::forward_range<maybe_const_t<Const, Views>> && ...);
template<bool Const, class... Views> struct zip_view_iterator_category {};
template<bool Const, class... Views>
requires all_forward<Const, Views...>
struct zip_view_iterator_category<Const, Views...> {
using iterator_category = std::input_iterator_tag;
};
template<bool Const, class... Views>
static auto _most_primitive_iterator_concept() noexcept(NO_EXCEPT) {
if constexpr(all_random_access<Const, Views...>)
return std::random_access_iterator_tag{};
else if constexpr(all_bidirectional<Const, Views...>)
return std::bidirectional_iterator_tag{};
else if constexpr(all_forward<Const, Views...>)
return std::forward_iterator_tag{};
else
return std::input_iterator_tag{};
}
template<bool Const, class... Views>
using most_primitive_iterator_concept = decltype(_most_primitive_iterator_concept<Const, Views...>());
template<class Range, bool Const>
using range_iterator_category = typename std::iterator_traits<
std::ranges::iterator_t<maybe_const_t<Const, Range>>
>::iterator_category;
template<class Range>
static constexpr auto _iterator_concept() noexcept(NO_EXCEPT) {
if constexpr(std::ranges::random_access_range<Range>)
return std::random_access_iterator_tag{};
else if constexpr(std::ranges::bidirectional_range<Range>)
return std::bidirectional_iterator_tag{};
else if constexpr(std::ranges::forward_range<Range>)
return std::forward_iterator_tag{};
else
return std::input_iterator_tag{};
}
template<class Range>
using iterator_concept = decltype(_iterator_concept<Range>());
template<std::ranges::range Range> struct cached_position {
constexpr bool has_value() const { return false; }
constexpr std::ranges::iterator_t<Range> get(const Range&) const {
__builtin_unreachable();
}
constexpr void set(const Range &, const std::ranges::iterator_t<Range> &) const {}
};
template<std::ranges::forward_range Range>
struct cached_position<Range> : protected std::optional<std::ranges::iterator_t<Range>> {
using std::optional<std::ranges::iterator_t<Range>>::optioanl;
using std::optional<std::ranges::iterator_t<Range>>::has_value;
constexpr std::ranges::iterator_t<Range> get(const Range&) const {
assert(this->has_value());
return **this;
}
constexpr void set(const Range&, const std::ranges::iterator_t<Range>& itr) {
assert(!this->has_value());
this->emplace(*itr);
}
};
template<std::ranges::random_access_range Range>
requires(sizeof(std::ranges::range_difference_t<Range>) <= sizeof(std::ranges::iterator_t<Range>))
struct cached_position<Range> {
private:
std::ranges::range_difference_t<Range> _offset = -1;
public:
cached_position() = default;
constexpr cached_position(const cached_position &) = default;
constexpr cached_position(cached_position &&other) noexcept {
*this = std::move(other);
}
constexpr cached_position &operator=(const cached_position &) = default;
constexpr cached_position &operator=(cached_position &&other) noexcept {
// Propagate the cached offset, but invalidate the source.
this->_offset = other._offset;
other._offset = -1;
return *this;
}
constexpr bool has_value() const { return this->_offset >= 0; }
constexpr std::ranges::iterator_t<Range> get(Range& range) const {
assert(this->has_value());
return std::ranges::begin(range) + this->_offset;
}
constexpr void set(Range &range, const std::ranges::iterator_t<Range> &itr) {
assert(!this->has_value());
this->_offset = itr - std::ranges::begin(range);
}
};
template<typename T, int Disc>
struct absent { };
template<bool PRESENT, class T, int Disc = 0>
using maybe_present_t = std::conditional_t<PRESENT, T, absent<T, Disc>>;
} // namespace internal
namespace views::adaptor {
template<class Adaptor, class... Args>
concept adaptor_invocable = requires { std::declval<Adaptor>()(std::declval<Args>()...); };
template<class Adaptor, class... Args>
concept adaptor_partial_app_viable =
(Adaptor::arity > 1) && (sizeof...(Args) == Adaptor::arity - 1) &&
(std::constructible_from<std::remove_cvref_t<Args>, Args> && ...);
template<class Adaptor, class... Args> struct partial;
template<class, class> struct pipe;
template<class Derived> struct range_adaptor_closure {};
template<class T, class U>
requires(!std::same_as<T, range_adaptor_closure<U>>)
void is_range_adaptor_closure_fn(const T &, const range_adaptor_closure<U> &);
template<class T>
concept is_range_adaptor_closure = requires(T t) { adaptor::is_range_adaptor_closure_fn(t, t); };
template<class Self, class Range>
requires is_range_adaptor_closure<Self> && adaptor_invocable<Self, Range>
constexpr auto operator|(Range&& range, Self&& self) {
return std::forward<Self>(self)(std::forward<Range>(range));
}
template<class Lhs, class Rhs>
requires is_range_adaptor_closure<Lhs> && is_range_adaptor_closure<Rhs>
constexpr auto operator|(Lhs&& lhs, Rhs&& rhs) {
return pipe<std::remove_cvref_t<Lhs>, std::remove_cvref_t<Rhs>>{ std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
}
template<class Derived> struct range_adaptor {
template<class... Args>
requires adaptor_partial_app_viable<Derived, Args...>
inline constexpr auto operator()(Args&& ..._args) const noexcept(NO_EXCEPT) {
return partial<Derived, std::remove_cvref_t<Args>...>{
std::forward<Args>(_args)...
};
}
};
template<class Adaptor>
concept closure_has_simple_call_op = Adaptor::has_simple_call_op;
template<class Adaptor, class... Args>
concept adaptor_has_simple_extra_args =
Adaptor::has_simple_extra_args ||
Adaptor::template has_simple_extra_args<Args...>;
template<class Adaptor, class... Args>
struct partial : range_adaptor_closure<partial<Adaptor, Args...>> {
std::tuple<Args...> args;
constexpr partial(Args... _args) noexcept(NO_EXCEPT) : args(std::move(_args)...) {}
template<class Range>
requires adaptor_invocable<Adaptor, Range, const Args &...>
inline constexpr auto operator()(Range&& range) const & noexcept(NO_EXCEPT) {
const auto forwarder = [&range](const auto &..._args) constexpr noexcept(NO_EXCEPT) {
return Adaptor{}(std::forward<Range>(range), _args...);
};
return std::apply(forwarder, this->args);
}
template<class Range>
requires adaptor_invocable<Adaptor, Range, Args...>
inline constexpr auto operator()(Range&& range) && noexcept(NO_EXCEPT) {
const auto forwarder = [&range](auto &..._args) constexpr noexcept(NO_EXCEPT) {
return Adaptor{}(std::forward<Range>(range), std::move(_args)...);
};
return std::apply(forwarder, this->args);
}
template<class Range>
inline constexpr auto operator()(Range&& range) const && = delete;
};
template<class Adaptor, class Arg>
struct partial<Adaptor, Arg> : range_adaptor_closure<partial<Adaptor, Arg>> {
Arg arg;
constexpr partial(Arg _arg) noexcept(NO_EXCEPT) : arg(std::move(_arg)) {}
template<class Range>
requires adaptor_invocable<Adaptor, Range, const Arg &>
inline constexpr auto operator()(Range&& range) const & noexcept(NO_EXCEPT) {
return Adaptor{}(std::forward<Range>(range), this->arg);
}
template<class Range>
requires adaptor_invocable<Adaptor, Range, Arg>
inline constexpr auto operator()(Range&& range) && noexcept(NO_EXCEPT) {
return Adaptor{}(std::forward<Range>(range), std::move(this->arg));
}
template<class Range>
inline constexpr auto operator()(Range&& range) const && = delete;
};
template<class Adaptor, class... Args>
requires adaptor_has_simple_extra_args<Adaptor, Args...> && (std::is_trivially_copyable_v<Args> && ...)
struct partial<Adaptor, Args...> : range_adaptor_closure<partial<Adaptor, Args...>> {
std::tuple<Args...> args;
constexpr partial(Args... _args) noexcept(NO_EXCEPT) : args(std::move(_args)...) {}
template<class Range>
requires adaptor_invocable<Adaptor, Range, const Args &...>
inline constexpr auto operator()(Range&& range) const noexcept(NO_EXCEPT) {
const auto forwarder = [&range](const auto &..._args) constexpr noexcept(NO_EXCEPT) {
return Adaptor{}(std::forward<Range>(range), _args...);
};
return std::apply(forwarder, this->args);
}
static constexpr bool has_simple_call_op = true;
};
template<class Adaptor, class Arg>
requires adaptor_has_simple_extra_args<Adaptor, Arg> &&
std::is_trivially_copyable_v<Arg>
struct partial<Adaptor, Arg> : range_adaptor_closure<partial<Adaptor, Arg>> {
Arg arg;
constexpr partial(Arg _arg) noexcept(NO_EXCEPT) : arg(std::move(_arg)) {}
template<class Range>
requires adaptor_invocable<Adaptor, Range, const Arg &>
inline constexpr auto operator()(Range&& range) const noexcept(NO_EXCEPT) {
return Adaptor{}(std::forward<Range>(range), this->arg);
}
static constexpr bool has_simple_call_op = true;
};
template<class Lhs, class Rhs, class Range>
concept pipe_invocable = requires {
std::declval<Rhs>()(std::declval<Lhs>()(std::declval<Range>()));
};
template<class Lhs, class Rhs> struct pipe : range_adaptor_closure<pipe<Lhs, Rhs>> {
[[no_unique_address]] Lhs lhs;
[[no_unique_address]] Rhs rhs;
constexpr pipe(Lhs _lhs, Rhs _rhs) noexcept(NO_EXCEPT) : lhs(std::move(_lhs)), rhs(std::move(_rhs)) {}
template<class Range>
requires pipe_invocable<const Lhs &, const Rhs &, Range>
inline constexpr auto operator()(Range&& range) const & noexcept(NO_EXCEPT) {
return rhs(lhs(std::forward<Range>(range)));
}
template<class Range>
requires pipe_invocable<Lhs, Rhs, Range>
inline constexpr auto operator()(Range&& range) && noexcept(NO_EXCEPT) {
return std::move(rhs)(std::move(lhs)(std::forward<Range>(range)));
}
template<class Range>
inline constexpr auto operator()(Range&& range) const && = delete;
};
template<class Lhs, class Rhs>
requires closure_has_simple_call_op<Lhs> && closure_has_simple_call_op<Rhs>
struct pipe<Lhs, Rhs> : range_adaptor_closure<pipe<Lhs, Rhs>> {
[[no_unique_address]] Lhs lhs;
[[no_unique_address]] Rhs rhs;
constexpr pipe(Lhs _lhs, Rhs _rhs) noexcept(NO_EXCEPT) : lhs(std::move(_lhs)), rhs(std::move(_rhs)) {}
template<class Range>
requires pipe_invocable<const Lhs &, const Rhs &, Range>
inline constexpr auto operator()(Range&& range) const noexcept(NO_EXCEPT) {
return rhs(lhs(std::forward<Range>(range)));
}
static constexpr bool has_simple_call_op = true;
};
} // namespace views::adaptor
} // namespace uni
#line 28 "iterable/operation.hpp"
#line 2 "iterable/z_array.hpp"
#line 6 "iterable/z_array.hpp"
#line 9 "iterable/z_array.hpp"
#line 2 "adaptor/valarray.hpp"
#line 11 "adaptor/valarray.hpp"
#line 14 "adaptor/valarray.hpp"
#line 16 "adaptor/valarray.hpp"
namespace uni {
template<class T> struct valarray : internal::advanced_container<std::valarray<T>> {
private:
using base = internal::advanced_container<std::valarray<T>>;
public:
using size_type = internal::size_t;
using iterator = T*;
using const_iterator = const T*;
protected:
inline bool _validate_index_in_right_open([[maybe_unused]] const size_type p) const noexcept(NO_EXCEPT) {
return 0 <= p and p < this->size();
}
inline bool _validate_index_in_closed([[maybe_unused]] const size_type p) const noexcept(NO_EXCEPT) {
return 0 <= p and p <= this->size();
}
inline bool _validate_rigth_open_interval([[maybe_unused]] const size_type l, [[maybe_unused]] const size_type r) const noexcept(NO_EXCEPT) {
return 0 <= l and l <= r and r <= this->size();
}
inline size_type _positivize_index(const size_type p) const noexcept(NO_EXCEPT) {
return p < 0 ? this->size() + p : p;
}
public:
valarray() noexcept(NO_EXCEPT) {}
explicit valarray(const std::size_t length, const T& val = T{}) noexcept(NO_EXCEPT) : base(val, length) {}
template<std::input_iterator I, std::sentinel_for<I> S>
valarray(I first, S last) noexcept(NO_EXCEPT) : base(std::ranges::distance(first, last)) { std::ranges::copy(first, last, std::ranges::begin(*this)); }
template<class U> valarray(const U* pointer, const size_t n) noexcept(NO_EXCEPT) : base(pointer, n) {};
valarray(const std::slice_array<T>& arr) noexcept(NO_EXCEPT) : base(arr) {};
valarray(const std::gslice_array<T>& arr) noexcept(NO_EXCEPT) : base(arr) {};
valarray(const std::mask_array<T>& arr) noexcept(NO_EXCEPT) : base(arr) {};
valarray(const std::indirect_array<T>& arr) noexcept(NO_EXCEPT) : base(arr) {};
valarray(const std::initializer_list<T>& init) noexcept(NO_EXCEPT) : base(init) {}
valarray(const internal::advanced_container<std::valarray<T>>& arr) noexcept(NO_EXCEPT) : base(arr) {}
#ifdef __GNUC__
template<class Dom> valarray(const std::_Expr<Dom,T>& expr) noexcept(NO_EXCEPT) : base(expr) {}
#endif
inline auto size() const noexcept(NO_EXCEPT) { return static_cast<size_type>(this->base::size()); }
inline void reserve(const size_type) noexcept(NO_EXCEPT) { /* do nothing */ }
template<std::input_iterator I, std::sentinel_for<I> S>
inline void assign(I first, S last) noexcept(NO_EXCEPT) {
this->resize(std::ranges::distance(first, last));
std::ranges::copy(first, last, std::ranges::begin(*this));
}
inline void assign(const std::size_t length, const T& val = T{}) noexcept(NO_EXCEPT) {
this->base::resize(length, val);
}
inline void resize(const std::size_t length, const T& val = T{}) noexcept(NO_EXCEPT) {
base temp = *this;
this->assign(length, val);
std::move(std::begin(temp), std::min(std::end(temp), std::next(std::begin(temp), length)), std::begin(*this));
}
inline const T& operator[](size_type pos) const noexcept(NO_EXCEPT) {
pos = this->_positivize_index(pos), assert(this->_validate_index_in_right_open(pos));
return this->base::operator[](pos);
}
inline T& operator[](size_type pos) noexcept(NO_EXCEPT) {
pos = this->_positivize_index(pos), assert(this->_validate_index_in_right_open(pos));
return this->base::operator[](pos);
}
inline const T& back() const noexcept(NO_EXCEPT) { return *std::prev(this->end()); }
inline T& back() noexcept(NO_EXCEPT) { return *std::prev(this->end()); }
inline const T& front() const noexcept(NO_EXCEPT) { return *this->begin(); }
inline T& front() noexcept(NO_EXCEPT) { return *this->begin(); }
inline auto rbegin() noexcept(NO_EXCEPT) { return std::make_reverse_iterator(std::ranges::end(*this)); }
inline auto rend() noexcept(NO_EXCEPT) { return std::make_reverse_iterator(std::ranges::begin(*this)); }
inline auto rbegin() const noexcept(NO_EXCEPT) { return std::make_reverse_iterator(std::ranges::end(*this)); }
inline auto rend() const noexcept(NO_EXCEPT) { return std::make_reverse_iterator(std::ranges::begin(*this)); }
};
} // namespace uni
#line 11 "iterable/z_array.hpp"
namespace uni {
// Thanks to: atcoder::z_algorithm
template<class SizeType = internal::size_t, class Container = valarray<SizeType>>
struct z_array : Container {
using size_type = SizeType;
template<std::input_iterator I, std::sentinel_for<I> S>
z_array(I first, S last) : Container(std::ranges::distance(first, last), {}) {
const size_type n = static_cast<size_type>(std::ranges::distance(first, last));
if(n == 0) return;
for(size_type i = 1, j = 0; i < n; ++i) {
size_type& k = this->operator[](i);
k = (j + this->operator[](j) <= i) ? 0 : std::ranges::min(j + this->operator[](j) - i, this->operator[](i - j));
while(i + k < n and first[k] == first[i + k]) ++k;
if(j + this->operator[](j) < i + this->operator[](i)) j = i;
}
*this->begin() = n;
}
template<std::ranges::input_range R>
explicit z_array(R&& range) : z_array(ALL(range)) {}
};
} // namespace uni
#line 31 "iterable/operation.hpp"
#line 2 "view/concat.hpp"
#line 11 "view/concat.hpp"
#line 18 "view/concat.hpp"
namespace uni {
namespace internal {
namespace view_impl {
template<std::ranges::input_range V0, std::ranges::input_range V1>
requires std::ranges::view<V0> && std::ranges::view<V1>
struct concat_view : std::ranges::view_interface<concat_view<V0, V1>> {
private:
V0 _b0;
V1 _b1;
template<bool Const> using B0 = internal::maybe_const_t<Const, V0>;
template<bool Const> using B1 = internal::maybe_const_t<Const, V1>;
template<bool Const> struct iterator_tag {};
template<bool Const>
requires std::ranges::forward_range<B0<Const>> && std::ranges::forward_range<B1<Const>>
struct iterator_tag<Const> {
public:
using iterator_category = uni::internal::most_primitive_iterator_tag<
typename std::iterator_traits<std::ranges::iterator_t<B0<Const>>>::iterator_category,
typename std::iterator_traits<std::ranges::iterator_t<B1<Const>>>::iterator_category
>;
};
public:
template<bool> class iterator;
constexpr explicit concat_view(V0 v0, V1 v1) noexcept(NO_EXCEPT)
: _b0(std::move(v0)), _b1(std::move(v1))
{}
inline constexpr std::pair<V0, V1> base() const & noexcept(NO_EXCEPT)
requires std::copy_constructible<V0> && std::copy_constructible<V0>
{
return { this->_b0, this->_b1 };
}
inline constexpr std::pair<V0,V1> base() && noexcept(NO_EXCEPT) {
return { std::move(this->_b0), std::move(this->_b1) };
}
inline constexpr auto begin() noexcept(NO_EXCEPT)
requires (!internal::simple_view<V0> && !internal::simple_view<V1>)
{
return iterator<false>(this, std::ranges::begin(this->_b0), std::ranges::begin(this->_b1), 0);
}
inline constexpr auto begin() const noexcept(NO_EXCEPT)
requires std::ranges::range<const V0> && std::ranges::range<const V1>
{
return iterator<true>(this, std::ranges::begin(this->_b0), std::ranges::begin(this->_b1), 0);
}
inline constexpr auto end() noexcept(NO_EXCEPT)
requires (!internal::simple_view<V0> && !internal::simple_view<V1>)
{
if constexpr(std::ranges::common_range<V0> && std::ranges::common_range<V1>) {
return iterator<false>(this, std::ranges::end(this->_b0), std::ranges::end(this->_b1), 1);
}
else {
return std::default_sentinel;
}
}
inline constexpr auto end() const noexcept(NO_EXCEPT)
requires std::ranges::range<const V0> && std::ranges::range<const V1>
{
if constexpr(std::ranges::common_range<const V0> && std::ranges::common_range<const V1>) {
return iterator<true>(this, std::ranges::end(this->_b0), std::ranges::end(this->_b1), 1);
}
else {
return std::default_sentinel;
}
}
inline constexpr auto size() noexcept(NO_EXCEPT)
requires std::ranges::sized_range<V0> && std::ranges::sized_range<V1>
{
return static_cast<std::size_t>(std::ranges::distance(this->_b0) + std::ranges::distance(this->_b1));
}
inline constexpr auto size() const noexcept(NO_EXCEPT)
requires std::ranges::sized_range<const V0> && std::ranges::sized_range<const V1>
{
return static_cast<std::size_t>(std::ranges::distance(this->_b0) + std::ranges::distance(this->_b1));
}
};
template<std::ranges::input_range V0, std::ranges::input_range V1>
requires std::ranges::view<V0> && std::ranges::view<V1>
template<bool Const>
struct concat_view<V0, V1>::iterator : iterator_tag<Const> {
private:
using Parent = internal::maybe_const_t<Const, concat_view>;
using B0 = concat_view::B0<Const>;
using B1 = concat_view::B1<Const>;
std::ranges::iterator_t<B0> _c0 = std::ranges::iterator_t<B0>();
std::ranges::iterator_t<B0> _b0 = std::ranges::iterator_t<B0>();
std::ranges::sentinel_t<B0> _e0 = std::ranges::sentinel_t<B0>();
std::ranges::iterator_t<B1> _c1 = std::ranges::iterator_t<B1>();
std::ranges::iterator_t<B1> _b1 = std::ranges::iterator_t<B1>();
std::ranges::sentinel_t<B1> _e1 = std::ranges::sentinel_t<B1>();
int _block = 0;
constexpr iterator(Parent *const parent, const std::ranges::iterator_t<B0> c0, const std::ranges::iterator_t<B1> c1, const int block) noexcept(NO_EXCEPT)
: _c0(std::move(c0)), _b0(std::ranges::begin(parent->_b0)), _e0(std::ranges::end(parent->_b0)),
_c1(std::move(c1)), _b1(std::ranges::begin(parent->_b1)), _e1(std::ranges::end(parent->_b1)),
_block(block || std::ranges::empty(parent->_b0))
{}
friend concat_view;
public:
using difference_type = std::common_type_t<std::ranges::range_difference_t<B0>, std::ranges::range_difference_t<B1>>;
using value_type = std::common_type_t<std::ranges::range_value_t<B0>, std::ranges::range_value_t<B1>>;
using reference_type = std::common_reference_t<std::ranges::range_reference_t<B0>, std::ranges::range_reference_t<B1>>;
using iterator_concept = most_primitive_iterator_concept<Const, V0, V1>;
iterator() noexcept(NO_EXCEPT)
requires std::default_initializable<std::ranges::iterator_t<B0>> &&
std::default_initializable<std::ranges::iterator_t<B0>>
= default;
constexpr iterator(iterator<!Const> itr) noexcept(NO_EXCEPT)
requires
Const &&
std::convertible_to<std::ranges::iterator_t<V0>, std::ranges::iterator_t<B0>> &&
std::convertible_to<std::ranges::sentinel_t<V0>, std::ranges::sentinel_t<B0>> &&
std::convertible_to<std::ranges::iterator_t<V1>, std::ranges::iterator_t<B1>> &&
std::convertible_to<std::ranges::sentinel_t<V1>, std::ranges::sentinel_t<B1>>
: _c0(std::move(itr._c0)), _b0(std::move(itr._b0)), _e0(std::move(itr._e0)),
_c1(std::move(itr._c0)), _b1(std::move(itr._b0)), _e1(std::move(itr._e1)),
_block(itr._block)
{}
inline constexpr std::variant<std::ranges::iterator_t<B0>, std::ranges::iterator_t<B1>>
base() && noexcept(NO_EXCEPT) {
if(this->_block == 0) return std::move(this->_c0);
else return std::move(this->_C1);
}
inline constexpr
std::variant<
std::reference_wrapper<const std::ranges::iterator_t<B0>>,
std::reference_wrapper<const std::ranges::iterator_t<B1>>
>
base() const & noexcept {
if(this->_block == 0) return std::move(this->_c0);
else return std::move(this->_c1);
}
inline constexpr reference_type operator*() const noexcept(NO_EXCEPT)
{
if(this->_block == 0) return *this->_c0;
else return *this->_c1;
}
inline constexpr iterator& operator++() noexcept(NO_EXCEPT)
{
assert(this->_c0 != this->_e0 or this->_c1 != this->_e1);
if(this->_block == 0) {
if(++this->_c0 == this->_e0) {
this->_block = 1;
assert(this->_c1 == this->_b1);
}
}
else {
++this->_c1;
}
return *this;
}
inline constexpr void operator++(int) noexcept(NO_EXCEPT) { ++*this; }
inline constexpr iterator operator++(int) noexcept(NO_EXCEPT)
requires std::ranges::forward_range<B0> && std::ranges::forward_range<B1>
{
const auto res = *this; ++*this; return res;
}
inline constexpr iterator& operator--() noexcept(NO_EXCEPT)
requires
std::ranges::bidirectional_range<B0> && std::ranges::bidirectional_range<B1> &&
std::bidirectional_iterator<std::ranges::sentinel_t<B0>>
{
if(this->_block == 1) {
if(this->_c1 == this->_b1) {
this->_block = 0;
this->_c0 = std::ranges::prev(this->_e0);
}
else {
--this->_c1;
}
}
else {
--this->_c0;
}
return *this;
}
inline constexpr iterator operator--(int) noexcept(NO_EXCEPT)
requires std::ranges::bidirectional_range<B0> && std::ranges::bidirectional_range<B1>
{
const auto res = *this; --*this; return res;
}
inline constexpr iterator& operator+=(const difference_type diff) noexcept(NO_EXCEPT)
requires
std::ranges::random_access_range<B0> && std::ranges::random_access_range<B1>
{
if(diff > 0) {
if(this->_block == 0) {
const auto missing = std::ranges::advance(this->_c0, diff, this->_e0);
if(this->_c0 == this->_e0) {
this->_block = 1;
assert(this->_c1 == this->_b1);
std::ranges::advance(this->_c1, missing, this->_e1);
}
}
else {
std::ranges::advance(this->_c1, diff, this->_e1);
}
}
if(diff < 0) {
if(this->_block == 1) {
const auto missing = std::ranges::advance(this->_c1, diff, this->_b1);
if(missing < 0) {
this->_block = 0;
assert(this->_c0 == this->_e0);
std::ranges::advance(this->_c0, missing, this->_b0);
}
}
else {
std::ranges::advance(this->_c0, diff, this->_b0);
}
}
return *this;
}
inline constexpr iterator& operator-=(const difference_type diff) noexcept(NO_EXCEPT)
requires std::ranges::random_access_range<B0> && std::ranges::random_access_range<B1>
{
return *this += -diff;
}
inline constexpr decltype(auto) operator[](const difference_type diff) const noexcept(NO_EXCEPT)
requires std::ranges::random_access_range<B0> && std::ranges::random_access_range<B1>
{
return *(*this + diff);
}
friend inline constexpr bool operator==(const iterator& lhs, std::default_sentinel_t) noexcept(NO_EXCEPT)
{
if(lhs._block == 0) return false;
if(lhs._block == 1) return lhs._c1 == lhs._e1;
assert(false);
}
friend inline constexpr bool operator==(const iterator& lhs, const iterator& rhs) noexcept(NO_EXCEPT)
requires
std::equality_comparable<std::ranges::iterator_t<B0>> &&
std::equality_comparable<std::ranges::iterator_t<B1>>
{
if(lhs._block != rhs._block) return false;
return lhs._block == 0 ? lhs._c0 == rhs._c0 : lhs._c1 == rhs._c1;
}
friend inline constexpr auto operator<=>(const iterator& lhs, const iterator& rhs) noexcept(NO_EXCEPT)
requires std::ranges::random_access_range<B0> && std::ranges::random_access_range<B1>
{
if(lhs._block != rhs._block) return lhs._block <=> rhs._block;
return lhs._block == 0 ? lhs._c0 <=> rhs._c0 : lhs._c1 <=> rhs._c1;
}
friend inline constexpr iterator operator+(const iterator& itr, const difference_type diff) noexcept(NO_EXCEPT)
requires std::ranges::random_access_range<B0> && std::ranges::random_access_range<B1>
{
auto res = itr; res += diff; return res;
}
friend inline constexpr iterator operator+(const difference_type diff, const iterator& itr) noexcept(NO_EXCEPT)
requires std::ranges::random_access_range<B0> && std::ranges::random_access_range<B1>
{
return itr + diff;
}
friend inline constexpr iterator operator-(const iterator& itr, const difference_type diff) noexcept(NO_EXCEPT)
requires std::ranges::random_access_range<B0> && std::ranges::random_access_range<B1>
{
auto res = itr; res -= diff; return res;
}
friend inline constexpr const difference_type operator-(const iterator& lhs, const iterator& rhs) noexcept(NO_EXCEPT)
requires
std::sized_sentinel_for<std::ranges::iterator_t<B0>, std::ranges::iterator_t<B0>> &&
std::sized_sentinel_for<std::ranges::iterator_t<B1>, std::ranges::iterator_t<B1>>
{
if(lhs._block == rhs._block) {
return lhs._block == 0 ? std::ranges::distance(rhs._c0, lhs._c0) : std::ranges::distance(rhs._c1, lhs._c1);
}
if(lhs._block > rhs._block) return std::ranges::distance(rhs._c0, rhs._e0) + std::ranges::distance(lhs._b1, lhs._c1);
if(lhs._block < rhs._block) return -(rhs - lhs);
assert(false);
}
friend inline constexpr const difference_type operator-(std::default_sentinel_t, const iterator& rhs) noexcept(NO_EXCEPT)
requires
std::sized_sentinel_for<std::ranges::sentinel_t<B0>, std::ranges::iterator_t<B0>> &&
std::sized_sentinel_for<std::ranges::sentinel_t<B1>, std::ranges::iterator_t<B1>>
{
if(rhs._block == 0) return std::ranges::distance(rhs._c0, rhs._e0) + std::ranges::distance(rhs._b1, rhs._e1);
if(rhs._block == 1) return std::ranges::distance(rhs._c1, rhs._e1);
assert(false);
}
friend inline constexpr const difference_type operator-(const iterator& lhs, std::default_sentinel_t rhs) noexcept(NO_EXCEPT)
requires
std::sized_sentinel_for<std::ranges::sentinel_t<B0>, std::ranges::iterator_t<B0>> &&
std::sized_sentinel_for<std::ranges::sentinel_t<B1>, std::ranges::iterator_t<B1>>
{
return -(rhs - lhs);
}
friend inline constexpr
std::common_reference_t<
std::ranges::range_rvalue_reference_t<B0>,
std::ranges::range_rvalue_reference_t<B1>
>
iter_move(const iterator& itr) noexcept(NO_EXCEPT)
{
if(itr._block == 0) return std::ranges::iter_move(itr._c0);
if(itr._block == 1) return std::ranges::iter_move(itr._c1);
assert(false);
}
friend inline constexpr void iter_swap(const iterator& lhs, const iterator& rhs) noexcept(NO_EXCEPT)
requires
std::indirectly_swappable<std::ranges::iterator_t<B0>> &&
std::indirectly_swappable<std::ranges::iterator_t<B1>> &&
std::indirectly_swappable<std::ranges::iterator_t<B0>, std::ranges::iterator_t<B1>>
{
if(lhs._block == 0 && rhs._block == 0) std::ranges::iter_swap(lhs._c0, rhs._c0);
if(lhs._block == 0 && rhs._block == 1) std::ranges::iter_swap(lhs._c0, rhs._c1);
if(lhs._block == 1 && rhs._block == 0) std::ranges::iter_swap(lhs._c1, rhs._c0);
if(lhs._block == 1 && rhs._block == 1) std::ranges::iter_swap(lhs._c1, rhs._c1);
assert(false);
}
};
} // namespace view_impl
} // namespace internal
template<class...> struct concat_view;
template<class T>
struct concat_view<T> : std::views::all_t<T> {
using std::views::all_t<T>::all_t;
};
template<class T0, class T1>
struct concat_view<T0, T1> : internal::view_impl::concat_view<std::views::all_t<T0>, std::views::all_t<T1>> {
explicit concat_view(T0&& v0, T1&& v1) noexcept(NO_EXCEPT)
: internal::view_impl::concat_view<std::views::all_t<T0>, std::views::all_t<T1>>(std::forward<T0>(v0), std::forward<T1>(v1))
{}
};
template<class T0, class T1, class... Ts>
struct concat_view<T0, T1, Ts...> : concat_view<concat_view<T0, T1>, Ts...> {
explicit concat_view(T0&& v0, T1&& v1, Ts&&... vs) noexcept(NO_EXCEPT)
: concat_view<concat_view<T0, T1>, Ts...>(
concat_view<T0, T1>(std::forward<T0>(v0), std::forward<T1>(v1)), std::forward<Ts>(vs)...
)
{}
};
namespace views {
namespace internal {
template<class... Ts>
concept can_concat_view = requires { concat_view<Ts...>(std::declval<Ts>()...); };
} // namespace internal
struct Concat {
template<class... Ts>
requires (sizeof...(Ts) == 0 || internal::can_concat_view<Ts...>)
inline constexpr auto operator() [[nodiscard]] (Ts&&... vs) const {
if constexpr(sizeof...(Ts) == 0) return std::views::empty<std::nullptr_t>;
else return concat_view<std::views::all_t<Ts>...>(std::forward<Ts>(vs)...);
}
};
inline constexpr Concat concat;
} // namespace views
} // namespace uni.
namespace std::ranges {
template<class... Views>
inline constexpr bool enable_borrowed_range<uni::concat_view<Views...>> = (enable_borrowed_range<Views> && ...);
}
#line 35 "iterable/operation.hpp"
namespace uni {
template<std::ranges::input_range R0, std::ranges::input_range R1>
requires std::constructible_from<
R0, std::common_type_t<std::ranges::range_size_t<R0>,std::ranges::range_size_t<R1>>
>
R0 concat(R0&& r0, R1&& r1) noexcept(NO_EXCEPT) {
R0 res(std::ranges::size(r0) + std::ranges::size(r1));
std::ranges::copy(r0, std::ranges::begin(res));
std::ranges::copy(r1, std::ranges::next(std::ranges::begin(res), std::ranges::size(r0)));
return res;
}
template<std::ranges::input_range R, std::ranges::input_range... Rs>
R concat(R&& range, Rs&&... tails) noexcept(NO_EXCEPT) {
return uni::concat(range, uni::concat(tails...));
}
template<std::ranges::input_range R>
requires
requires(R r) {
r.erase(std::ranges::unique(ALL(r)), std::ranges::end(r));
}
inline auto unique(R range) noexcept(NO_EXCEPT) {
std::ranges::sort(range);
range.erase(std::ranges::unique(ALL(range)), std::ranges::end(range));
return range;
}
template<
std::input_iterator I,
std::sentinel_for<I> S,
class T = std::iter_value_t<I>
>
T mex(I first, S last, const T& base = T()) noexcept(NO_EXCEPT) {
std::vector<T> val(first, last);
std::ranges::sort(val);
{
auto range = std::ranges::unique(val);
val.erase(ALL(range));
}
val.erase(val.begin(), std::ranges::lower_bound(val, base));
T i = 0;
while(i < std::ranges::ssize(val) && val[i] == i + base) ++i;
return T{i} + base;
}
template<std::ranges::input_range R>
auto mex(R&& range, const std::ranges::range_value_t<R>& base = std::ranges::range_value_t<R>()) noexcept(NO_EXCEPT) {
return mex(ALL(range), base);
}
template<class T>
auto mex(const std::initializer_list<T> v, const T& base = T()) noexcept(NO_EXCEPT) {
return mex(ALL(v), base);
}
template<std::input_iterator I, std::sentinel_for<I> S, class T>
inline constexpr auto gcd(I first, S last) noexcept(NO_EXCEPT) {
T res = T{0};
for(auto itr=first; itr!=last; ++itr) res = std::gcd(res, *itr);
return res;
}
template<std::input_iterator I, std::sentinel_for<I> S, class T>
inline constexpr auto lcm(I first, S last) noexcept(NO_EXCEPT) {
T res = T{1};
for(auto itr=first; itr!=last; ++itr) res = std::lcm(res, *itr);
return res;
}
template<std::ranges::input_range R, class T = std::ranges::range_value_t<R>>
auto mex(R&& range, const T& base) noexcept(NO_EXCEPT) {
return mex(ALL(range), base);
}
template<std::ranges::input_range R>
auto gcd(R&& range) noexcept(NO_EXCEPT) {
return gcd(ALL(range));
}
template<std::ranges::input_range R>
auto lcm(R&& range) noexcept(NO_EXCEPT) {
return lcm(ALL(range));
}
template<class R, std::input_iterator I, std::sentinel_for<I> S, class D>
requires
requires (R r, I itr) {
r.emplace_back(itr, itr);
}
auto split(I first, S last, const D& delim = ' ') noexcept(NO_EXCEPT) {
R res;
for(auto itr=first, fnd=first; ; itr=std::ranges::next(fnd)) {
fnd = std::find(itr, last, delim);
res.emplace_back(itr, fnd);
if(fnd == last) break;
}
return res;
}
template<class R, std::ranges::input_range V, class D>
requires (!std::ranges::input_range<D>)
auto split(V&& v, D&& d) noexcept(NO_EXCEPT) { return split<R>(ALL(v), d); }
template<class R, std::ranges::input_range V, std::ranges::input_range Ds>
auto split(V&& v, Ds&& ds) noexcept(NO_EXCEPT) {
R res = { v };
ITR(d, ds) {
R tmp;
ITR(p, res) tmp = concat(tmp, split<R>(p, d));
res = std::move(tmp);
}
return res;
}
template<class R, std::ranges::input_range V, class T>
auto split(V&& v, const std::initializer_list<T> ds) noexcept(NO_EXCEPT){
return split<R,V>(v, std::vector<T>(ALL(ds)));
}
template<std::ranges::sized_range Source, std::ranges::sized_range Qeury>
auto find(Source&& source, Qeury&& query) noexcept(NO_EXCEPT) {
z_array z_arr(views::concat(query, source));
const auto query_size = std::ranges::ssize(query);
vector<std::ranges::iterator_t<Source>> res;
{
auto itr = std::ranges::begin(source);
REP(i, query_size, std::ranges::size(z_arr)) {
if(z_arr[i] >= query_size) res.push_back(itr);
++itr;
}
}
return res;
}
template<
replacement_policy POLICY,
std::ranges::sized_range R,
std::ranges::sized_range From,
std::ranges::sized_range To
>
auto replaced(R&& source, From&& from, To&& to) noexcept(NO_EXCEPT) {
std::remove_cvref_t<R> res;
if constexpr(POLICY == replacement_policy::insert_sync) {
const auto found = find(source, from);
auto itr = std::ranges::begin(source);
ITRR(fn, found) {
std::ranges::copy(itr, fn, std::back_inserter(res));
std::ranges::copy(ALL(to), std::back_inserter(res));
itr = std::ranges::next(fn, std::ranges::size(from));
}
std::ranges::copy(itr, std::ranges::end(source), std::back_inserter(res));
}
else {
res = source;
res.resize(std::ranges::size(source) + std::ranges::size(to));
const auto found = find(res, from);
auto prev = std::ranges::begin(res);
ITRR(fn, found) {
if constexpr(POLICY == replacement_policy::overwrite_sync) {
if(prev <= fn) prev = std::ranges::copy(to, fn);
}
else {
std::ranges::copy(to, fn);
}
}
res.resize(std::ranges::size(source));
}
return res;
}
template<
std::ranges::sized_range R,
std::ranges::sized_range From,
std::ranges::sized_range To
>
inline auto replaced(R&& source, From&& from, To&& to) noexcept(NO_EXCEPT) {
return replaced<replacement_policy::insert_sync, R, From, To>(std::forward<R>(source), std::forward<From>(from), std::forward<To>(to));
}
template<alignment ALIGNMENT, internal::resizable_range R, class T = std::ranges::range_value_t<R>>
auto align(R&& source, const internal::size_t size, const T& v = T()) noexcept(NO_EXCEPT) {
if(std::ssize(source) >= size) return source;
if(ALIGNMENT == alignment::left) {
R left, right;
left = source;
right.resize(size - std::size(left), v);
return R(ALL(uni::views::concat(left, right)));
}
if(ALIGNMENT == alignment::center) {
R left, center, right;
center = source;
left.resize((size - std::size(center)) / 2, v);
right.resize(size - std::size(center) - std::size(left), v);
return R(ALL(uni::views::concat(left, center, right)));
}
if(ALIGNMENT == alignment::right) {
R left, right;
right = source;
left.resize(size - std::size(right), v);
return R(ALL(uni::views::concat(left, right)));
}
assert(false);
}
template<internal::resizable_range R, class T = std::ranges::range_value_t<R>>
auto ljust(R&& source, const internal::size_t size, const T& v = T()) noexcept(NO_EXCEPT) {
return align<alignment::left>(source, size, v);
}
template<internal::resizable_range R, class T = std::ranges::range_value_t<R>>
auto cjust(R&& source, const internal::size_t size, const T& v = T()) noexcept(NO_EXCEPT) {
return align<alignment::center>(source, size, v);
}
template<internal::resizable_range R, class T = std::ranges::range_value_t<R>>
auto rjust(R&& source, const internal::size_t size, const T& v = T()) noexcept(NO_EXCEPT) {
return align<alignment::right>(source, size, v);
}
template<
class Res,
std::ranges::random_access_range Target,
std::ranges::forward_range Order
>
requires std::ranges::output_range<Res, std::ranges::range_value_t<Target>>
Res ordered_by(Target&& target, Order&& order) noexcept(NO_EXCEPT) {
const auto target_size = std::ranges::ssize(target);
const auto order_size = std::ranges::ssize(order);
Res res(order_size);
{
auto res_itr = std::ranges::begin(res);
auto order_itr = std::ranges::begin(order);
const auto order_end = std::ranges::end(std::forward<Order>(order));
for(; order_itr != order_end; ++res_itr, ++order_itr) {
if constexpr(std::signed_integral<std::ranges::range_value_t<Order>>) assert(0 <= *order_itr);
assert(*order_itr < target_size);
*res_itr = target[*order_itr];
}
}
return res;
}
template<
std::ranges::random_access_range Target,
std::ranges::forward_range Order
>
auto ordered_by(Target&& target, Order&& order) noexcept(NO_EXCEPT) {
return ordered_by<std::remove_cvref_t<Target>, Target, Order>(std::forward<Target>(target), std::forward<Order>(order));
}
template<std::ranges::input_range Target, std::ranges::input_range Source>
requires std::equality_comparable_with<std::ranges::range_value_t<Target>, std::ranges::range_value_t<Source>>
auto is_subsequence_of(Target&& target, Source&& source) noexcept(NO_EXCEPT) {
auto target_itr = std::ranges::begin(source);
auto source_itr = std::ranges::begin(source);
const auto target_end = std::ranges::end(source);
const auto source_end = std::ranges::end(source);
for(; source_itr != source_end; ++source_itr) {
if(*target_itr == *source_itr) ++target_itr;
}
return target_itr == target_end;
}
template<std::ranges::input_range Target, std::ranges::input_range Source>
requires std::equality_comparable_with<std::ranges::range_value_t<Target>, std::ranges::range_value_t<Source>>
auto is_continuous_subsequence_of(Target&& target, Source&& source) noexcept(NO_EXCEPT) {
auto found = find(source, target);
return found.size() > 0;
}
} // namespace uni
#line 31 "numeric/arithmetic.hpp"
namespace uni {
template<class T>
inline constexpr T div_floor(const T& x, const T& d) noexcept(NO_EXCEPT) {
if constexpr(std::is_integral_v<T>) {
return x / d - (x % d && ((x < 0) ^ (d < 0)));
}
else {
return std::floor(x / d);
}
}
template<class T>
inline constexpr T div_ceil(const T& x, const T& d) noexcept(NO_EXCEPT) {
if constexpr(std::is_integral_v<T>) {
return div_floor(x + d - 1, d);
}
else {
return std::ceil(x / d);
}
}
template<class T>
inline constexpr T div_round(const T& x, const T& d) noexcept(NO_EXCEPT) {
if constexpr(std::is_integral_v<T>) {
return div_round<ld>(x, d);
}
else {
return std::round(x / d);
}
}
template<class T>
inline constexpr std::make_signed_t<T> to_signed(const T& x) noexcept(NO_EXCEPT) {
return std::bit_cast<std::make_signed_t<T>>(x);
}
template<class T>
inline constexpr std::make_unsigned_t<T> to_unsigned(const T& x) noexcept(NO_EXCEPT) {
return std::bit_cast<std::make_unsigned_t<T>>(x);
}
namespace internal {
template<class T>
inline constexpr auto perm(const T& n, const T& r) noexcept(NO_EXCEPT) {
T res = 1;
REP(i, r) res *= n - i;
return res;
}
template<class T>
inline constexpr auto comb(const T& n, T r) noexcept(NO_EXCEPT) {
if(n < 2 * r) r = n - r;
T p = 1, q = 1;
REP(i, r) p *= n - i, q *= r - i;
return p / q;
}
} // namespace internal
template<class T0, std::common_with<T0> T1>
inline constexpr auto perm(const T0& n, const T1& r) noexcept(NO_EXCEPT) {
assert(n >= 0), assert(r >= 0);
using T = std::common_type_t<T0, T1>;
if(n < r) return static_cast<T>(0);
return internal::perm<T>(n, r);
}
template<class T0, std::common_with<T0> T1>
inline constexpr auto comb(const T0& n, const T1& r) noexcept(NO_EXCEPT) {
assert(n >= 0), assert(r >= 0);
using T = std::common_type_t<T0, T1>;
if(n < r) return static_cast<T>(0);
if(n == r) return static_cast<T>(1);
return internal::comb<T>(n, r);
}
template<class T, class U, std::invocable<T, T> F = std::multiplies<>>
constexpr T pow(T x, U n, F mul = F(), T one = static_cast<T>(1)) noexcept(NO_EXCEPT) {
if(n == 0) return one;
if(n == 1 || x == one) return x;
T res = one;
while(true) {
if(n & 1) res = mul(res, x);
x = mul(x, x);
if(n == 0) return res;
n >>= 1;
}
assert(false);
}
using atcoder::pow_mod;
using atcoder::inv_mod;
using atcoder::crt;
template<class T> inline constexpr T sign(const T& x) noexcept(NO_EXCEPT) {
if(x == 0) return 0;
return (x > 0) ? 1 : -1;
}
template<class T, T FROM_MIN, T FROM_MAX, T TO_MIN, T TO_MAX> inline constexpr T mapping(const T x) {
return (x - FROM_MIN) * (TO_MAX - TO_MIN) / (FROM_MAX - FROM_MIN) + TO_MIN;
}
template<class T> inline constexpr T mapping(const T x, const T from_min, const T from_max, const T to_min, const T to_max) {
return (x - from_min) * (to_max - to_min) / (from_max - from_min) + to_min;
}
template<class... Args>
inline constexpr std::common_type_t<Args...> min(const Args&... args) noexcept(NO_EXCEPT) {
return std::min({ static_cast<std::common_type_t<Args...>>(args)... });
}
template<class... Args>
inline constexpr std::common_type_t<Args...> max(const Args&... args) noexcept(NO_EXCEPT) {
return std::max({ static_cast<std::common_type_t<Args...>>(args)... });
}
template<class T>
inline constexpr T gcd(const std::initializer_list<T> args) noexcept(NO_EXCEPT) {
return gcd(ALL(args));
}
template<class... Args>
inline constexpr std::common_type_t<Args...> gcd(const Args&... args) noexcept(NO_EXCEPT) {
return gcd({ static_cast<std::common_type_t<Args...>>(args)... });
}
template<class T>
inline constexpr T lcm(const std::initializer_list<T> args) noexcept(NO_EXCEPT) {
return lcm(ALL(args));
}
template<class... Args>
inline constexpr std::common_type_t<Args...> lcm(const Args&... args) noexcept(NO_EXCEPT) {
return lcm({ static_cast<std::common_type_t<Args...>>(args)... });
}
template<std::integral T0, std::integral T1>
inline constexpr std::optional<std::common_type_t<T0, T1>> add_overflow(const T0& a, const T1& b) noexcept(NO_EXCEPT) {
std::common_type_t<T0, T1> res;
if(__builtin_add_overflow(a, b, &res)) return {};
return res;
}
template<std::integral T0, std::integral T1>
inline constexpr std::optional<std::common_type_t<T0, T1>> sub_overflow(const T0& a, const T1& b) noexcept(NO_EXCEPT) {
std::common_type_t<T0, T1> res;
if(__builtin_sub_overflow(a, b, &res)) return {};
return res;
}
template<std::integral T0, std::integral T1>
inline constexpr std::optional<std::common_type_t<T0, T1>> mul_overflow(const T0& a, const T1& b) noexcept(NO_EXCEPT) {
std::common_type_t<T0, T1> res;
if(__builtin_mul_overflow(a, b, &res)) return {};
return res;
}
template<std::integral T0, std::integral T1, std::integral Limit>
inline auto add_clamp(const T0 x, const T1 y, const Limit inf, const Limit sup) noexcept(NO_EXCEPT) {
using Common = std::common_type_t<T0, T1, Limit>;
const auto res = add_overflow<Common>(x, y);
if(!res) {
if(x < 0 && y < 0) return inf;
if(x > 0 && y > 0) return sup;
assert(false);
}
return std::clamp<Common>(*res, inf, sup);
}
template<std::integral T0, std::integral T1, std::integral Limit>
inline auto sub_clamp(const T0 x, const T1 y, const Limit inf, const Limit sup) noexcept(NO_EXCEPT) {
using Common = std::common_type_t<T0, T1, Limit>;
const auto res = sub_overflow<Common>(x, y);
if(!res) {
if(x < 0 && y > 0) return inf;
if(x > 0 && y < 0) return sup;
assert(false);
}
return std::clamp<Common>(*res, inf, sup);
}
template<std::integral T0, std::integral T1, std::integral Limit>
inline auto mul_clamp(const T0 x, const T1 y, const Limit inf, const Limit sup) noexcept(NO_EXCEPT) {
using Common = std::common_type_t<T0, T1, Limit>;
const auto res = mul_overflow<Common>(x, y);
if(!res) {
if((x > 0) xor (y > 0)) return inf;
else return sup;
assert(false);
}
return std::clamp<Common>(*res, inf, sup);
}
template<class T>
inline constexpr T sqrt_floor(const T x) noexcept(NO_EXCEPT) {
return static_cast<T>(std::sqrt(static_cast<long double>(x)));
}
template<class T>
inline constexpr T sqrt_ceil(const T x) noexcept(NO_EXCEPT) {
T res = sqrt_floor(x);
if constexpr(std::is_floating_point_v<T>) {
while(res * res < x) res += 1;
}
else {
while(mul_overflow(res, res).value_or(std::numeric_limits<T>::max()) < x) ++res;
}
return res;
}
template<class T, std::integral K>
inline constexpr T kth_root_floor(T x, const K k) noexcept(NO_EXCEPT) {
assert(x >= 0);
if(std::signed_integral<K>) assert(k > 0);
if(x <= 1 or k == 1) return x;
constexpr auto DIGITS = std::numeric_limits<T>::digits;
if(k >= DIGITS) return T{1};
if(k == 2) return sqrt_floor(x);
constexpr auto MAX = std::numeric_limits<T>::max();
if(x == MAX) --x;
auto pow = [&](T t, i64 p) {
if(p == 0) return T{1};
T res = 1;
while(p) {
if(p & 1) {
res = mul_overflow(res, t).value_or(MAX);
}
t = mul_overflow(t, t).value_or(MAX);
p >>= 1;
}
return res;
};
auto res = static_cast<T>(std::pow(x, std::nextafter(1 / static_cast<double>(k), 0)));
while(pow(res + 1, k) <= x) ++res;
return res;
}
template<std::integral T>
T inline constexpr extended_gcd(const T& a, const T& b, T& x, T& y) noexcept {
if(b == 0) {
x = 1;
y = 0;
return a;
}
const T d = extended_gcd(b, a%b, y, x);
y -= a / b * x;
return d;
};
template<std::integral T>
std::pair<T, spair<T>> inline constexpr extended_gcd(const T& a, const T& b) noexcept {
T x, y;
const T d = extended_gcd(a, b, x, y);
return { d, spair<T>{ x, y } };
};
template<std::integral T>
std::optional<spair<T>> inline constexpr bezout_equation(const T& a, const T& b, const T& c) noexcept {
if(a == 0) {
if(b == 0) {
if(c == 0) return spair<T>{ 0, 0 };
else { };
}
if(c % b == 0) return spair<T>{ 0, c / b };
return {};
}
if(b == 0) {
const auto ans = bezout_equation(b, a, c);
if(ans.has_value()) return swapped(ans.value());
return {};
}
T x, y;
const T gcd = extended_gcd(a, b, x, y);
if(c % gcd != 0) return {};
const T p = c / gcd;
return spair<T>{ x * p, y * p };
};
} // namespace uni
#line 18 "numeric/bit.hpp"
namespace uni {
template<std::unsigned_integral T>
constexpr T multiply_high(const T x, const T y) noexcept(NO_EXCEPT) {
constexpr int digits = std::numeric_limits<T>::digits;
if constexpr(digits <= 16) {
return static_cast<T>((static_cast<u32>(x) * static_cast<u32>(y)) >> digits);
}
else if constexpr(digits <= 32) {
return static_cast<T>((static_cast<u64>(x) * static_cast<u64>(y)) >> digits);
}
else if constexpr(digits <= 64) {
return static_cast<T>((static_cast<u128>(x) * static_cast<u128>(y)) >> digits);
}
else {
constexpr int h_digits = digits / 2;
constexpr T mask = (T{ 1 } << h_digits) - 1;
const T xh = x >> h_digits, yh = y >> h_digits;
const T xl = x & mask, yl = y & mask;
const T ph = xh * yh, pl = xl * yl;
return (((pl >> h_digits) + (xh + xl) * (yh + yl) - (ph + pl)) >> h_digits) + ph;
}
}
template<std::unsigned_integral T>
inline constexpr int highest_bit_pos(const T v) noexcept(NO_EXCEPT) {
return (int)std::bit_width(v) - 1; // cast to int for GCC12
}
template<std::unsigned_integral T>
inline constexpr int lowest_bit_pos(const T v) noexcept(NO_EXCEPT) {
if(v == 0) return -1;
return std::countr_zero(v);
}
template<std::unsigned_integral T, std::integral I = int>
__attribute__((target("bmi2")))
inline constexpr T clear_higher_bits(const T v, const I p) {
if constexpr(std::signed_integral<I>) assert(0 <= p);
constexpr int DIGITS = std::numeric_limits<T>::digits;
assert(p <= DIGITS);
if constexpr(DIGITS <= 32) return _bzhi_u32(v, static_cast<u32>(p));
if constexpr(DIGITS <= 64) return _bzhi_u64(v, static_cast<u64>(p));
else {
static_assert(DIGITS <= 128);
constexpr std::uint64_t MAX64 = std::numeric_limits<std::uint64_t>::max();
const std::uint64_t high = v >> 64;
const std::uint64_t low = v & MAX64;
if(p < 64) return _bzhi_u64(low, p);
return low | (T{_bzhi_u64(high, p - 64)} << 64);
}
}
template<std::unsigned_integral T, std::integral I = int> constexpr T shiftl(const T, const I = 1);
template<std::unsigned_integral T, std::integral I = int> constexpr T shiftr(const T, const I = 1);
template<std::unsigned_integral T, std::integral I>
constexpr T shiftl(const T x, const I n) {
constexpr int DIGITS = std::numeric_limits<T>::digits;
if constexpr(std::signed_integral<I>) {
if(n < 0) return shiftr(x, -n);
}
if(n >= DIGITS) return 0;
return x << n;
}
template<std::unsigned_integral T, std::integral I>
constexpr T shiftr(const T x, const I n) {
constexpr int DIGITS = std::numeric_limits<T>::digits;
if constexpr(std::signed_integral<I>) {
if(n < 0) return shiftl(x, -n);
}
if(n >= DIGITS) return 0;
return x >> n;
}
template<std::unsigned_integral T, std::integral I = int>
inline constexpr bool bit(const T x, const I p) {
if constexpr(std::signed_integral<I>) assert(0 <= p);
assert(p < std::numeric_limits<T>::digits);
return shiftr(x, p) & T{1};
}
template<std::unsigned_integral T, std::integral I = int>
inline constexpr auto reset_bit(const T x, const I p) {
if constexpr(std::signed_integral<I>) assert(0 <= p);
assert(p < std::numeric_limits<T>::digits);
return x & ~(T{1} << p);
}
template<std::unsigned_integral T, std::integral I = int>
inline constexpr auto set_bit(const T x, const I p, const bool bit = true) {
if constexpr(std::signed_integral<I>) assert(0 <= p);
assert(p < std::numeric_limits<T>::digits);
if(!bit) return reset_bit(x, p);
return x | (T{1} << p);
}
template<std::unsigned_integral T, std::integral I = int>
inline constexpr T lower_bits(const T x, const I digits) {
if constexpr(std::signed_integral<I>) assert(0 <= digits);
assert(digits <= std::numeric_limits<T>::digits);
return x & (uni::shiftl(x, digits) - 1);
}
// Thanks to: https://noshi91.github.io/Library/other/select64.cpp
constexpr int select64(const u64 x0, u32 k) {
const u64 x1 = (x0 & UINT64_C(0x5555555555555555)) + (x0 >> 1 & UINT64_C(0x5555555555555555));
const u64 x2 = (x1 & UINT64_C(0x3333333333333333)) + (x1 >> 2 & UINT64_C(0x3333333333333333));
const u64 x3 = (x2 & UINT64_C(0x0F0F0F0F0F0F0F0F)) + (x2 >> 4 & UINT64_C(0x0F0F0F0F0F0F0F0F));
const u64 x4 = (x3 & UINT64_C(0x00FF00FF00FF00FF)) + (x3 >> 8 & UINT64_C(0x00FF00FF00FF00FF));
const u64 x5 = (x4 & UINT64_C(0x0000FFFF0000FFFF)) + (x4 >> 16 & UINT64_C(0x0000FFFF0000FFFF));
int res = 0;
u32 t;
t = x5 & 0xFFFFFFFF;
if(t <= k) k -= t, res += 32;
t = x4 >> res & 0xFFFF;
if(t <= k) k -= t, res += 16;
t = x3 >> res & 0xFF;
if(t <= k) k -= t, res += 8;
t = x2 >> res & 0xF;
if(t <= k) k -= t, res += 4;
t = x1 >> res & 0x3;
if(t <= k) k -= t, res += 2;
t = x0 >> res & 0x1;
if(t <= k) k -= t, res += 1;
return res;
}
namespace internal {
template<std::unsigned_integral T>
constexpr T binary_gcd(T a, T b) noexcept(NO_EXCEPT) {
if(!a || !b) return a | b;
T t, s = std::countr_zero(a | b);
a >>= std::countr_zero(a);
do {
b >>= std::countr_zero(b);
if(a > b) t = a, a = b, b = t;
b -= a;
} while(b);
return a << s;
}
template<std::signed_integral T>
inline constexpr T binary_gcd(const T a, const T b) noexcept(NO_EXCEPT) {
return binary_gcd(a < 0 ? -a : a, b < 0 ? -b : b);
}
} // namespace internal
template<std::integral T0, std::integral T1>
inline constexpr auto binary_gcd(T0 v0, T1 v1) noexcept(NO_EXCEPT) {
using common_type = std::common_type_t<T0, T1>;
return internal::binary_gcd(static_cast<common_type>(v0), static_cast<common_type>(v1));
}
template<std::unsigned_integral T, std::unsigned_integral S>
inline constexpr bool is_subset_of(T target, S superset) noexcept(NO_EXCEPT) {
return (target & ~superset) == 0;
}
template<std::unsigned_integral T, std::unsigned_integral S>
inline constexpr bool is_superset_of(T target, S subset) noexcept(NO_EXCEPT) {
return (~target & subset) == 0;
}
template<std::unsigned_integral S0, std::unsigned_integral S1>
inline constexpr auto comapre_as_bitset(S0 s0, S1 s1) noexcept(NO_EXCEPT) {
if(s0 == s1) return std::partial_ordering::equivalent;
if(is_subset_of(s0, s1)) return std::partial_ordering::less;
if(is_superset_of(s0, s1)) return std::partial_ordering::greater;
return std::partial_ordering::unordered;
}
} // namespace uni
#line 2 "algebraic/internal/concepts.hpp"
#line 6 "algebraic/internal/concepts.hpp"
#line 9 "algebraic/internal/concepts.hpp"
#line 2 "algebraic/base.hpp"
#line 6 "algebraic/base.hpp"
#line 10 "algebraic/base.hpp"
namespace uni {
namespace algebraic {
template<class Derived>
struct scalar_multipliable {
struct identity {
template<std::integral Scalar>
friend inline Derived operator*(const Scalar, const Derived& val) noexcept(NO_EXCEPT) {
return val;
}
};
struct automatic {
template<std::integral Scalar>
friend inline Derived operator*(const Scalar k, const Derived& val) noexcept(NO_EXCEPT) {
return uni::pow<Derived, Scalar, std::plus<Derived>>(val, k, {}, {});
}
};
};
template<class T>
struct base {
using value_type = T;
protected:
value_type _value;
public:
template<class... Args>
requires std::constructible_from<value_type, Args...>
base(Args&&... args) noexcept(NO_EXCEPT) : _value(std::forward<Args>(args)...) {}
inline explicit operator value_type() const noexcept(NO_EXCEPT) { return this->_value; }
inline auto val() const noexcept(NO_EXCEPT) { return this->_value; };
inline const value_type* operator->() const noexcept(NO_EXCEPT) { return &this->_value; };
inline value_type* operator->() noexcept(NO_EXCEPT) { return &this->_value; };
friend inline auto operator<=>(const base& lhs, const base& rhs) noexcept(NO_EXCEPT) {
return lhs._value <=> rhs._value;
};
friend inline bool operator==(const base& lhs, const base& rhs) noexcept(NO_EXCEPT) {
return lhs._value == rhs._value;
}
};
struct associative {};
struct commutative {};
} // namespace algebraic
} // namespace uni
#line 11 "algebraic/internal/concepts.hpp"
namespace uni {
namespace algebraic {
namespace internal {
template<class T>
concept magma =
uni::internal::addable<T> &&
requires {
typename T::value_type;
};
template<class T>
concept associative = std::is_base_of_v<algebraic::associative, T>;
template<class T>
concept commutative = std::is_base_of_v<algebraic::commutative, T>;
template<class T>
concept invertible = uni::internal::unary_subtractable<T>;
template<class T>
concept semigroup = magma<T> && associative<T>;
template<class T>
concept monoid = semigroup<T> && std::default_initializable<T>;
template<class T>
concept group = monoid<T> && invertible<T>;
} // namespace internal
} // namespace algebraic
} // namespace uni
#line 2 "action/base.hpp"
#line 6 "action/base.hpp"
#line 2 "internal/dummy.hpp"
namespace uni {
namespace internal {
struct dummy {};
} // namespace internal
} // namespace uni
#line 11 "action/base.hpp"
#line 13 "action/base.hpp"
namespace uni {
namespace actions {
template<class operation = uni::internal::dummy>
requires algebraic::internal::monoid<operation> || std::same_as<operation, uni::internal::dummy>
struct base {
static operation power(const operation& x, const uni::internal::size_t) noexcept(NO_EXCEPT) { return x; }
};
namespace internal {
template<class T>
concept operatable_action = algebraic::internal::magma<typename T::operand>;
template<class T>
concept effective_action =
algebraic::internal::magma<typename T::operation> &&
requires (const typename T::operation& f, const uni::internal::size_t length) {
{ T::power(f, length) } -> std::same_as<typename T::operation>;
};
template<class T>
concept operand_only_action = operatable_action<T> && (!effective_action<T>);
template<class T>
concept effect_only_action = effective_action<T> && (!operatable_action<T>);
template<class T>
concept full_action =
operatable_action<T> && effective_action<T> &&
requires (typename T::operation f, typename T::operand v) {
{ T::mapping(f, v) } -> std::same_as<typename T::operand>;
};
template<class T>
concept action = operatable_action<T> || effective_action<T>;
} // namespace internal
} // namespace actions
} // namespace uni
#line 25 "data_structure/segment_tree.hpp"
namespace uni {
namespace internal {
namespace segment_tree_impl {
// Thanks to: atcoder::segtree
template<algebraic::internal::monoid Monoid>
struct core {
using size_type = internal::size_t;
using operand = Monoid;
protected:
size_type _n = 0, _size = 0, _depth = 0;
std::valarray<operand> _data;
inline void _pull(const size_type k) noexcept(NO_EXCEPT) {
this->_data[k] = this->_data[k << 1] + this->_data[k << 1 | 1];
}
public:
core() noexcept = default;
explicit core(const size_type n) noexcept(NO_EXCEPT)
: _n(n), _size(std::bit_ceil(uni::to_unsigned(n))), _depth(std::countr_zero(uni::to_unsigned(this->_size))),
_data(this->_size << 1)
{}
inline size_type size() const noexcept(NO_EXCEPT) { return this->_n; }
inline size_type allocated() const noexcept(NO_EXCEPT) { return this->_values.size(); }
inline size_type depth() const noexcept(NO_EXCEPT) { return this->_depth; }
inline operand fold_all() const noexcept(NO_EXCEPT) { return this->_data[1]; }
template<std::input_iterator I, std::sentinel_for<I> S>
inline void assign(I first, S last) noexcept(NO_EXCEPT) {
if constexpr(std::sized_sentinel_for<S, I>) {
assert(std::ranges::distance(first, last) == this->_n);
}
{
size_type p = 0;
for(auto itr=first; itr!=last; ++itr, ++p) this->_data[this->_size + p] = static_cast<operand>(*itr);
}
REPD(p, 1, this->_size) this->_pull(p);
}
inline void fill(const operand& v = operand()) noexcept(NO_EXCEPT) {
REP(p, this->_n) this->_data[this->_size + p] = v;
REPD(p, 1, this->_size) this->_pull(p);
}
inline void add(size_type p, const operand& x) noexcept(NO_EXCEPT) {
this->set(p, this->_data[p + this->_size] + x);
}
inline void set(size_type p, const operand& x) noexcept(NO_EXCEPT) {
p += this->_size;
this->_data[p] = x;
FOR(i, 1, this->_depth) this->_pull(p >> i);
}
inline operand get(size_type p) const noexcept(NO_EXCEPT) {
return this->_data[p + this->_size];
}
inline operand fold(size_type l, size_type r) const noexcept(NO_EXCEPT) {
operand sml, smr;
l += this->_size;
r += this->_size;
while(l < r) {
if(l & 1) sml = sml + this->_data[l++];
if(r & 1) smr = this->_data[--r] + smr;
l >>= 1;
r >>= 1;
}
return sml + smr;
}
template<class F>
inline size_type max_right(size_type l, F&& f) const noexcept(NO_EXCEPT) {
assert(0 <= l && l <= this->_n);
assert(f(operand{}));
if(l == this->_n) return this->_n;
l += this->_size;
operand acc;
do {
while((l & 1) == 0) l >>= 1;
if(!f(acc + this->_data[l])) {
while(l < this->_size) {
l <<= 1;
if(f(acc + this->_data[l])) {
acc = acc + this->_data[l];
++l;
}
}
return l - this->_size;
}
acc = acc + this->_data[l];
++l;
} while((l & -l) != l);
return this->_n;
}
template<class F>
inline size_type min_left(size_type r, F&& f) const noexcept(NO_EXCEPT) {
assert(0 <= r && r <= this->_n);
assert(f(operand{}));
if (r == 0) return 0;
r += this->_size;
operand acc;
do {
--r;
while(r > 1 && (r & 1)) r >>= 1;
if(!f(this->_data[r] + acc)) {
while(r < this->_size) {
r = (r << 1 | 1);
if(f(this->_data[r] + acc)) {
acc = this->_data[r] + acc;
--r;
}
}
return r + 1 - this->_size;
}
acc = this->_data[r] + acc;
} while((r & -r) != r);
return 0;
}
};
} // namespace segment_tree_impl
} // namespace internal
template<class T>
struct segment_tree : internal::unconstructible {};
template<algebraic::internal::monoid Monoid>
struct segment_tree<Monoid> {
private:
using core = typename internal::segment_tree_impl::core<Monoid>;
core _impl;
public:
using value_type = Monoid;
using size_type = typename core::size_type;
private:
inline auto _positivize_index(const size_type p) const noexcept(NO_EXCEPT) {
return p < 0 ? this->_impl.size() + p : p;
}
public:
segment_tree() noexcept(NO_EXCEPT) : _impl() {};
explicit segment_tree(const size_type n, const value_type& v = value_type()) noexcept(NO_EXCEPT) : _impl(n) { this->_impl.fill(v); }
template<std::convertible_to<value_type> T>
segment_tree(const std::initializer_list<T>& init_list) noexcept(NO_EXCEPT) : segment_tree(ALL(init_list)) {}
template<std::input_iterator I, std::sized_sentinel_for<I> S>
segment_tree(I first, S last) noexcept(NO_EXCEPT)
: segment_tree(static_cast<size_type>(std::ranges::distance(first, last)))
{ this->assign(first, last); }
template<std::ranges::input_range R>
explicit segment_tree(R&& range) noexcept(NO_EXCEPT) : segment_tree(ALL(range)) {}
inline auto size() const noexcept(NO_EXCEPT) { return this->_impl.size(); }
inline auto allocated() const noexcept(NO_EXCEPT) { return this->_impl.allocated(); }
inline auto depth() const noexcept(NO_EXCEPT) { return this->_impl.depth(); }
template<std::convertible_to<value_type> T>
inline auto& assign(const std::initializer_list<T>& init_list) noexcept(NO_EXCEPT) { return this->assign(ALL(init_list)); }
template<std::input_iterator I, std::sentinel_for<I> S>
inline auto& assign(I first, S last) noexcept(NO_EXCEPT) {
this->_impl.assign(first, last);
return *this;
}
template<std::ranges::input_range R>
inline auto& assign(R&& range) noexcept(NO_EXCEPT) { return this->assign(ALL(range)); }
inline auto& fill(const value_type& v = value_type()) noexcept(NO_EXCEPT) {
this->_impl.fill(v);
return *this;
}
inline bool empty() const noexcept(NO_EXCEPT) { return this->_impl.size() == 0; }
struct point_reference : internal::point_reference<segment_tree> {
point_reference(segment_tree *const super, const size_type p) noexcept(NO_EXCEPT)
: internal::point_reference<segment_tree>(super, super->_positivize_index(p))
{
assert(0 <= this->_pos && this->_pos < this->_super->size());
}
operator value_type() const noexcept(NO_EXCEPT) { return this->_super->get(this->_pos); }
auto val() const noexcept(NO_EXCEPT) { return this->_super->get(this->_pos); }
inline auto& operator=(const value_type& v) noexcept(NO_EXCEPT) {
this->_super->set(this->_pos, v);
return *this;
}
inline auto& operator+=(const value_type& v) noexcept(NO_EXCEPT) {
this->_super->add(this->_pos, v);
return *this;
}
};
struct range_reference : internal::range_reference<segment_tree> {
range_reference(segment_tree *const super, const size_type l, const size_type r) noexcept(NO_EXCEPT)
: internal::range_reference<segment_tree>(super, super->_positivize_index(l), super->_positivize_index(r))
{
assert(0 <= this->_begin && this->_begin <= this->_end && this->_end <= this->_super->size());
}
inline auto fold() noexcept(NO_EXCEPT) {
if(this->_begin == 0 and this->_end == this->_super->size()) return this->_super->fold();
return this->_super->fold(this->_begin, this->_end);
}
};
inline auto& add(const size_type p, const value_type& x) noexcept(NO_EXCEPT) {
assert(0 <= p && p < this->_impl.size());
this->_impl.add(p, x);
return *this;
}
inline auto& set(const size_type p, const value_type& x) noexcept(NO_EXCEPT) {
assert(0 <= p && p < this->_impl.size());
this->_impl.set(p, x);
return *this;
}
inline auto get(const size_type p) const noexcept(NO_EXCEPT) {
assert(0 <= p && p < this->_impl.size());
return this->_impl.fold(p, p+1);
}
inline auto operator[](const size_type p) noexcept(NO_EXCEPT) { return point_reference(this, p); }
inline auto operator()(const size_type l, const size_type r) noexcept(NO_EXCEPT) { return range_reference(this, l, r); }
inline auto fold(const size_type l, const size_type r) const noexcept(NO_EXCEPT) {
assert(0 <= l && l <= r && r <= this->_impl.size());
return this->_impl.fold(l, r);
}
inline auto fold(const size_type r) const noexcept(NO_EXCEPT) {
assert(0 <= r && r <= this->_impl.size());
return this->_impl.fold(0, r);
}
inline auto fold() const noexcept(NO_EXCEPT) {
return this->_impl.fold_all();
}
template<bool (*f)(value_type)>
inline auto max_right(const size_type l) const noexcept(NO_EXCEPT) {
return this->_impl.max_right(l, [](value_type x) { return f(x); });
}
template<class F>
inline auto max_right(const size_type l, F&& f) const noexcept(NO_EXCEPT) {
return this->_impl.max_right(l, std::forward<F>(f));
}
template<bool (*f)(value_type)>
inline auto min_left(const size_type r) const noexcept(NO_EXCEPT) {
return this->_impl.min_left(r, [](value_type x) { return f(x); });
}
template<class F>
inline auto min_left(const size_type r, F&& f) const noexcept(NO_EXCEPT) {
return this->_impl.min_left(r, std::forward<F>(f));
}
struct iterator;
protected:
using iterator_interface = internal::container_iterator_interface<value_type, const segment_tree, iterator>;
public:
struct iterator : iterator_interface {
using iterator_interface::iterator_interface;
};
inline auto begin() const noexcept(NO_EXCEPT) { return iterator(this, 0); }
inline auto end() const noexcept(NO_EXCEPT) { return iterator(this, this->_impl.size()); }
inline auto rbegin() const noexcept(NO_EXCEPT) { return std::make_reverse_iterator(this->end()); }
inline auto rend() const noexcept(NO_EXCEPT) { return std::make_reverse_iterator(this->begin()); }
};
template<actions::internal::operatable_action Action>
struct segment_tree<Action> : segment_tree<typename Action::operand> {
using segment_tree<typename Action::operand>::segment_tree;
};
} // namespace uni
#line 2 "action/range_set_range_sum.hpp"
#line 5 "action/range_set_range_sum.hpp"
#line 7 "action/range_set_range_sum.hpp"
#line 2 "algebraic/addition.hpp"
#line 7 "algebraic/addition.hpp"
namespace uni {
namespace algebraic {
template<class T>
struct addition : base<T>, associative, commutative {
using base<T>::base;
friend inline addition operator+(const addition& lhs, const addition& rhs) noexcept(NO_EXCEPT) {
return lhs.val() + rhs.val();
}
template<std::integral Scalar>
friend inline addition operator*(const Scalar k, const addition& rhs) noexcept(NO_EXCEPT) {
return k * rhs.val();
}
inline addition operator-() const noexcept(NO_EXCEPT)
requires internal::invertible<T>
{
return -this->val();
}
};
} // namespace algebraic
} // namespace uni
#line 2 "algebraic/assignment.hpp"
#line 4 "algebraic/assignment.hpp"
#line 7 "algebraic/assignment.hpp"
namespace uni {
namespace algebraic {
template<class T>
struct assignment : base<std::optional<T>>, scalar_multipliable<assignment<T>>::identity, associative {
using base<std::optional<T>>::base;
friend inline assignment operator+(const assignment& lhs, const assignment& rhs) noexcept(NO_EXCEPT) {
if(lhs->has_value()) return lhs;
return rhs;
}
};
} // namespace algebraic
} // namespace uni
#line 10 "action/range_set_range_sum.hpp"
namespace uni {
namespace actions {
template<class T>
struct range_set_range_sum {
using operand = algebraic::addition<T>;
using operation = algebraic::assignment<T>;
static operand mapping(const operation& f, const operand& x) noexcept(NO_EXCEPT) {
return f->value_or(x.val());
}
static auto power(const operation& x, const uni::internal::size_t length) noexcept(NO_EXCEPT) {
if(x->has_value()) return operation(x->operator*() * length);
return x;
}
};
static_assert(internal::full_action<range_set_range_sum<int>>);
} // namespace actions
} // namespace uni
#line 2 "action/range_add_range_sum.hpp"
#line 5 "action/range_add_range_sum.hpp"
#line 7 "action/range_add_range_sum.hpp"
#line 2 "action/helpers.hpp"
#line 5 "action/helpers.hpp"
#line 2 "algebraic/null.hpp"
#line 5 "algebraic/null.hpp"
#line 9 "algebraic/null.hpp"
#line 12 "algebraic/null.hpp"
namespace uni {
namespace algebraic {
template<class T = uni::internal::dummy>
struct null : base<T>, scalar_multipliable<null<T>>::identity, associative, commutative {
using base<T>::base;
friend inline null operator+(const null& lhs, const null& rhs) noexcept(NO_EXCEPT) {
if(lhs == null()) return rhs;
return lhs;
}
inline null operator-() const noexcept(NO_EXCEPT)
requires internal::invertible<T>
{
return -*this;
}
};
} // namespace algebraic
} // namespace uni
#line 2 "algebraic/helper.hpp"
#line 7 "algebraic/helper.hpp"
namespace uni {
namespace algebraic {
template<class T, auto op, auto e, class... Tags>
struct helper : uni::algebraic::base<T>, uni::algebraic::scalar_multipliable<helper<T, op, e, Tags...>>::automatic, Tags... {
static_assert(std::same_as<std::invoke_result_t<decltype(op), T, T>, T>);
static_assert(std::same_as<std::invoke_result_t<decltype(e)>, T>);
using uni::algebraic::base<T>::base;
helper() : helper(e()) {}
friend inline helper operator+(const helper& lhs, const helper& rhs) noexcept(NO_EXCEPT) {
return op(lhs.val(), rhs.val());
}
};
template<class T, auto op, auto e>
using monoid_helper = helper<T, op, e, associative>;
template<class T>
struct make_magma {
using type = null<T>;
static_assert(internal::magma<type>);
};
template<internal::magma T>
struct make_magma<T> {
using type = T;
};
template<class T>
using make_magma_t = typename make_magma<T>::type;
} // namespace algebraic
} // namespace uni
#line 2 "action/null.hpp"
#line 6 "action/null.hpp"
#line 8 "action/null.hpp"
#line 11 "action/null.hpp"
namespace uni {
namespace actions {
template<class T>
struct null : base<algebraic::null<T>> {
using operand = algebraic::null<T>;
using operation = algebraic::null<T>;
static operand mapping(const operation&, const operand& x) noexcept(NO_EXCEPT) { return x; }
};
} // namespace actions
} // namespace uni
#line 11 "action/helpers.hpp"
namespace uni {
namespace actions {
template<class S, auto op, auto e, class F, auto _mapping, auto composition, auto id, auto _power = nullptr>
struct helper {
static_assert(std::same_as<std::invoke_result_t<decltype(_mapping), F, S>, S>);
// static_assert(std::same_as<std::invoke_result_t<decltype(_power), F, uni::internal::size_t>, F>);
using operand = algebraic::monoid_helper<S, op, e>;
using operation = algebraic::monoid_helper<F, composition, id>;
static operand mapping(const operation& f, const operand& x) noexcept(NO_EXCEPT) {
return _mapping(f.val(), x.val());
}
static operation power(const operation& x, [[maybe_unused]] const uni::internal::size_t length) noexcept(NO_EXCEPT) {
if constexpr(_power == nullptr) return x;
else return _power(x.val(), length);
}
};
template<class S, class F, auto _mapping, auto _power = nullptr>
struct mixer {
static_assert(std::same_as<std::invoke_result_t<decltype(_mapping), F, S>, S>);
static_assert(std::same_as<std::invoke_result_t<decltype(_power), F, uni::internal::size_t>, F>);
using operand = S;
using operation = F;
static operand mapping(const operation& f, const operand& x) noexcept(NO_EXCEPT) {
return _mapping(f.val(), x.val());
}
static operation power(const operation& x, [[maybe_unused]] const uni::internal::size_t length) noexcept(NO_EXCEPT) {
if constexpr(_power == nullptr) return x;
return _power(x.val(), length);
}
};
template<class S>
struct amplifier {
using operand = S;
using operation = S;
static operand mapping(const operation& f, const operand& x) noexcept(NO_EXCEPT) {
return f + x;
}
static operation power(const operation& x, [[maybe_unused]] const uni::internal::size_t length) noexcept(NO_EXCEPT) {
return length * x;
}
};
template<algebraic::internal::magma Magma>
struct make_operatable {
struct type {
using operand = Magma;
};
static_assert(internal::operatable_action<type>);
};
template<class T>
using make_operatable_t = typename make_operatable<T>::type;
template<algebraic::internal::magma Magma>
struct make_effective {
struct type : base<Magma> {
using operation = Magma;
};
static_assert(internal::effective_action<type>);
};
template<class T>
using make_effective_t = typename make_effective<T>::type;
template<class T>
struct make_full {
using type = null<T>;
static_assert(internal::full_action<type>);
};
template<algebraic::internal::magma Magma>
struct make_full<Magma> {
using type = make_full<make_operatable_t<Magma>>::type;
};
template<internal::full_action Action>
struct make_full<Action> {
using type = Action;
};
template<internal::operand_only_action Action>
struct make_full<Action> {
using base = Action;
struct type : actions::base<algebraic::null<typename base::operand::value_type>> {
using operand = typename base::operand;
using operation = algebraic::null<typename base::operand::value_type>;
using actions::base<algebraic::null<typename base::operand::value_type>>::base;
static operand mapping(const operation&, const operand& x) noexcept(NO_EXCEPT) { return x; }
};
static_assert(internal::full_action<type>);
};
template<internal::effect_only_action Action>
struct make_full<Action> {
using base = Action;
struct type : base {
using operand = typename base::operation;
using operation = typename base::operation;
using base::base;
static operand mapping(const operation& f, const operand& x) noexcept(NO_EXCEPT) { return f + x; }
};
static_assert(internal::full_action<type>);
};
template<class T>
using make_full_t = typename make_full<T>::type;
} // namespace actions
} // namespace uni
#line 9 "action/range_add_range_sum.hpp"
namespace uni {
namespace actions {
template<class T>
using range_add_range_sum = amplifier<algebraic::addition<T>>;
static_assert(internal::full_action<range_add_range_sum<int>>);
} // namespace actions
} // namespace uni
#line 2 "action/range_sum.hpp"
#line 6 "action/range_sum.hpp"
#line 8 "action/range_sum.hpp"
namespace uni {
namespace actions {
template<class T>
using range_sum = make_operatable_t<uni::algebraic::addition<T>>;
static_assert(internal::operand_only_action<range_sum<int>>);
} // namespace actions
} // namespace uni
#line 2 "algebraic/combined.hpp"
#line 6 "algebraic/combined.hpp"
#line 9 "algebraic/combined.hpp"
#line 12 "algebraic/combined.hpp"
namespace uni {
namespace algebraic {
template<
internal::magma M0,
internal::magma M1
>
struct combined
: base<std::pair<M0, M1>>,
std::conditional_t<internal::associative<M0> && internal::associative<M1>, associative, uni::internal::dummy>,
std::conditional_t<internal::commutative<M0> && internal::commutative<M1>, commutative, uni::internal::dummy>
{
using base<std::pair<M0, M1>>::base;
template<class T>
requires std::convertible_to<T, M0> && std::convertible_to<T, M1>
combined(const T& v) : combined(v, v) {};
friend inline combined operator+(const combined& lhs, const combined& rhs) noexcept(NO_EXCEPT) {
return { lhs->first + rhs->first, lhs->second + rhs->second };
}
template<std::integral Scalar>
friend inline combined&& operator*(const Scalar k, const combined& val) noexcept(NO_EXCEPT) {
return { k * val->first, k * val->second };
}
friend inline combined operator-(const combined& val) noexcept(NO_EXCEPT)
requires internal::invertible<M0> && internal::invertible<M1>
{
return { -val->first, -val->second };
}
};
} // namespace algebraic
} // namespace uni
#line 2 "algebraic/minimum.hpp"
#line 6 "algebraic/minimum.hpp"
#line 9 "algebraic/minimum.hpp"
namespace uni {
namespace algebraic {
template<class T>
struct minimum : base<T>, scalar_multipliable<minimum<T>>::identity, associative, commutative {
using base<T>::base;
minimum() noexcept(NO_EXCEPT) : minimum(std::numeric_limits<T>::max()) {};
friend inline minimum operator+(const minimum& lhs, const minimum& rhs) noexcept(NO_EXCEPT) {
return std::min(lhs.val(), rhs.val());
}
};
} // namespace algebraic
} // namespace uni
#line 26 "data_structure/adaptor/set.hpp"
namespace uni {
namespace internal {
template<
template<class...> class Tree,
template<class...> class Action
>
requires actions::internal::action<Action<internal::size_t>>
struct set_adaptor_impl {
using size_type = internal::size_t;
using key_type = internal::size_t;
using value_type = internal::size_t;
protected:
using impl_data_type = algebraic::combined<algebraic::addition<value_type>, algebraic::minimum<value_type>>;
using impl_tree =
Tree<
std::conditional_t<
internal::available_with<
Tree,
Action<impl_data_type>
>,
Action<impl_data_type>,
actions::range_sum<impl_data_type>
>
>;
impl_tree _data;
size_type _elem = 0;
public:
set_adaptor_impl(const size_type sup) noexcept(NO_EXCEPT) : _data(sup) {};
inline size_type size() const noexcept(NO_EXCEPT) { return this->_data.fold(); }
inline bool empty() const noexcept(NO_EXCEPT) { return this->size() == 0; }
inline size_type count(const key_type& k) const noexcept(NO_EXCEPT) { return this->_data.get(k).val()->first.val(); }
inline bool contains(const key_type& k) const noexcept(NO_EXCEPT) { return this->_data.get(k).val()->first.val() > 0; }
inline value_type mex(const key_type& base = 0) const noexcept(NO_EXCEPT) {
return this->_data.max_right(base, [](const auto& p) { return p.val()->second.val() > 0; });
}
inline std::optional<value_type> next(const key_type& k, const size_type count = 0) const noexcept(NO_EXCEPT) {
const auto v = this->_data.max_right(k, [count](const auto& p) { return p.val()->first.val() <= count; });
if(v == this->_data.size()) return {};
return { v };
}
inline std::optional<value_type> prev(const key_type& k, const size_type count = 0) const noexcept(NO_EXCEPT) {
const auto v = this->_data.min_left(k + 1, [count](const auto& p) { return p.val()->first.val() <= count; });
if(v == 0) return {};
return { v - 1 };
}
inline auto kth_smallest(const size_type k) const noexcept(NO_EXCEPT) { return this->next(0, k); }
inline auto kth_largest(const size_type k) const noexcept(NO_EXCEPT) { return this->prev(this->_data.size()-1, k); }
inline value_type min() const noexcept(NO_EXCEPT) { return this->kth_smallest(0); }
inline value_type max() const noexcept(NO_EXCEPT) { return this->kth_largest(0); }
inline size_type count_under(const value_type& v) const noexcept(NO_EXCEPT) { return this->_data.fold(0, v).val()->first.val(); }
inline size_type count_over(const value_type& v) const noexcept(NO_EXCEPT) { return this->_data.fold(v+1, this->_data.size()).val()->first.val(); }
inline size_type count_or_under(const value_type& v) const noexcept(NO_EXCEPT) { return this->_data.fold(0, v+1).val()->first.val(); }
inline size_type count_or_over(const value_type& v) const noexcept(NO_EXCEPT) { return this->_data.fold(v, this->_data.size()).val()->first.val(); }
template<comparison com = comparison::equal_to>
inline size_type count(const value_type& v) const noexcept(NO_EXCEPT) {
if constexpr(com == comparison::eq) return this->count(v);
if constexpr(com == comparison::under) return this->count_under(v);
if constexpr(com == comparison::over) return this->count_over(v);
if constexpr(com == comparison::or_under) return this->count_or_under(v);
if constexpr(com == comparison::or_over) return this->count_or_over(v);
assert(false);
}
inline const auto& _debug() const noexcept(NO_EXCEPT) { return this->_data; }
};
};
template<template<class...> class Tree = uni::segment_tree>
struct set_adaptor : internal::set_adaptor_impl<Tree, actions::range_set_range_sum> {
using size_type = internal::size_t;
using key_type = internal::size_t;
using value_type = size_type;
protected:
using Base = internal::set_adaptor_impl<Tree, actions::range_set_range_sum>;
using impl_data_type = typename Base::impl_data_type;
public:
set_adaptor() noexcept(NO_EXCEPT) = default;
set_adaptor(const size_type sup) noexcept(NO_EXCEPT) : Base(sup) {};
template<std::input_iterator I, std::sentinel_for<I> S>
set_adaptor(I first, S last) noexcept(NO_EXCEPT) : set_adaptor(*std::ranges::max_element(first, last) + 1) {
valarray<bool> bits(this->_data.size());
REP(itr, first, last) {
assert(0 <= *itr && *itr < this->_data.size());
bits[*itr] = true;
}
this->build_from_bits(ALL(bits));
};
template<std::ranges::input_range R>
set_adaptor(R&& range) noexcept(NO_EXCEPT) : set_adaptor(ALL(range)) {}
template<std::input_iterator I, std::sentinel_for<I> S>
inline auto& build_from_bits(I first, S last) noexcept(NO_EXCEPT) {
if constexpr(std::sized_sentinel_for<S, I>) {
assert(std::ranges::distance(first, last) == this->_data.size());
}
this->_data.assign(first, last);
return *this;
};
template<std::ranges::input_range R>
inline auto& build_from_bits(R&& range) noexcept(NO_EXCEPT) {
return this->build_from_bits(ALL(range));
}
inline bool insert(const key_type& k) noexcept(NO_EXCEPT) {
assert(0 <= k && k < this->_data.size());
const bool res = !this->_data.get(k).val()->first.val();
if(res) this->_data.set(k, impl_data_type{ 1 });
return res;
}
inline bool remove(const key_type& k) noexcept(NO_EXCEPT) {
assert(0 <= k && k < this->_data.size());
const bool res = this->_data.get(k).val()->first.val();
if(res) this->_data.set(k, impl_data_type{ 0 });
return res;
}
};
template<template<class...> class Tree = uni::segment_tree, std::integral Size = std::int64_t>
struct multiset_adaptor : internal::set_adaptor_impl<Tree, actions::range_add_range_sum> {
using size_type = Size;
using key_type = internal::size_t;
using value_type = key_type;
private:
using Base = internal::set_adaptor_impl<Tree, actions::range_add_range_sum>;
using impl_data_type = typename Base::impl_data_type;
public:
multiset_adaptor(const size_type sup) noexcept(NO_EXCEPT) : Base(sup) {};
template<std::input_iterator I, std::sentinel_for<I> S>
multiset_adaptor(I first, S last) noexcept(NO_EXCEPT) : Base(*std::ranges::max_element(first, last) + 1) {
vector<size_type> cnts(this->_data.size());
REP(itr, first, last) {
assert(0 <= *itr && *itr < this->_data.size());
cnts[*itr]++;
}
this->build_from_histogram(ALL(cnts));
};
template<std::ranges::input_range R>
multiset_adaptor(R&& range) noexcept(NO_EXCEPT) : multiset_adaptor(ALL(range)) {}
template<std::input_iterator I, std::sentinel_for<I> S>
inline auto& build_from_histogram(I first, S last) noexcept(NO_EXCEPT) {
if constexpr(std::sized_sentinel_for<S, I>) {
assert(std::ranges::distance(first, last) == this->_data.size());
}
this->_data.assign(first, last);
return *this;
};
template<std::ranges::input_range R>
inline auto& build_from_histogram(R&& range) noexcept(NO_EXCEPT) {
return this->build_from_histogram(ALL(range));
}
inline void insert(const key_type& k, const size_type count = 1) noexcept(NO_EXCEPT) {
assert(0 <= k && k < this->_data.size());
assert(0 <= count);
const auto cur = this->_data.get(k);
const auto num = cur.val()->first.val();
this->_data.set(k, impl_data_type{ num + count });
this->_elem += count;
}
inline void remove(const key_type& k, const size_type count = 1) noexcept(NO_EXCEPT) {
assert(0 <= k && k < this->_data.size());
const auto cur = this->_data.get(k);
const auto num = cur.val()->first.val();
assert(0 <= count && count <= num);
this->_data.set(k, impl_data_type{ num - count });
}
};
} // namespace uni
#line 4 "include/data_structures.hpp"
#line 2 "data_structure/bit_vector.hpp"
#line 9 "data_structure/bit_vector.hpp"
#line 14 "data_structure/bit_vector.hpp"
#line 16 "data_structure/bit_vector.hpp"
namespace uni {
// Thanks to: https://github.com/NyaanNyaan/library/blob/master/data-structure-2d/wavelet-matrix.hpp
struct bit_vector {
using size_type = std::uint_fast32_t;
private:
static constexpr size_type WORDSIZE = 64;
std::vector<std::uint64_t> _block;
std::vector<size_type> _count;
size_type _n, _zeros;
public:
bit_vector(const size_type n = 0) noexcept(NO_EXCEPT) { this->init(n); }
template<std::input_iterator I, std::sentinel_for<I> S>
bit_vector(I first, S last) noexcept(NO_EXCEPT)
: bit_vector(std::ranges::distance(first, last))
{
size_type pos = 0;
for(auto itr=first; itr != last; ++pos, ++itr) if(*itr) this->set(pos);
}
template<std::ranges::input_range R>
bit_vector(R&& range) noexcept(NO_EXCEPT) : bit_vector(ALL(range)) {}
template<class T> bit_vector(const std::initializer_list<T>& init_list) noexcept(NO_EXCEPT)
: bit_vector(ALL(init_list))
{}
inline constexpr size_type size() const noexcept(NO_EXCEPT) { return this->_n; }
inline constexpr size_type zeros() const noexcept(NO_EXCEPT) { return this->_zeros; }
inline constexpr size_type ones() const noexcept(NO_EXCEPT) { return this->_n - this->_zeros; }
inline void set(const size_type k) noexcept(NO_EXCEPT) { this->_block[k / WORDSIZE] |= (1LL << (k % WORDSIZE)); }
inline bool get(const size_type k) const noexcept(NO_EXCEPT) {
return 1U & static_cast<std::uint32_t>(this->_block[k / WORDSIZE] >> (k % WORDSIZE));
}
__attribute__((optimize("O3", "unroll-loops")))
inline void init(const size_type n) noexcept(NO_EXCEPT) {
this->_n = this->_zeros = n;
this->_block.resize(this->_n / WORDSIZE + 1, 0);
this->_count.resize(this->_block.size(), 0);
}
inline void build() noexcept(NO_EXCEPT) {
for(auto k = 1UL; k < this->_block.size(); ++k) {
this->_count[k] = this->_count[k-1] + static_cast<size_type>(std::popcount(this->_block[k-1]));
}
this->_zeros = this->rank0(this->_n);
}
inline size_type rank1(const size_type k) const noexcept(NO_EXCEPT) {
return
this->_count[k / WORDSIZE] +
static_cast<size_type>(std::popcount(uni::clear_higher_bits(this->_block[k / WORDSIZE], k % WORDSIZE)));
}
inline size_type rank0(const size_type k) const noexcept(NO_EXCEPT) { return k - this->rank1(k); }
template<bool BIT>
inline size_type rank(const size_type k) const noexcept(NO_EXCEPT) {
if constexpr(BIT) return this->rank0(k);
else return this->rank1(k);
}
template<bool BIT>
inline size_type select(const size_type rank) const noexcept(NO_EXCEPT) {
if constexpr(BIT) {
if(rank >= this->ones()) return this->_n;
}
else {
if(rank >= this->zeros()) return this->_n;
}
size_type index = 0;
{
size_type ng = static_cast<size_type>(this->_count.size());
while(ng - index > 1) {
size_type mid = (ng + index) / 2;
size_type cnt = this->_count[mid];
if constexpr(!BIT) cnt = mid * WORDSIZE - cnt;
(cnt <= rank ? index : ng) = mid;
}
}
const size_type base = index * WORDSIZE;
if constexpr(BIT) {
return base + select64(this->_block[index], rank - this->_count[index]);
}
else {
return base + select64(~this->_block[index], rank - (base - this->_count[index]));
}
}
inline size_type select0(const size_type k) const noexcept(NO_EXCEPT) { return this->select<false>(k); }
inline size_type select1(const size_type k) const noexcept(NO_EXCEPT) { return this->select<true>(k); }
struct iterator;
private:
using iterator_interface = internal::container_iterator_interface<bool, const bit_vector, iterator>;
public:
struct iterator : iterator_interface {
iterator() noexcept = default;
iterator(const bit_vector *const ref, const size_type pos) noexcept(NO_EXCEPT) : bit_vector::iterator_interface(ref, static_cast<difference_type>(pos)) {}
inline bool operator*() const noexcept(NO_EXCEPT) { return this->ref()->get(this->pos()); }
};
inline auto begin() const noexcept(NO_EXCEPT) { return iterator(this, 0); }
inline auto end() const noexcept(NO_EXCEPT) { return iterator(this, this->size()); }
};
} // namespace uni
#line 2 "data_structure/disjoint_set.hpp"
#line 8 "data_structure/disjoint_set.hpp"
#line 12 "data_structure/disjoint_set.hpp"
#line 15 "data_structure/disjoint_set.hpp"
#line 17 "data_structure/disjoint_set.hpp"
namespace uni {
//Thanks to: atcoder::disjoint_set
struct disjoint_set {
using size_type = internal::size_t;
private:
size_type _n = 0, _group_count = 0;
// root node: -1 * component size
// otherwise: parent
std::vector<size_type> _parent_or_size;
public:
disjoint_set() noexcept = default;
explicit disjoint_set(const size_type n) noexcept(NO_EXCEPT) : _n(n), _group_count(n), _parent_or_size(n, -1) {}
inline auto size() const noexcept(NO_EXCEPT) { return this->_n; }
inline auto group_count() const noexcept(NO_EXCEPT) { return this->_group_count; }
inline auto merge(const size_type a, const size_type b) noexcept(NO_EXCEPT) {
assert(0 <= a && a < _n);
assert(0 <= b && b < _n);
size_type x = this->leader(a), y = this->leader(b);
if (x == y) return x;
--this->_group_count;
if (-this->_parent_or_size[x] < -this->_parent_or_size[y]) std::swap(x, y);
this->_parent_or_size[x] += this->_parent_or_size[y];
this->_parent_or_size[y] = x;
return x;
}
inline bool same(const size_type a, const size_type b) noexcept(NO_EXCEPT) {
assert(0 <= a && a < _n);
assert(0 <= b && b < _n);
return this->leader(a) == this->leader(b);
}
inline size_type leader(const size_type a) noexcept(NO_EXCEPT) {
assert(0 <= a && a < _n);
if(this->_parent_or_size[a] < 0) return a;
return this->_parent_or_size[a] = this->leader(this->_parent_or_size[a]);
}
inline auto size(const size_type a) noexcept(NO_EXCEPT) {
assert(0 <= a && a < _n);
return -this->_parent_or_size[this->leader(a)];
}
inline auto groups() noexcept(NO_EXCEPT) {
vector<size_type> leader_buf(_n), group_size(_n);
REP(i, this->_n) {
leader_buf[i] = this->leader(i);
group_size[leader_buf[i]]++;
}
vector<vector<size_type>> result(_n);
REP(i, this->_n) result[i].reserve(group_size[i]);
REP(i, this->_n) result[leader_buf[i]].push_back(i);
{
const auto range = std::ranges::remove_if(result, [&](const auto& v) { return v.empty(); });
result.erase(ALL(range));
}
return result;
}
};
} // namespace uni
#line 2 "data_structure/disjoint_sparse_table.hpp"
#line 12 "data_structure/disjoint_sparse_table.hpp"
#line 19 "data_structure/disjoint_sparse_table.hpp"
#line 21 "data_structure/disjoint_sparse_table.hpp"
#line 24 "data_structure/disjoint_sparse_table.hpp"
namespace uni {
namespace internal {
namespace disjoint_sparse_table_impl {
// Thanks to: https://noshi91.hatenablog.com/entry/2018/05/08/183946
template<algebraic::internal::semigroup Operand>
struct core {
using size_type = internal::size_t;
using operand = Operand;
using iterator = std::vector<std::vector<Operand>>;
size_type _n = 0, _depth = 0;
bool _built = false;
protected:
std::vector<std::vector<operand>> _table = {};
public:
explicit core(const size_type n = 0) noexcept(NO_EXCEPT) : _n(n) {
this->_depth = std::bit_width<std::make_unsigned_t<size_type>>(n);
this->_table.resize(this->_depth+1, std::vector<operand>(n));
}
template<std::input_iterator I, std::sized_sentinel_for<I> S>
core(I first, S last) noexcept(NO_EXCEPT)
: core(static_cast<size_type>(std::ranges::distance(first, last)))
{
std::ranges::copy(first, last, this->_table.begin()->begin());
}
template<bool FORCE = false>
inline auto& build() noexcept(NO_EXCEPT) {
if(!FORCE and this->_built) return *this;
FOR(i, 2, this->_depth) {
const size_type len = 1 << i;
for(size_type l = 0, m = (len >> 1); m < this->_n; l += len, m = l + (len >> 1)) {
this->_table[i - 1][m - 1] = this->_table.front()[m - 1];
REPD(j, l, m-1) {
this->_table[i - 1][j] = this->_table.front()[j] + this->_table[i - 1][j + 1];
}
this->_table[i - 1][m] = this->_table.front()[m];
REP(j, m + 1, std::min(l + len, this->_n)) {
this->_table[i - 1][j] = this->_table[i - 1][j - 1] + this->_table.front()[j];
}
}
}
this->_built = true;
return *this;
}
inline auto& raw() noexcept(NO_EXCEPT) {
this->_built = false;
return this->_table.front();
}
inline const auto& raw() const noexcept(NO_EXCEPT) { return this->_table.front(); }
inline auto& data() noexcept(NO_EXCEPT) { return this->_table; }
inline const auto& data() const noexcept(NO_EXCEPT) { return this->_table; }
size_type size() const noexcept(NO_EXCEPT) { return this->_n; }
operand fold(const size_type l, size_type r) {
if(l == r) return operand{};
if(l == --r) return this->_table.front()[l];
this->build();
const size_type p = highest_bit_pos<std::make_unsigned_t<size_type>>(l ^ r);
return this->_table[p][l] + this->_table[p][r];
}
};
} // namespace disjoint_sparse_table_impl
} // namespace internal
template<class> struct disjoint_sparse_table : internal::unconstructible {};
template<algebraic::internal::semigroup Semigroup>
struct disjoint_sparse_table<Semigroup> {
private:
using core = internal::disjoint_sparse_table_impl::core<Semigroup>;
using iterator = core::iterator;
core _impl;
public:
using value_type = Semigroup;
using size_type = core::size_type;
protected:
inline auto _positivize_index(const size_type p) const noexcept(NO_EXCEPT) {
return p < 0 ? this->_impl.size() + p : p;
}
public:
explicit disjoint_sparse_table(const size_type n, const value_type& val = value_type()) noexcept(NO_EXCEPT) : _impl(n) {
this->_impl.data().begin()->assign(n, val);
}
template<std::input_iterator I, std::sized_sentinel_for<I> S>
disjoint_sparse_table(I first, S last) noexcept(NO_EXCEPT) : _impl(first, last) {}
template<std::ranges::input_range R>
explicit disjoint_sparse_table(R&& range) noexcept(NO_EXCEPT)
: _impl(std::ranges::begin(range), std::ranges::end(range))
{}
inline auto& raw() noexcept(NO_EXCEPT) { return this->_impl.raw(); }
inline const auto& raw() const noexcept(NO_EXCEPT) { return this->_impl.raw(); }
inline const auto& data() const noexcept(NO_EXCEPT) { return this->impl.data(); }
inline auto size() const noexcept(NO_EXCEPT) { return this->_impl.size(); }
friend internal::range_reference<disjoint_sparse_table>;
struct range_reference : internal::range_reference<disjoint_sparse_table> {
range_reference(disjoint_sparse_table *const super, const size_type l, const size_type r) noexcept(NO_EXCEPT)
: internal::range_reference<disjoint_sparse_table>(super, super->_positivize_index(l), super->_positivize_index(r))
{
assert(0 <= this->_begin && this->_begin <= this->_end && this->_end <= this->_super->size());
}
inline auto fold() noexcept(NO_EXCEPT) {
return this->_super->fold(this->_begin, this->_end);
}
};
inline auto fold(size_type l, size_type r) noexcept(NO_EXCEPT) {
l = this->_positivize_index(l), r = this->_positivize_index(r);
assert(0 <= l && l <= r && r <= this->size());
return this->_impl.fold(l, r);
}
inline auto fold() noexcept(NO_EXCEPT) { return this->fold(0, this->size()); }
inline auto operator[](const size_type index) const noexcept(NO_EXCEPT) { return this->_impl.data().front()[index]; }
inline auto operator()(const size_type l, const size_type r) noexcept(NO_EXCEPT) { return range_reference(this, l, r); }
inline auto begin() const noexcept(NO_EXCEPT) { return this->_impl.data().begin()->begin(); }
inline auto end() const noexcept(NO_EXCEPT) { return this->_impl.data().begin()->end(); }
inline auto rbegin() const noexcept(NO_EXCEPT) { return this->_impl.data().begin()->rbegin(); }
inline auto rend() const noexcept(NO_EXCEPT) { return this->_impl.data().begin()->rend(); }
};
template<actions::internal::operatable_action Action>
struct disjoint_sparse_table<Action> : disjoint_sparse_table<typename Action::operand> {
using disjoint_sparse_table<typename Action::operand>::disjoint_sparse_table;
};
} // namespace uni
#line 2 "data_structure/dynamic_segment_tree.hpp"
#include <memory_resource>
#line 6 "data_structure/dynamic_segment_tree.hpp"
#include <memory>
#line 13 "data_structure/dynamic_segment_tree.hpp"
#line 16 "data_structure/dynamic_segment_tree.hpp"
#line 23 "data_structure/dynamic_segment_tree.hpp"
#line 2 "data_structure/internal/node_handler.hpp"
#line 5 "data_structure/internal/node_handler.hpp"
#line 7 "data_structure/internal/node_handler.hpp"
namespace uni {
namespace node_handlers {
namespace internal {
template<class Allocator, class NodeType>
struct base_handler {
using allocator_type = Allocator;
protected:
using allocator_traits = std::allocator_traits<allocator_type>;
using node_allocator_type = allocator_traits::template rebind_alloc<NodeType>;
using node_allocator_traits = std::allocator_traits<node_allocator_type>;
[[no_unique_address]] node_allocator_type _allocator;
public:
base_handler(const allocator_type& allocator = allocator_type()) noexcept(NO_EXCEPT)
: _allocator(allocator)
{}
base_handler(const base_handler& source) noexcept(NO_EXCEPT)
: _allocator(node_allocator_traits::select_on_container_copy_construction(source._allocator))
{}
base_handler(base_handler&& source) noexcept = default;
auto& operator=(const base_handler& source) noexcept(NO_EXCEPT) {
if(&source != this) {
if constexpr(allocator_traits::propagate_on_container_copy_assignment::value) {
this->_allocator = source._allocator;
}
}
return *this;
}
auto& operator=(base_handler&& source) noexcept(NO_EXCEPT) {
if(&source != this) {
if constexpr(allocator_traits::propagate_on_container_move_assignment::value) {
this->_allocator = source._allocator;
}
}
return *this;
}
};
} // namespace internal
template<class Allocator>
struct cloneable {
template<class NodeType>
struct handler : internal::base_handler<Allocator, NodeType> {
using internal::base_handler<Allocator, NodeType>::base_handler;
using node_type = NodeType;
using node_pointer = std::shared_ptr<node_type>;
inline static node_pointer nil = std::make_shared<node_type>();
template<class... Args>
inline auto create(Args&&... args) noexcept(NO_EXCEPT) {
return std::allocate_shared<node_type>(this->_allocator, std::forward<Args>(args)...);
}
inline auto clone(const node_pointer& ptr) noexcept(NO_EXCEPT) {
return this->create(*ptr);
}
inline constexpr bool disposable(const node_pointer&) const noexcept { return false; }
inline constexpr void dispose(const node_pointer&) const noexcept {}
};
};
template<class Allocator>
struct reusing {
template<class NodeType>
struct handler : internal::base_handler<Allocator, NodeType> {
using node_type = NodeType;
using node_pointer = std::add_pointer_t<node_type>;
private:
using base = internal::base_handler<Allocator, NodeType>;
using node_allocator_traits = typename base::node_allocator_traits;
inline static int _instance_count = 0;
public:
using base::base;
using allocator_type = typename base::allocator_type;
inline static node_pointer nil;
handler(const allocator_type& allocator = allocator_type()) noexcept(NO_EXCEPT) : base(allocator) {
if(handler::_instance_count++ == 0) {
handler::nil = new node_type{};
}
}
~handler() noexcept {
if(--handler::_instance_count == 0) {
delete handler::nil;
}
}
template<class... Args>
inline auto create(Args&&... args) noexcept(NO_EXCEPT) {
node_pointer node = node_allocator_traits::allocate(this->_allocator, 1);
node_allocator_traits::construct(this->_allocator, node, std::forward<Args>(args)...);
return node;
}
inline auto clone(const node_pointer ptr) const noexcept { return ptr; }
inline bool disposable(const node_pointer node) const noexcept(NO_EXCEPT) {
return node != handler::nil;
}
inline void dispose(const node_pointer node) noexcept(NO_EXCEPT) {
node_allocator_traits::destroy(this->_allocator, node);
node_allocator_traits::deallocate(this->_allocator, node, 1);
}
};
};
} // namespace node_handlers
} // namespace uni
#line 25 "data_structure/dynamic_segment_tree.hpp"
#line 28 "data_structure/dynamic_segment_tree.hpp"
#line 2 "debugger/debug.hpp"
#line 9 "debugger/debug.hpp"
#include <array>
#line 13 "debugger/debug.hpp"
#include <bitset>
#include <deque>
#include <queue>
#include <stack>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#line 22 "debugger/debug.hpp"
#include <iomanip>
#line 26 "debugger/debug.hpp"
#line 2 "numeric/int128.hpp"
#include <cctype>
#line 9 "numeric/int128.hpp"
#line 12 "numeric/int128.hpp"
#line 14 "numeric/int128.hpp"
namespace std {
template<class C, class S>
auto& operator>>(std::basic_istream<C, S>& in, uni::i128& v) noexcept(NO_EXCEPT) {
std::string str; in >> str;
v = 0;
bool negative = (str[0] == '-');
REP(d, std::ranges::next(str.begin(), negative), str.end()) {
assert(std::isdigit(*d));
v = v * 10 + *d - '0';
}
if(negative) v *= -1;
return in;
}
template<class C, class S>
auto& operator>>(std::basic_istream<C, S>& in, uni::u128& v) noexcept(NO_EXCEPT) {
std::string str; in >> str;
v = 0U;
assert(str[0] != '-');
REP(d, str.begin(), str.end()) {
assert(std::isdigit(*d));
v = v * 10U + *d - '0';
}
return in;
}
template<class C, class S>
auto& operator<<(std::basic_ostream<C, S>& out, uni::i128 v) noexcept(NO_EXCEPT) {
if(v == 0) return out << 0;
if(v < 0) out << '-', v *= -1;
std::string str;
while(v > 0) str += static_cast<char>(v%10) + '0', v /= 10;
std::reverse(str.begin(), str.end());
return out << str;
}
template<class C, class S>
auto& operator<<(std::basic_ostream<C, S>& out, uni::u128 v) noexcept(NO_EXCEPT) {
if(v == 0) return out << 0U;
std::string str;
while(v > 0) str += static_cast<char>(v%10U) + '0', v /= 10U;
std::reverse(str.begin(), str.end());
return out << str;
}
}
#line 29 "debugger/debug.hpp"
#line 2 "internal/resolving_rank.hpp"
namespace uni {
namespace internal {
template<int P> struct resolving_rank : resolving_rank<P-1> {};
template<> struct resolving_rank<0> {};
} // namespace internal
} // namespace uni
#line 34 "debugger/debug.hpp"
#include <typeinfo>
#include <cxxabi.h>
namespace debugger {
template<class T>
auto _debug (T&& val) -> decltype(val._debug()) {
return val._debug();
}
std::ostream *cdebug = &std::clog;
#ifdef DEBUGGER_COLORED_OUTPUT
constexpr std::string COLOR_LINE = "\033[3;35m";
constexpr std::string COLOR_IDENTIFIER = "\033[32m";
constexpr std::string COLOR_INIT = "\033[m";
constexpr std::string COLOR_STRING = "\033[33m";
constexpr std::string COLOR_TYPE = "\033[34m";
constexpr std::string COLOR_NUMERIC = "\033[36m";
constexpr std::string COLOR_LITERAL_OPERATOR = "\033[31m";
#else
constexpr std::string COLOR_LINE = "";
constexpr std::string COLOR_IDENTIFIER = "";
constexpr std::string COLOR_INIT = "";
constexpr std::string COLOR_STRING = "";
constexpr std::string COLOR_TYPE = "";
constexpr std::string COLOR_NUMERIC = "";
constexpr std::string COLOR_LITERAL_OPERATOR = "";
#endif
using Brackets = std::pair<std::string, std::string>;
template<class T>
std::string dump(T&&);
template<class T>
const std::string get_type_name(T&& val) {
const char* const name = typeid(std::forward<T>(val)).name();
int status = -4;
char* const demangled_name = abi::__cxa_demangle(name, NULL, NULL, &status);
std::string res{name};
if (status == 0) {
res = std::string(demangled_name);
free(demangled_name);
}
return COLOR_TYPE + res + COLOR_INIT;
}
struct debug_t : std::string {
using std::string::string;
debug_t(const std::string& str) {
this->assign(str);
}
};
template<size_t N, class T>
void dump_tuple_impl([[maybe_unused]] T&& val, std::stringstream &res) {
if constexpr(N < std::tuple_size_v<std::remove_cvref_t<T>>) {
res << dump(std::get<N>(val));
if constexpr(N < std::tuple_size_v<std::remove_cvref_t<T>> - 1) res << ", ";
dump_tuple_impl<N + 1>(std::forward<T>(val), res);
}
}
template<std::ranges::input_range R>
std::string dump_range_impl(R&& range, const Brackets& brcs = { "[", "]" }, const std::string& spl = ", ") {
std::stringstream res;
res << brcs.first << " ";
auto itr = std::ranges::begin(range);
auto end = std::ranges::end(std::forward<R>(range));
while(itr != end) {
if(std::ranges::next(itr) == end) res << dump(*itr) << " ";
else res << dump(*itr) << spl;
++itr;
}
res << brcs.second ;
return res.str();
}
std::string dump_debug_t(debug_t info) {
return info;
}
struct dump_primitive_like {
std::string operator()(std::nullptr_t) const {
return COLOR_INIT;
}
template<uni::internal::pointer T>
std::string operator()(const T ptr) const {
return dump(*ptr);
}
template<class T>
requires uni::internal::derived_from_template<std::remove_cvref_t<T>, std::basic_string>
std::string operator()(T&& val) const {
std::stringstream res;
res << COLOR_STRING << "`" << val << "`" << COLOR_INIT;
return res.str();
}
std::string operator()(const char val) const {
std::stringstream res;
res << COLOR_STRING << "\'" << val << "\'" << COLOR_INIT;
return res.str();
}
std::string operator()(const char val[]) const {
std::stringstream res;
res << COLOR_STRING << "\"" << val << "\"" << COLOR_INIT;
return res.str();
}
std::string operator()(const unsigned char val) const {
std::stringstream res;
res << COLOR_NUMERIC << static_cast<int>(val) << COLOR_INIT;
return res.str();
}
std::string operator()(const bool val) const {
std::stringstream res;
res << COLOR_NUMERIC << (val ? "true" : "false" ) << COLOR_INIT;
return res.str();
}
template<uni::internal::arithmetic T>
std::string operator()(const T val) const {
std::stringstream res;
res << std::setprecision(std::numeric_limits<T>::digits10) << val;
auto str = res.str();
std::string dst = "";
while(str.length() > 3) {
dst = ',' + str.substr(str.length() - 3, 3) + dst;
str = str.substr(0, str.length() - 3);
}
return COLOR_NUMERIC + str + dst + COLOR_LITERAL_OPERATOR + uni::internal::literal_operator_v<T> + COLOR_INIT;
};
template<class T>
requires uni::internal::derived_from_template<std::remove_cvref_t<T>, std::optional>
std::string operator()(T&& val) const {
if(val.has_value()) return dump(*val);
return COLOR_TYPE + "invalid" + COLOR_INIT;
}
};
struct dump_bitset {
template<std::size_t N>
std::string operator()(const std::bitset<N>& val) const {
std::stringstream res;
res << COLOR_NUMERIC << val.to_string() << COLOR_INIT;
return res.str();
}
};
struct dump_has_val {
template<class T>
requires requires (T val) { val.val(); }
std::string operator()(T&& val) const {
return dump(val.val());
}
};
struct dump_iterator {
template<std::input_or_output_iterator I>
std::string operator()(I&& itr) const {
return COLOR_TYPE + "<iterator> " + COLOR_INIT+ dump(*itr);
}
};
struct dump_wrapper {
template<class T>
requires uni::internal::derived_from_template<std::remove_cvref_t<T>, std::map>
std::string operator()(T&& val) const {
return dump_range_impl(val, Brackets("{", "}"));
}
template<class T>
requires uni::internal::derived_from_template<std::remove_cvref_t<T>, std::multimap>
std::string operator()(T&& val) const {
return dump_range_impl(val, Brackets("{", "}"));
}
template<class T>
requires uni::internal::derived_from_template<std::remove_cvref_t<T>, std::unordered_map>
std::string operator()(T&& val) const {
return dump_range_impl(val, Brackets("{", "}"));
}
template<class T>
requires uni::internal::derived_from_template<std::remove_cvref_t<T>, std::unordered_multimap>
std::string operator()(T&& val) const {
return dump_range_impl(val, Brackets("{", "}"));
}
template<class T>
requires uni::internal::derived_from_template<std::remove_cvref_t<T>, std::set>
std::string operator()(T&& val) const {
return dump_range_impl(val, Brackets("{", "}"));
}
template<class T>
requires uni::internal::derived_from_template<std::remove_cvref_t<T>, std::multiset>
std::string operator()(T&& val) const {
return dump_range_impl(val, Brackets("{", "}"));
}
template<class T>
requires uni::internal::derived_from_template<std::remove_cvref_t<T>, std::unordered_set>
std::string operator()(T&& val) const {
return dump_range_impl(val, Brackets("{", "}"));
}
template<class T>
requires uni::internal::derived_from_template<std::remove_cvref_t<T>, std::unordered_multiset>
std::string operator()(T&& val) const {
return dump_range_impl(val, Brackets("{", "}"));
}
template<class T>
requires uni::internal::derived_from_template<std::remove_cvref_t<T>, std::valarray>
std::string operator()(T&& val) const {
return dump_range_impl(val, Brackets("[", "]"));
}
template<class T>
requires uni::internal::derived_from_template<std::remove_cvref_t<T>, std::vector>
std::string operator()(T&& val) const {
return dump_range_impl(val, Brackets("[", "]"));
}
template<class T>
requires uni::internal::derived_from_template<std::remove_cvref_t<T>, std::deque>
std::string operator()(T&& val) const {
return dump_range_impl(val, Brackets("[", "]"));
}
template<uni::internal::derived_from_template<std::queue> T>
std::string operator()(T val) const {
std::vector<typename T::value_type> vec;
while(!val.empty()) vec.emplace_back(val.front()), val.pop();
return dump_range_impl(vec, Brackets("<", ">"));
}
template<uni::internal::derived_from_template<std::stack> T>
std::string operator()(T val) const {
std::vector<typename T::value_type> vec;
while(!val.empty()) vec.emplace_back(val.top()), val.pop();
std::ranges::reverse(vec);
return dump_range_impl(vec, Brackets("<", ">"));
}
template<uni::internal::derived_from_template<std::priority_queue> T>
std::string operator()(T val) const {
std::vector<typename T::value_type> vec;
while(!val.empty()) vec.emplace_back(val.top()), val.pop();
return dump_range_impl(vec, Brackets("<", ">"));
}
template<class T>
requires uni::internal::derived_from_template<std::remove_cvref_t<T>, std::pair>
std::string operator()(T&& val) const {
std::stringstream res;
res << "( " << dump(val.first) << ", " << dump(val.second) << " )";
return res.str();
}
template<class T>
requires uni::internal::derived_from_template<std::remove_cvref_t<T>, std::tuple>
std::string operator()(T&& val) const {
std::stringstream res;
res << "( ";
dump_tuple_impl<0>(val, res);
res << " )";
return res.str();
}
};
struct dump_range {
template<std::ranges::input_range T>
std::string operator()(T&& val) const {
return dump_range_impl(val);
}
};
struct dump_loggable {
template<uni::internal::loggable T>
std::string operator()(T&& val) const {
auto res = _debug(val);
if constexpr(std::same_as<decltype(res), debug_t>) {
return res;
}
else {
return dump(res);
}
}
};
template<class T>
std::string dump(T&& val) {
if constexpr(std::same_as<std::remove_cvref_t<T>, debug_t>) {
// return "debug_t";
return dump_debug_t(std::forward<T>(val));
}
if constexpr(std::invocable<dump_primitive_like, T>) {
// return "primitive";
return dump_primitive_like{}(std::forward<T>(val));
}
if constexpr(std::invocable<dump_loggable, T>) {
// return "loggable";
return dump_loggable{}(std::forward<T>(val));
}
if constexpr(std::invocable<dump_has_val, T>) {
// return "has val";
return dump_has_val{}(std::forward<T>(val));
}
if constexpr(std::invocable<dump_bitset, T>) {
// return "bitset";
return dump_bitset{}(std::forward<T>(val));
}
if constexpr(std::invocable<dump_iterator, T>) {
// return "iterator";
return dump_iterator{}(std::forward<T>(val));
}
if constexpr(std::invocable<dump_wrapper, T>) {
// return "wrapper";
return dump_wrapper{}(std::forward<T>(val));
}
if constexpr(std::invocable<dump_range, T>) {;
// return "range";
return dump_range{}(std::forward<T>(val));
}
return "== dump error ==";
}
template<class T> void debug(T&& val, const std::string& endl) {
*cdebug << dump(val) << endl << std::flush;
}
constexpr std::string_view WHITESPACES = " \n\r\t\f\v";
std::string ltrim(const std::string &s)
{
size_t start = s.find_first_not_of(WHITESPACES);
return (start == std::string::npos) ? "" : s.substr(start);
}
std::string rtrim(const std::string &s)
{
size_t end = s.find_last_not_of(WHITESPACES);
return (end == std::string::npos) ? "" : s.substr(0, end + 1);
}
std::string trim(const std::string &s) {
return rtrim(ltrim(s));
}
std::vector<std::string> split(const std::string& str) {
static constexpr char SEPARATOR = ',';
static constexpr char ESCAPE = '\\';
static constexpr std::string_view QUOTATIONS = "\"\'";
static constexpr std::string_view PARENTHESES = "()[]{}<>";
static constexpr auto PARENTHESES_KINDS = std::ranges::size(PARENTHESES);
static_assert(PARENTHESES_KINDS % 2 == 0);
std::vector<std::string> res = { "" };
bool quoted = false;
std::array<int,(PARENTHESES_KINDS / 2)> enclosed = { 0 };
for(auto itr = std::ranges::begin(str); itr != std::ranges::end(str); ++itr) {
if(std::ranges::find(QUOTATIONS, *itr) != std::ranges::end(QUOTATIONS)) {
if(itr == std::ranges::begin(str) or *std::ranges::prev(itr) != ESCAPE) {
quoted ^= true;
}
}
if(const auto found = std::ranges::find(PARENTHESES, *itr); found != std::ranges::end(PARENTHESES)) {
if(not quoted) {
auto& target = enclosed[std::ranges::distance(std::begin(PARENTHESES), found) / 2];
target = std::max(0, target - static_cast<int>((std::ranges::distance(std::begin(PARENTHESES), found) % 2) * 2) + 1);
}
}
if(
not quoted
and static_cast<std::size_t>(std::ranges::count(enclosed, 0)) == std::ranges::size(enclosed)
and *itr == SEPARATOR
) {
res.push_back("");
}
else {
res.back() += *itr;
}
}
for(auto&& v : res) v = trim(v);
return res;
}
template<class Arg> void raw(std::nullptr_t, Arg&& arg) { *cdebug << std::forward<Arg>(arg) << std::flush; }
template<class Arg> void raw(Arg&& arg) { *cdebug << dump(std::forward<Arg>(arg)) << std::flush; }
void debug(const std::vector<std::string>, const size_t, const int, const std::string) { debug(nullptr, COLOR_INIT + "\n"); }
std::map<std::pair<std::string, int>, int> count;
template<class Head, class... Tail>
void debug(
const std::vector<std::string> args, const size_t idx,
const int line, const std::string path,
Head&& H, Tail&&... T
) {
if(idx == 0) {
std::string file = path.substr(path.find_last_of("/") + 1);
debug(nullptr, COLOR_LINE + file + " #" + std::to_string(line) + " (" + std::to_string(count[{ file, line }]++) + ")" + COLOR_INIT);
}
debug(nullptr, "\n - ");
const std::string content = dump(H);
const std::string type_name = get_type_name(std::forward<Head>(H));
debug(nullptr, COLOR_IDENTIFIER + args[idx] + COLOR_INIT + " : ");
debug(nullptr, content);
if(type_name.size() + content.size() >= 300) debug(nullptr, "\n ");
debug(nullptr, " " + type_name);
debug(args, idx + 1, 0, path, std::forward<Tail>(T)...);
}
} // namespace debugger
#line 30 "data_structure/dynamic_segment_tree.hpp"
namespace uni {
namespace internal {
namespace dynamic_segment_tree_impl {
// Thanks to: atcoder::segtree
template<algebraic::internal::monoid Monoid, class NodeHandler>
struct core {
using size_type = internal::size_t;
using operand = Monoid;
struct node_type;
using node_handler = NodeHandler::template handler<node_type>;
using allocator_type = typename node_handler::allocator_type;
using node_pointer = typename node_handler::node_pointer;
protected:
[[no_unique_address]] node_handler _node_handler;
public:
explicit core(const allocator_type& allocator = allocator_type()) noexcept(NO_EXCEPT) : _node_handler(allocator) {}
core(const core&, const allocator_type& allocator) noexcept(NO_EXCEPT) : _node_handler(allocator) {}
core(core&&, const allocator_type& allocator) noexcept(NO_EXCEPT) : _node_handler(allocator) {}
struct node_type {
size_type index;
operand val, acc;
node_pointer left = node_handler::nil, right = node_handler::nil;
node_type() noexcept = default;
node_type(const size_type _index, const operand& _val) noexcept(NO_EXCEPT)
: index(_index), val(_val), acc(_val)
{}
};
protected:
inline void pull(const node_pointer& tree) const noexcept(NO_EXCEPT) {
tree->acc = tree->left->acc + tree->val + tree->right->acc;
}
inline void dispose(const node_pointer& tree) noexcept(NO_EXCEPT) {
if(this->_node_handler.disposable(tree)) {
this->dispose(tree->left);
this->dispose(tree->right);
this->_node_handler.dispose(tree);
}
}
public:
template<std::random_access_iterator I>
node_pointer build(const size_type lower, const size_type upper, const size_type l, const size_type r, I first) noexcept(NO_EXCEPT) {
const size_type middle = (lower + upper) >> 1;
const auto itr = std::ranges::next(first, middle);
if(middle < l || r <= middle) return node_handler::nil;
node_pointer node = this->_node_handler.create(middle, *itr);
node->left = this->build(lower, middle, l, middle, first);
node->right = this->build(middle, upper, middle + 1, r, first);
this->pull(node);
return node;
}
template<std::random_access_iterator I, std::sentinel_for<I> S>
node_pointer build(I first, S last) noexcept(NO_EXCEPT) {
const size_type size = std::ranges::distance(first, last);
return this->build(0, size, 0, size, first);
}
void set(node_pointer& tree, const size_type lower, const size_type upper, size_type pos, operand val) noexcept(NO_EXCEPT) {
if(tree == node_handler::nil) {
tree = this->_node_handler.create(pos, val);
return;
}
tree = this->_node_handler.clone(tree);
if(tree->index == pos) {
tree->val = val;
this->pull(tree);
return;
}
const size_type middle = (lower + upper) >> 1;
if(pos < middle) {
if(tree->index < pos) std::swap(tree->index, pos), std::swap(tree->val, val);
this->set(tree->left, lower, middle, pos, val);
}
else {
if(pos < tree->index) std::swap(tree->index, pos), std::swap(tree->val, val);
this->set(tree->right, middle, upper, pos, val);
}
this->pull(tree);
}
operand get(const node_pointer& tree, const size_type lower, const size_type upper, const size_type pos) const noexcept(NO_EXCEPT) {
if(tree == node_handler::nil) return {};
if(tree->index == pos) return tree->val;
const size_type middle = (lower + upper) >> 1;
if(pos < middle) return this->get(tree->left, lower, middle, pos);
else return this->get(tree->right, middle, upper, pos);
}
operand fold(const node_pointer& tree, const size_type lower, const size_type upper, const size_type l, const size_type r) const noexcept(NO_EXCEPT) {
if(tree == node_handler::nil || upper <= l || r <= lower) return {};
if(l <= lower && upper <= r) return tree->acc;
const size_type middle = (lower + upper) >> 1;
operand val = this->fold(tree->left, lower, middle, l, r);
if(l <= tree->index && tree->index < r) val = val + tree->val;
return val + this->fold(tree->right, middle, upper, l, r);
}
void clear(const node_pointer& tree, const size_type lower, const size_type upper, const size_type l, const size_type r) const noexcept(NO_EXCEPT) {
if(tree == node_handler::nil || upper <= l || r <= lower) return;
if(l <= lower && upper <= r) {
this->dispose(tree);
tree = node_handler::nil;
return;
}
const size_type middle = (lower + upper) >> 1;
this->clear(tree->left, lower, middle, l, r);
this->clear(tree->right, middle, upper, l, r);
this->pull(tree);
}
template<class F>
size_type max_right(const node_pointer& tree, const size_type lower, const size_type upper, const size_type l, F&& f, operand& acc) const {
if(tree == node_handler::nil || upper <= l) return -1;
if(f(acc + tree->acc)) {
acc = acc + tree->acc;
return -1;
}
const size_type middle = (lower + upper) >> 1;
const size_type res = this->max_right(tree->left, lower, middle, l, f, acc);
if(res != -1) return res;
if(l <= tree->index && !f(acc = acc + tree->val)) return tree->index;
return this->max_right(tree->right, middle, upper, l, std::forward<F>(f), acc);
}
template<class F>
size_type min_left(const node_pointer& tree, const size_type lower, const size_type upper, const size_type r, F&& f, operand& acc) const {
if(tree == node_handler::nil || r <= lower) return 0;
if(f(tree->acc + acc)) {
acc = tree->acc + acc;
return 0;
}
const size_type middle = (lower + upper) >> 1;
const size_type res = this->min_left(tree->right, middle, upper, r, f, acc);
if(res != 0) return res;
if(tree->index < r && !f(acc = tree->val + acc)) {
return tree->index + 1;
}
return this->min_left(tree->left, lower, middle, r, std::forward<F>(f), acc);
}
public:
debugger::debug_t dump_rich(const node_pointer& tree, const std::string prefix = " ", const int dir = 0) const {
if(!tree || tree == node_handler::nil) return prefix + "\n";
const auto left = this->dump_rich(tree->left, prefix + (dir == 1 ? "| " : " "), -1);
const auto here = prefix + "--+ " + debugger::dump(tree->index) + " : " + debugger::dump(tree->val) + "\n";
const auto right = this->dump_rich(tree->right, prefix + (dir == -1 ? "| " : " "), 1);
return left + here + right;
}
debugger::debug_t _debug(const node_pointer tree) const {
if(!tree || tree == node_handler::nil) return "";
return
"(" +
this->_debug(tree->left) + " " +
debugger::dump(tree->index) + " : " + debugger::dump(tree->val) +
this->_debug(tree->right) +
")";
}
};
} // namespace dynamic_segment_tree_impl
} // namespace internal
template<class T, class = node_handlers::reusing<std::allocator<T>>>
struct dynamic_segment_tree : internal::unconstructible {};
template<actions::internal::operatable_action Action, class NodeHandler>
struct dynamic_segment_tree<Action, NodeHandler>
: private internal::dynamic_segment_tree_impl::core<typename Action::operand, NodeHandler>
{
private:
using core = typename internal::dynamic_segment_tree_impl::core<typename Action::operand, NodeHandler>;
public:
using value_type = typename core::operand;
using size_type = typename core::size_type;
using node_handler = typename core::node_handler;
using allocator_type = typename core::allocator_type;
using node_type = typename core::node_type;
using node_pointer = typename core::node_pointer;
private:
inline auto _positivize_index(const size_type p) const noexcept(NO_EXCEPT) {
return p < 0 ? this->_n + p : p;
}
size_type _n = 0;
node_pointer _root = node_handler::nil;
public:
~dynamic_segment_tree() { this->dispose(this->_root); }
dynamic_segment_tree(const allocator_type& allocator = allocator_type()) noexcept(NO_EXCEPT) : core(allocator) {};
dynamic_segment_tree(const dynamic_segment_tree& source, const allocator_type& allocator) noexcept(NO_EXCEPT)
: core(allocator), _n(source._n), _root(source._root)
{}
dynamic_segment_tree(dynamic_segment_tree&& source, const allocator_type& allocator) noexcept(NO_EXCEPT)
: core(allocator), _n(source._n), _root(source._root)
{}
explicit dynamic_segment_tree(const size_type n, const allocator_type& allocator = allocator_type()) noexcept(NO_EXCEPT)
: core(allocator), _n(n)
{}
template<std::convertible_to<value_type> T>
dynamic_segment_tree(const std::initializer_list<T>& init_list, const allocator_type& allocator = allocator_type()) noexcept(NO_EXCEPT)
: dynamic_segment_tree(init_list, allocator)
{}
template<std::input_iterator I, std::sized_sentinel_for<I> S>
dynamic_segment_tree(I first, S last, const allocator_type& allocator = allocator_type()) noexcept(NO_EXCEPT) : dynamic_segment_tree(allocator) {
this->assign(first, last);
}
template<std::ranges::input_range R>
requires (!std::same_as<std::remove_cvref_t<R>, dynamic_segment_tree>)
dynamic_segment_tree(R&& range, const allocator_type& allocator = allocator_type()) noexcept(NO_EXCEPT)
: dynamic_segment_tree(ALL(range), allocator)
{}
inline auto clone() const noexcept(NO_EXCEPT) { return *this; }
inline auto size() const noexcept(NO_EXCEPT) { return this->_n; }
inline auto& clear() noexcept(NO_EXCEPT) {
this->dispose(this->_root);
this->_n = 0;
this->_root = node_handler::nil;
return *this;
}
template<std::convertible_to<value_type> T>
inline auto& assign(const std::initializer_list<T>& init_list) noexcept(NO_EXCEPT) { return this->assign(init_list); }
template<std::input_iterator I, std::sized_sentinel_for<I> S>
inline auto& assign(I first, S last) noexcept(NO_EXCEPT) {
this->_n = std::ranges::distance(first, last);
this->_root = this->build(first, last);
return *this;
}
template<std::ranges::input_range R>
inline auto& assign(R&& range) noexcept(NO_EXCEPT) { return this->assign(ALL(range)); }
inline auto& set(const size_type pos, value_type val) noexcept(NO_EXCEPT) {
assert(pos < this->_n);
this->core::set(this->_root, 0, this->_n, pos, val);
return *this;
}
inline auto get(const size_type pos) const noexcept(NO_EXCEPT) {
assert(pos < this->_n);
return this->core::get(this->_root, 0, this->_n, pos);
}
inline auto& add(const size_type pos, const value_type& val) noexcept(NO_EXCEPT) {
assert(0 <= pos && pos < this->_n);
this->set(pos, this->get(pos) + val);
return *this;
}
inline auto fold(const size_type l, const size_type r) const noexcept(NO_EXCEPT) {
assert(0 <= l && l <= r && r <= this->_n);
return this->core::fold(this->_root, 0, this->_n, l, r);
}
inline auto fold() const noexcept(NO_EXCEPT) { return this->_root->acc; }
inline auto& clear(const size_type l, const size_type r) noexcept(NO_EXCEPT) {
assert(0 <= l && l <= r && r <= this->_n);
this->core::clear(this->_root, 0, this->_n, l, r);
return *this;
}
template<bool (*f)(value_type)>
inline auto max_right(const size_type l) const noexcept(NO_EXCEPT) {
return this->max_right(l, [](const value_type& val) { return f(val); });
}
template<class F>
inline auto max_right(const size_type l, const F &f) const noexcept(NO_EXCEPT) {
assert(0 <= l && l <= this->_n);
value_type acc;
assert(f(acc));
const auto res = this->core::max_right(this->_root, 0, this->_n, l, f, acc);
return res == -1 ? this->_n : res;
}
template<bool (*f)(value_type)>
inline auto min_left(const size_type r) const noexcept(NO_EXCEPT) {
return this->min_left(r, [](const value_type& val) noexcept(NO_EXCEPT) { return f(val); });
}
template<class F>
inline auto min_left(const size_type r, const F &f) const noexcept(NO_EXCEPT) {
assert(0 <= r && r <= this->_n);
value_type acc;
assert(f(acc));
return this->core::min_left(this->_root, 0, this->_n, r, f, acc);
}
struct point_reference : internal::point_reference<dynamic_segment_tree> {
point_reference(dynamic_segment_tree *const super, const size_type p) noexcept(NO_EXCEPT)
: internal::point_reference<dynamic_segment_tree>(super, super->_positivize_index(p))
{
assert(0 <= this->_pos && this->_pos < this->_super->_n);
}
inline operator value_type() const noexcept(NO_EXCEPT) { return this->_super->get(this->_pos); }
inline auto val() const noexcept(NO_EXCEPT) { return this->_super->get(this->_pos); }
inline auto& operator=(const value_type& v) noexcept(NO_EXCEPT) {
this->_super->set(this->_pos, v);
return *this;
}
inline auto& operator+=(const value_type& v) noexcept(NO_EXCEPT) {
this->_super->add(this->_pos, v);
return *this;
}
};
struct range_reference : internal::range_reference<dynamic_segment_tree> {
range_reference(dynamic_segment_tree *const super, const size_type l, const size_type r) noexcept(NO_EXCEPT)
: internal::range_reference<dynamic_segment_tree>(super, super->_positivize_index(l), super->_positivize_index(r))
{
assert(0 <= this->_begin && this->_begin <= this->_end && this->_end <= this->_super->_n);
}
inline auto fold() noexcept(NO_EXCEPT) {
return this->_super->fold(this->_begin, this->_end);
}
};
inline auto operator[](const size_type p) noexcept(NO_EXCEPT) { return point_reference(this, p); }
inline auto operator()(const size_type l, const size_type r) noexcept(NO_EXCEPT) { return range_reference(this, l, r); }
public:
struct iterator;
protected:
using iterator_interface = internal::container_iterator_interface<value_type, const dynamic_segment_tree, iterator>;
public:
struct iterator : iterator_interface {
using iterator_interface::iterator_interface;
};
inline auto begin() const noexcept(NO_EXCEPT) { return iterator(this, 0); }
inline auto end() const noexcept(NO_EXCEPT) { return iterator(this, this->_n); }
inline auto rbegin() const noexcept(NO_EXCEPT) { return std::make_reverse_iterator(this->end()); }
inline auto rend() const noexcept(NO_EXCEPT) { return std::make_reverse_iterator(this->begin()); }
using core::dump_rich;
using core::_debug;
debugger::debug_t dump_rich(const std::string prefix = " ") const {
return "\n" + this->dump_rich(this->_root, prefix);
}
debugger::debug_t _debug() const {
return "[ " + this->_debug(this->_root) + " ]";
}
};
template<class Action, class Allocator = std::allocator<Action>>
using persistent_dynamic_segment_tree = dynamic_segment_tree<Action, node_handlers::cloneable<Allocator>>;
namespace pmr {
template<class Action>
using dynamic_segment_tree = uni::dynamic_segment_tree<Action, std::pmr::polymorphic_allocator<Action>>;
template<class Action>
using persistent_dynamic_segment_tree = uni::persistent_dynamic_segment_tree<Action, std::pmr::polymorphic_allocator<Action>>;
}; // namespace pmr
} // namespace uni
#line 2 "data_structure/dynamic_sequence.hpp"
#line 8 "data_structure/dynamic_sequence.hpp"
#include <random>
#line 12 "data_structure/dynamic_sequence.hpp"
#line 15 "data_structure/dynamic_sequence.hpp"
#line 2 "internal/uncopyable.hpp"
namespace uni {
namespace internal {
struct uncopyable {
uncopyable() noexcept {}
uncopyable(const uncopyable&) = delete;
uncopyable& operator=(const uncopyable&) = delete;
};
} // namespace internal
} // namespace uni
#line 22 "data_structure/dynamic_sequence.hpp"
#line 25 "data_structure/dynamic_sequence.hpp"
#line 27 "data_structure/dynamic_sequence.hpp"
#line 2 "data_structure/internal/basic_tree_concept.hpp"
#line 6 "data_structure/internal/basic_tree_concept.hpp"
#line 8 "data_structure/internal/basic_tree_concept.hpp"
namespace uni {
namespace internal {
template<class T>
concept basic_tree =
std::default_initializable<T> &&
std::integral<typename T::size_type> &&
requires (T base, typename T::size_type key, typename T::node_pointer tree, const typename T::node_pointer const_tree) {
base.split(const_tree, key, tree, tree);
base.merge(tree, const_tree, const_tree);
};
} // namespace internal
} // namespace name
#line 2 "data_structure/internal/tree_dumper.hpp"
#line 5 "data_structure/internal/tree_dumper.hpp"
#line 9 "data_structure/internal/tree_dumper.hpp"
namespace uni {
namespace internal {
template<class Derived, class Core, bool LEAF_ONLY>
struct dumpable_tree {
private:
using node_handler = Core::node_handler;
using node_pointer = Core::node_pointer;
using size_type = Core::size_type;
inline auto _push(const node_pointer& tree) {
return static_cast<Derived*>(this)->_impl.push(tree);
// return static_cast<Derived*>(this)->push(tree);
}
public:
debugger::debug_t dump_rich(node_pointer tree, const std::string prefix, const int dir, size_type& index)
requires (!LEAF_ONLY)
{
if(!tree || tree == node_handler::nil) return prefix + "\n";
this->_push(tree);
// debug(tree->priority >= tree->left->priority, tree->priority, tree->left->priority);
// debug(tree->priority >= tree->right->priority, tree->priority, tree->right->priority);
assert(tree->priority >= tree->left->priority);
assert(tree->priority >= tree->right->priority);
const auto left = this->dump_rich(tree->left, prefix + (dir == 1 ? "| " : " "), -1, index);
const auto here =
prefix + "--+ [" +
debugger::dump(index) + ", " + debugger::dump(index + tree->length) + ") : " +
"<" + debugger::dump(tree->priority) + "> " +
debugger::dump(tree->data) + " [" + debugger::dump(tree->length) + "]\n";
index += tree->length;
const auto right = this->dump_rich(tree->right, prefix + (dir == -1 ? "| " : " "), 1, index);
return left + here + right;
}
debugger::debug_t dump_rich(node_pointer tree, const std::string prefix, const int dir, size_type& index)
requires
(
LEAF_ONLY &&
requires {
typename Core::node_colors;
}
)
{
if(!tree || tree == node_handler::nil) return prefix + "\n";
this->_push(tree);
const auto left = this->dump_rich(tree->left, prefix + (dir == 1 ? "| " : " "), -1, index);
const auto right = this->dump_rich(tree->right, prefix + (dir == -1 ? "| " : " "), 1, index);
const auto color = tree->color == Core::node_colors::BLACK ? "<->" : "<+>";
const auto here = [&]() -> std::string {
if(tree->is_leaf()) {
index += tree->size;
return
prefix + "--+ [" +
debugger::dump(index - tree->size) + ", " + debugger::dump(index) + ") : " +
debugger::COLOR_STRING + color + debugger::COLOR_INIT + " " +
debugger::dump(tree->data) + " [" + debugger::dump(tree->size) + "]\n";
}
return "";
}();
return left + here + right;
}
inline debugger::debug_t dump_rich(const node_pointer& tree, const std::string prefix = " ", const int dir = 0) {
size_type index = 0;
return this->dump_rich(tree, prefix, dir, index);
}
debugger::debug_t _debug(node_pointer tree)
requires (!LEAF_ONLY)
{
if(!tree || tree == node_handler::nil) return "";
this->_push(tree);
return
"(" +
this->_debug(tree->left) + " " +
debugger::dump(tree->data) + " [" +
debugger::dump(tree->length) + "] " +
this->_debug(tree->right) +
")";
}
debugger::debug_t _debug(node_pointer tree)
requires LEAF_ONLY
{
if(!tree || tree == node_handler::nil) return "";
this->_push(tree);
return
"(" +
this->_debug(tree->left) + " " +
(
tree->is_leaf()
?
debugger::dump(tree->data) + " [" +
debugger::dump(tree->size) + "] "
:
""
) +
this->_debug(tree->right) +
")";
}
};
} // namespace internal
} // namespace uni
#line 2 "data_structure/internal/dynamic_tree.hpp"
#line 6 "data_structure/internal/dynamic_tree.hpp"
#line 9 "data_structure/internal/dynamic_tree.hpp"
#line 12 "data_structure/internal/dynamic_tree.hpp"
#line 15 "data_structure/internal/dynamic_tree.hpp"
#line 17 "data_structure/internal/dynamic_tree.hpp"
namespace uni {
namespace internal {
namespace dynamic_tree_impl {
namespace internal {
template<class T>
consteval auto to_val() {
if constexpr(actions::internal::operatable_action<T>) return typename T::operand{};
else return T{};
}
template<class T>
consteval auto to_acc() {
if constexpr(actions::internal::operatable_action<T>) return typename T::operand{};
else return dummy{};
}
template<class T>
consteval auto to_lazy() {
if constexpr(actions::internal::effective_action<T>) return typename T::operation{};
else return dummy{};
}
template<class T, bool LEAF_ONLY, bool MAY_BE_LAZY = true>
struct data_type {
using val_t = decltype(to_val<T>());
using acc_t = decltype(to_acc<T>());
using lazy_t = decltype(to_lazy<T>());
val_t val;
[[no_unique_address]] acc_t acc;
[[no_unique_address]] std::conditional_t<MAY_BE_LAZY, lazy_t, dummy> lazy;
bool rev = false;
data_type() noexcept = default;
data_type(const val_t& _val) noexcept(NO_EXCEPT) : val(_val) {}
auto _debug() const { return this->val; }
friend bool operator==(const data_type& lhs, const data_type& rhs) noexcept(NO_EXCEPT) {
return lhs.val == rhs.val;
}
friend auto operator<=>(const data_type& lhs, const data_type& rhs) noexcept(NO_EXCEPT) {
return lhs.val <=> rhs.val;
}
};
template<class ActionOrValue, class Derived, class Context>
struct basic_core
: Context::substance<Derived, internal::data_type<ActionOrValue, Context::LEAF_ONLY>>
{
using data_type = internal::data_type<ActionOrValue, Context::LEAF_ONLY>;
private:
using base = typename Context::substance<Derived, data_type>;
static_assert(basic_tree<base>);
public:
using base::base;
using node_handler = typename base::node_handler;
using node_pointer = typename base::node_pointer;
using size_type = typename base::size_type;
using operand = data_type::val_t;
using operation = data_type::lazy_t;
inline auto val(const node_pointer& node) const noexcept(NO_EXCEPT) {
if constexpr(Context::LEAF_ONLY) {
if(node->is_leaf()) return node->size * node->data.val;
return node->data.val;
}
else {
return node->data.acc;
}
}
using base::split;
using base::merge;
inline void split(const node_pointer tree, const size_type l, const size_type r, node_pointer& t0, node_pointer& t1, node_pointer& t2) noexcept(NO_EXCEPT) {
// See: https://twitter.com/KakurenboUni/status/1784576244321018209
this->split(tree, l, t0, t1);
this->split(t1, r - l, t1, t2);
}
inline void split(
const node_pointer tree,
const size_type l, const size_type m, const size_type r,
node_pointer& t0, node_pointer& t1, node_pointer& t2, node_pointer& t3
) noexcept(NO_EXCEPT) {
// See: https://twitter.com/KakurenboUni/status/1784576244321018209
this->split(tree, l, m, t0, t1, t2);
this->split(t2, r - m, t2, t3);
}
inline void merge(node_pointer& tree, node_pointer t0, const node_pointer t1, const node_pointer t2) noexcept(NO_EXCEPT) {
this->merge(t0, t0, t1);
this->merge(tree, t0, t2);
}
void erase(node_pointer& tree, const size_type l, const size_type r) noexcept(NO_EXCEPT) {
assert(l <= r);
node_pointer t0, t1, t2;
this->split(tree, l, r, t0, t1, t2);
this->dispose(t1);
this->merge(tree, t0, t2);
}
auto pop(node_pointer& tree, const size_type pos, const size_type count = 1) noexcept(NO_EXCEPT) {
assert(0 <= count);
if(count == 0) return operand{};
node_pointer t0, t1, t2;
this->split(tree, pos, pos + count, t0, t1, t2);
const auto res = this->val(t1);
this->dispose(t1);
this->merge(tree, t0, t2);
return res;
}
operand get(node_pointer tree, const size_type pos) noexcept(NO_EXCEPT) {
if(tree == node_handler::nil || pos < 0 || pos >= tree->size) return {};
this->base::push(tree);
const auto lower_bound = tree->left->size;
const auto upper_bound = tree->size - tree->right->size;
if(pos < lower_bound) {
return this->get(tree->left, pos);
}
else if(pos >= upper_bound) {
return this->get(tree->right, pos - upper_bound);
}
else {
return tree->data.val;
}
}
template<std::forward_iterator I>
requires std::output_iterator<I, operand>
void enumerate(node_pointer tree, I& itr) noexcept(NO_EXCEPT) {
if(tree == node_handler::nil) return;
this->base::push(tree);
this->enumerate(tree->left, itr);
if constexpr(Context::LEAF_ONLY) {
if(tree->is_leaf()) {
REP(tree->size) *(itr++) = tree->data.val;
}
}
else {
REP(tree->length) *(itr++) = tree->data.val;
}
this->enumerate(tree->right, itr);
}
auto fold(node_pointer& tree, size_type l, size_type r) noexcept(NO_EXCEPT) {
assert(l <= r);
if(l == r) return operand{};
node_pointer t0, t1, t2;
this->split(tree, l, r, t0, t1, t2);
const operand res = this->val(t1);
this->merge(tree, t0, t1, t2);
return res;
}
};
} // namespace internal
} // namespace dynamic_tree_impl
} // namespace internal
} // namespace uni
#line 31 "data_structure/dynamic_sequence.hpp"
#line 2 "data_structure/treap.hpp"
#line 13 "data_structure/treap.hpp"
#line 2 "utility/functional.hpp"
#line 8 "utility/functional.hpp"
#line 11 "utility/functional.hpp"
#line 13 "utility/functional.hpp"
#line 16 "utility/functional.hpp"
#line 18 "utility/functional.hpp"
namespace uni {
namespace internal {
template<class T> constexpr T plus(const T a, const T b) noexcept(NO_EXCEPT) { return std::plus<T>{}(a, b); }
template<class T> constexpr T minus(const T a, const T b) noexcept(NO_EXCEPT) { return std::minus<T>{}(a, b); }
template<class T> constexpr T bit_xor(const T a, const T b) noexcept(NO_EXCEPT) { return a xor b; }
} // namespace internal
template<class T, class U> inline auto to_optional_if_equal(const T& v, const U& ill) noexcept(NO_EXCEPT) -> std::optional<T> {
return v == ill ? std::optional<T>{} : std::optional<T>(v);
}
template<class T, class U> inline auto to_optional_if_over(const T& v, const U& ill) noexcept(NO_EXCEPT) -> std::optional<T> {
return v > ill ? std::optional<T>{} : std::optional<T>(v);
}
template<class T, class U> inline auto to_optional_if_or_over(const T& v, const U& ill) noexcept(NO_EXCEPT) -> std::optional<T> {
return v >= ill ? std::optional<T>{} : std::optional<T>(v);
}
template<class T, class U> inline auto to_optional_if_under(const T& v, const U& ill) noexcept(NO_EXCEPT) -> std::optional<T> {
return v < ill ? std::optional<T>{} : std::optional<T>(v);
}
template<class T, class U> inline auto to_optional_if_or_under(const T& v, const U& ill) noexcept(NO_EXCEPT) -> std::optional<T> {
return v <= ill ? std::optional<T>{} : std::optional<T>(v);
}
template<class T, class F> inline auto to_optional_if(const T& v, F&& f) noexcept(NO_EXCEPT) -> decltype(f(v), std::optional<T>{}){
return f(v) ? std::optional<T>{} : std::optional<T>(v);
}
template<class T, class U> inline bool chmin(T &a, const U& b) noexcept(NO_EXCEPT) { return (a>b ? a=b, true : false); }
template<class T, class U> inline bool chmax(T &a, const U& b) noexcept(NO_EXCEPT) { return (a<b ? a=b, true : false); }
template<class T, class... Ts> inline bool chmin(T &a, Ts... b) noexcept(NO_EXCEPT) { return chmin(a, min(b...)); }
template<class T, class... Ts> inline bool chmax(T &a, Ts... b) noexcept(NO_EXCEPT) { return chmax(a, max(b...)); }
template<class... Ts>
inline constexpr std::common_type_t<Ts...> tuple_sum(const std::tuple<Ts...>& tuple, const std::common_type_t<Ts...>& base = std::common_type_t<Ts...>()) noexcept(NO_EXCEPT) {
std::common_type_t<Ts...> res = base;
tuple_for_each(tuple, [&](const auto& v) constexpr { res += v; });
return res;
}
template<class... Ts>
inline constexpr std::common_type_t<Ts...> min_element(const std::tuple<Ts...>& tuple) noexcept(NO_EXCEPT) {
return std::apply([&](auto&&... v) constexpr { return min(v...); }, tuple);
}
template<class... Ts>
inline constexpr std::common_type_t<Ts...> max_element(const std::tuple<Ts...>& tuple) noexcept(NO_EXCEPT) {;
return std::apply([&](auto&&... v) constexpr { return max(v...); }, tuple);
}
template<interval_notation INTERVAL, class T0, class T1, class T2>
inline constexpr bool in_range(const T0& x, const T1& l, const T2& r) noexcept(NO_EXCEPT) {
if constexpr(INTERVAL == interval_notation::right_open) return l <= x and x < r;
else if constexpr(INTERVAL == interval_notation::left_open) return l < x and x <= r;
else if constexpr(INTERVAL == interval_notation::open) return l < x and x < r;
return l <= x and x <= r;
}
template<class F, class Tuple>
constexpr void tuple_for_each(F&& f, Tuple&& tuple) {
std::apply(
[&]<class... Ts>(Ts&&... elems) {
(std::invoke(f, std::forward<Ts>(elems)), ...);
},
std::forward<Tuple>(tuple)
);
}
template<class F, class Tuple>
constexpr auto tuple_transform(F&& f, Tuple&& tuple) {
return std::apply(
[&]<class...Ts>(Ts&&... elems) {
return internal::tuple_or_pair_t<std::invoke_result_t<F&,Ts>...>(
std::invoke(f, std::forward<Ts>(elems))...
);
},
std::forward<Tuple>(tuple)
);
}
} // namespace uni
#line 17 "data_structure/treap.hpp"
#line 23 "data_structure/treap.hpp"
#line 25 "data_structure/treap.hpp"
#line 27 "data_structure/treap.hpp"
#line 2 "random/engine.hpp"
#line 7 "random/engine.hpp"
#line 2 "template/debug.hpp"
#ifdef LOCAL_JUDGE
#define DEBUGGER_ENABLED
#define DEBUGGER_COLORED_OUTPUT 1
#endif
#line 13 "template/debug.hpp"
#ifdef DEBUGGER_ENABLED
#define debug(...) debugger::debug(debugger::split(#__VA_ARGS__), 0, __LINE__, __FILE__, __VA_ARGS__)
#define debug_(...) do { const std::string file = __FILE__; debugger::raw(nullptr, debugger::COLOR_LINE + file.substr(file.find_last_of("/") + 1) + " #" + std::to_string(__LINE__) + debugger::COLOR_INIT + " "); debugger::raw(__VA_ARGS__); debugger::raw(nullptr, debugger::COLOR_INIT + "\n"); } while(0);
#define DEBUG if constexpr(true)
#else
#define debug(...) ({ ; })
#define debug_(...) ({ ; })
#define DEBUG if constexpr(false)
#endif
#line 9 "random/engine.hpp"
#line 12 "random/engine.hpp"
#line 14 "random/engine.hpp"
#line 2 "hash/general_hasher.hpp"
#line 7 "hash/general_hasher.hpp"
#line 11 "hash/general_hasher.hpp"
#line 13 "hash/general_hasher.hpp"
namespace uni {
template<std::unsigned_integral R, std::integral T>
constexpr R shrink(T x) noexcept(NO_EXCEPT) {
constexpr int DIGITS_R = std::numeric_limits<R>::digits;
constexpr int DIGITS_T = std::numeric_limits<R>::digits;
REPD(digits, DIGITS_R, DIGITS_T, DIGITS_R) {
x = (x >> digits) ^ uni::lower_bits(x, digits);
}
return x;
}
// Thanks to: https://gist.github.com/badboy/6267743
template<class T>
constexpr u32 hash32(T x) {
if constexpr(std::integral<T>) {
if constexpr(std::signed_integral<T>) return hash32(to_unsigned(x));
constexpr int DIGITS_T = std::numeric_limits<T>::digits;
if constexpr(DIGITS_T <= 32) {
auto h = static_cast<u32>(x);
h = ~h + (h << 15);
h ^= (h >> 12);
h += (h << 2);
h ^= (h >> 4);
h *= 2057;
h ^= (h >> 16);
return h;
}
else if constexpr(DIGITS_T <= 64) {
auto h = static_cast<u64>(x);
h = (~h) + (h << 18);
h ^= (h >> 31);
h *= 21;
h ^= (h >> 11);
h += (h << 6);
h ^= (h >> 22);
return static_cast<u32>(h);
}
else {
return hash32(hash64(x));
}
}
else {
return hash32(std::hash<T>{}(x));
}
}
template<class T>
constexpr u64 hash64(T x) {
if constexpr(std::integral<T>) {
if constexpr(std::signed_integral<T>) return hash64(to_unsigned(x));
constexpr int DIGITS_T = std::numeric_limits<T>::digits;
if constexpr(DIGITS_T <= 64) {
auto h = static_cast<u64>(x);
h = (~h) + (h << 21);
h ^= (h >> 24);
h *= 265;
h ^= (h >> 14);
h *= 21;
h ^= (h >> 28);
h += h << 31;
return h;
}
else {
return hash64(shrink<u64>(x));
}
}
else {
return hash64(std::hash<T>{}(x));
}
}
template<class T>
struct hash {
inline constexpr auto operator()(const T& key) const noexcept(NO_EXCEPT) {
return static_cast<std::size_t>(uni::hash64(key));
}
};
} // namespace uni
#line 16 "random/engine.hpp"
// Thanks to: https://prng.di.unimi.it/
namespace uni {
namespace internal {
template<class Derived, class ResultType>
struct random_engine {
using result_type = ResultType;
static constexpr result_type MIN = std::numeric_limits<result_type>::min();
static constexpr result_type MAX = std::numeric_limits<result_type>::max();
static constexpr result_type min() noexcept(NO_EXCEPT) { return MIN; }
static constexpr result_type max() noexcept(NO_EXCEPT) { return MAX; }
template<std::unsigned_integral T = result_type>
constexpr random_engine(const T _seed = 0) noexcept(NO_EXCEPT) {
static_cast<Derived*>(this)->seed(_seed);
};
inline constexpr result_type operator()() noexcept(NO_EXCEPT) {
return static_cast<Derived*>(this)->next();
}
};
const i64 INTERNAL_RANDOM_GENERATOR_ID = -(1UL << 60);
}; // namespace internal
constexpr float to_float(const std::uint32_t x) noexcept(NO_EXCEPT) {
return float(x >> 8) * 0x1.0p-24f;
}
constexpr double to_double(const std::uint64_t x) noexcept(NO_EXCEPT) {
return double(x >> 11) * 0x1.0p-53;
}
struct mulberry32 : internal::random_engine<mulberry32, std::uint32_t> {
using internal::random_engine<mulberry32, std::uint32_t>::random_engine;
private:
std::uint32_t _x;
public:
template<std::unsigned_integral T>
inline constexpr void seed(const T x) noexcept(NO_EXCEPT) { this->_x = x; }
inline constexpr std::uint32_t next() noexcept(NO_EXCEPT) {
std::uint32_t z = (this->_x += 0x6D2B79F5U);
z = (z ^ (z >> 15)) * (z | 1U);
z ^= z + (z ^ (z >> 7)) * (z | 61U);
return static_cast<std::uint32_t>(z ^ (z >> 14));
}
};
struct splitmix64 : internal::random_engine<splitmix64, std::uint64_t> {
using internal::random_engine<splitmix64, std::uint64_t>::random_engine;
private:
std::uint64_t _x;
public:
template<std::unsigned_integral T>
inline constexpr void seed(const T x) noexcept(NO_EXCEPT) { this->_x = x; }
inline constexpr std::uint64_t next() noexcept(NO_EXCEPT) {
std::uint64_t z = (this->_x += 0x9e3779b97f4a7c15);
z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9;
z = (z ^ (z >> 27)) * 0x94d049bb133111eb;
return z ^ (z >> 31);
}
};
// xoroshiro64**
struct xoroshiro64ss : internal::random_engine<xoroshiro64ss, std::uint32_t> {
using internal::random_engine<xoroshiro64ss, std::uint32_t>::random_engine;
private:
std::uint32_t s[2];
public:
template<std::unsigned_integral T>
inline constexpr void seed(const T _seed) noexcept(NO_EXCEPT) {
mulberry32 gen32(hash32(_seed));
this->s[0] = gen32();
this->s[1] = gen32();
}
inline constexpr std::uint32_t next() noexcept(NO_EXCEPT) {
const std::uint32_t s0 = this->s[0];
std::uint32_t s1 = this->s[1];
const std::uint32_t res = std::rotl(s0 * 0x9E3779BBU, 5) * 5;
s1 ^= s0;
this->s[0] = std::rotl(s0, 26) ^ s1 ^ (s1 << 9);
this->s[1] = std::rotl(s1, 13);
return res;
}
};
struct xoroshiro128ss : internal::random_engine<xoroshiro128ss, std::uint64_t> {
using internal::random_engine<xoroshiro128ss, std::uint64_t>::random_engine;
private:
std::uint64_t s[2];
public:
template<std::unsigned_integral T>
inline constexpr void seed(const T _seed) noexcept(NO_EXCEPT) {
splitmix64 gen64(hash32(_seed));
this->s[0] = gen64();
this->s[1] = gen64();
}
inline constexpr std::uint64_t next() noexcept(NO_EXCEPT) {
const uint64_t s0 = this->s[0];
uint64_t s1 = this->s[1];
const uint64_t res = std::rotl(s0 * 5, 7) * 9;
s1 ^= s0;
this->s[0] = std::rotl(s0, 24) ^ s1 ^ (s1 << 16);
this->s[1] = std::rotl(s1, 37);
return res;
}
};
struct xoroshiro128pp : internal::random_engine<xoroshiro128pp, std::uint64_t> {
using internal::random_engine<xoroshiro128pp, std::uint64_t>::random_engine;
private:
std::uint64_t s[2];
public:
template<std::unsigned_integral T>
inline constexpr void seed(const T _seed) noexcept(NO_EXCEPT) {
splitmix64 gen64(hash32(_seed));
this->s[0] = gen64();
this->s[1] = gen64();
}
inline constexpr std::uint64_t next() noexcept(NO_EXCEPT) {
const std::uint64_t s0 = this->s[0];
std::uint64_t s1 = this->s[1];
const std::uint64_t res = std::rotl(s0 + s1, 17) + s0;
s1 ^= s0;
this->s[0] = std::rotl(s0, 49) ^ s1 ^ (s1 << 21); // a, b
this->s[1] = std::rotl(s1, 28); // c
return res;
}
};
// xoroshiro128+
struct xoroshiro128p : internal::random_engine<xoroshiro128p, std::uint64_t> {
using internal::random_engine<xoroshiro128p, std::uint64_t>::random_engine;
private:
std::uint64_t s[2];
public:
template<std::unsigned_integral T>
inline constexpr void seed(const T _seed) noexcept(NO_EXCEPT) {
splitmix64 gen64(hash64(_seed));
this->s[0] = gen64();
this->s[1] = gen64();
}
inline constexpr std::uint64_t next() noexcept(NO_EXCEPT) {
const std::uint64_t s0 = this->s[0];
std::uint64_t s1 = this->s[1];
const std::uint64_t res = s0 + s1;
s1 ^= s0;
this->s[0] = std::rotl(s0, 24) ^ s1 ^ (s1 << 16);
this->s[1] = std::rotl(s1, 37);
return res;
}
};
struct xoroshiro64s : internal::random_engine<xoroshiro64s, std::uint32_t> {
using internal::random_engine<xoroshiro64s, std::uint32_t>::random_engine;
private:
std::uint32_t s[2];
public:
template<std::unsigned_integral T>
inline constexpr void seed(const T _seed) noexcept(NO_EXCEPT) {
mulberry32 gen32(hash32(_seed));
this->s[0] = gen32();
this->s[1] = gen32();
}
inline constexpr std::uint32_t next() noexcept(NO_EXCEPT) {
const std::uint32_t s0 = s[0];
std::uint32_t s1 = s[1];
const std::uint32_t res = s0 * 0x9E3779BB;
s1 ^= s0;
s[0] = std::rotl(s0, 26) ^ s1 ^ (s1 << 9);
s[1] = std::rotl(s1, 13);
return res;
}
};
using random_engine_32bit = xoroshiro64ss;
using random_engine_64bit = xoroshiro128pp;
using random_engine_float = xoroshiro64s;
using random_engine_double = xoroshiro128p;
random_engine_32bit randi32;
random_engine_64bit randi64;
float randf() {
static random_engine_float gen;
return to_float(gen());
}
double randd() {
static random_engine_double gen;
return to_double(gen());
}
} // namespace uni
#line 29 "data_structure/treap.hpp"
#line 32 "data_structure/treap.hpp"
namespace uni {
namespace internal {
// Thanks to: https://github.com/xuzijian629/library2/blob/master/treap/implicit_treap.cpp
template<class Allocator, class Derived, std::integral SizeType, class ValueType, i64 Id>
struct treap_impl : private uncopyable {
using size_type = SizeType;
using value_type = ValueType;
struct node_type;
using node_handler = typename uni::node_handlers::reusing<Allocator>::template handler<node_type>;
using allocator_type = typename node_handler::allocator_type;
using node_pointer = typename node_handler::node_pointer;
private:
using derived = Derived;
inline auto* _derived() noexcept(NO_EXCEPT) {
return static_cast<derived*>(this);
}
inline const auto* _derived() const noexcept(NO_EXCEPT) {
return static_cast<const derived*>(this);
}
[[no_unique_address]] node_handler _node_handler;
static inline random_engine_32bit _rand;
using priority_type = random_engine_32bit::result_type;
public:
void pull(const node_pointer tree) noexcept(NO_EXCEPT) {
if(tree == node_handler::nil) return;
tree->size = tree->left->size + tree->length + tree->right->size;
this->_derived()->pull(tree);
}
void push(const node_pointer tree) noexcept(NO_EXCEPT) {
if(tree == node_handler::nil) return;
this->_derived()->push(tree);
}
node_pointer create(const value_type& val, const size_type size) noexcept(NO_EXCEPT) {
if(size == 0) return node_handler::nil;
return this->_node_handler.create(val, size);
}
void dispose(node_pointer tree) noexcept(NO_EXCEPT) {
if(this->_node_handler.disposable(tree)) {
this->dispose(tree->left);
this->dispose(tree->right);
this->_node_handler.dispose(tree);
}
}
template<class... Args>
inline void constexpr clone(Args&&...) const noexcept {}
private:
void _rotate_right(node_pointer& tree) noexcept(NO_EXCEPT) { // push ommitted
auto t = tree->left;
tree->left = t->right;
this->pull(tree);
t->right = tree;
this->pull(t);
tree = std::move(t);
}
void _rectify(const node_pointer tree) const noexcept(NO_EXCEPT) {
if(tree->size == 0) return;
std::vector<priority_type> priorities(tree->size);
std::ranges::generate(priorities, treap_impl::_rand);
std::ranges::make_heap(priorities);
std::queue<node_pointer> queue;
queue.push(tree);
auto itr = std::ranges::begin(priorities);
while(!queue.empty()) {
node_pointer node = queue.front();
queue.pop();
node->priority = *(itr++);
if(node->left != node_handler::nil) queue.push(node->left);
if(node->right != node_handler::nil) queue.push(node->right);
}
}
template<std::random_access_iterator I, std::sized_sentinel_for<I> S>
requires std::constructible_from<value_type, std::iter_value_t<I>>
node_pointer _build(I first, S last) noexcept(NO_EXCEPT) {
if(first == last) return node_handler::nil;
const auto length = std::ranges::distance(first, last);
const auto middle = std::ranges::next(first, length >> 1);
node_pointer tree = this->create(value_type{ *middle }, 1);
tree->left = this->_build(first, middle);
tree->right = this->_build(std::ranges::next(middle), last);
this->pull(tree);
return tree;
}
template<std::random_access_iterator I, std::sized_sentinel_for<I> S>
requires
std::constructible_from<value_type, typename std::iter_value_t<I>::first_type> &&
std::integral<typename std::iter_value_t<I>::second_type>
node_pointer _build(I first, S last) noexcept(NO_EXCEPT) {
if(first == last) return node_handler::nil;
const auto length = std::ranges::distance(first, last);
const auto middle = std::ranges::next(first, length >> 1);
node_pointer tree = this->create(value_type{ middle->first }, middle->second );
tree->left = this->_build(first, middle);
tree->right = this->_build(std::ranges::next(middle), last);
this->pull(tree);
return tree;
}
void _split(node_pointer tree, const size_type pos, node_pointer& left, node_pointer& right) noexcept(NO_EXCEPT) {
if(tree == node_handler::nil) {
left = right = node_handler::nil;
return;
}
this->push(tree);
const auto lower_bound = tree->left->size;
const auto upper_bound = tree->size - tree->right->size;
if(pos <= lower_bound) {
node_pointer t;
this->split(tree->left, pos, left, t);
tree->left = t;
if(tree->priority < t->priority) this->_rotate_right(tree);
right = std::move(tree);
this->pull(right);
}
else if(pos >= upper_bound) {
this->split(tree->right, pos - upper_bound, tree->right, right);
left = std::move(tree);
this->pull(left);
}
else {
tree->length = pos - lower_bound;
this->merge(tree->right, this->create(tree->data, upper_bound - pos), tree->right);
this->split(tree->right, 0, tree->right, right), left = std::move(tree);
this->pull(left);
}
}
public:
explicit treap_impl(const allocator_type& allocator = allocator_type()) noexcept(NO_EXCEPT) : _node_handler(allocator) {}
template<std::random_access_iterator I, std::sized_sentinel_for<I> S>
node_pointer build(I first, S last) {
const auto tree = this->_build(first, last);
this->_rectify(tree);
return tree;
}
struct node_type {
priority_type priority = std::numeric_limits<priority_type>::lowest();
node_pointer left = node_handler::nil, right = node_handler::nil;
size_type length, size;
[[no_unique_address]] value_type data;
node_type() noexcept = default;
node_type(const value_type& _data, const size_type _size) noexcept(NO_EXCEPT)
: priority(treap_impl::_rand()), length(_size), size(_size), data(_data)
{}
};
template<bool STRICT = false, bool RETURN_EXISTENCE = false>
void split(const node_pointer tree, const value_type& val, node_pointer& left, node_pointer& right, bool* exist = nullptr) noexcept(NO_EXCEPT) {
if(tree == node_handler::nil) {
left = right = node_handler::nil;
return;
}
this->push(tree);
if constexpr(RETURN_EXISTENCE) *exist |= val == tree->data;
if(val < tree->data || (!STRICT && val == tree->data)) {
this->template split<STRICT, RETURN_EXISTENCE>(tree->left, val, left, tree->left, exist);
right = std::move(tree);
this->pull(right);
}
else {
this->template split<STRICT, RETURN_EXISTENCE>(tree->right, val, tree->right, right, exist);
left = std::move(tree);
this->pull(left);
}
}
void split(const node_pointer tree, const size_type pos, node_pointer& left, node_pointer& right) noexcept(NO_EXCEPT) {
if(pos <= 0) {
left = node_handler::nil;
this->merge(right, this->create(value_type{}, -pos), std::move(tree));
}
else if(tree->size <= pos) {
right = node_handler::nil;
this->merge(left, std::move(tree), this->create(value_type{}, pos - tree->size));
}
else {
this->_split(std::move(tree), pos, left, right);
}
}
void merge(node_pointer& tree, const node_pointer left, const node_pointer right) noexcept(NO_EXCEPT) {
this->push(left);
this->push(right);
if(left == node_handler::nil || right == node_handler::nil) {
tree = left == node_handler::nil ? right : left;
}
else if(left->priority < right->priority) {
this->merge(right->left, left, right->left), tree = std::move(right);
}
else {
this->merge(left->right, left->right, right), tree = std::move(left);
}
this->pull(tree);
}
};
} // namespace internal
template<std::integral SizeType = i64, class Allocator = std::allocator<SizeType>, i64 Id = -1>
struct treap_context {
static constexpr bool LEAF_ONLY = false;
template<class Derived, class ValueType = internal::dummy>
using substance = internal::treap_impl<Allocator, Derived, SizeType, ValueType, Id>;
};
namespace pmr {
template<std::integral SizeType = i64, i64 Id = -1>
using treap_context = uni::treap_context<SizeType, std::pmr::polymorphic_allocator<SizeType>, Id>;
} // namespace pmr
} // namespace uni
#line 33 "data_structure/dynamic_sequence.hpp"
#line 35 "data_structure/dynamic_sequence.hpp"
#line 38 "data_structure/dynamic_sequence.hpp"
#line 40 "data_structure/dynamic_sequence.hpp"
namespace uni {
namespace internal {
namespace dynamic_tree_impl {
template<class ActionOrValue, class Context>
struct sequence_core
: internal::basic_core<ActionOrValue, sequence_core<ActionOrValue, Context>, Context>
// ,
// dumpable_tree<
// sequence_core<ActionOrValue, Context>,
// internal::basic_core<ActionOrValue, sequence_core<ActionOrValue, Context>, Context>,
// Context::LEAF_ONLY
// >
{
private:
using base = typename internal::basic_core<ActionOrValue, sequence_core, Context>;
public:
static constexpr bool ACC = actions::internal::operatable_action<ActionOrValue>;
static constexpr bool LAZY = actions::internal::effective_action<ActionOrValue>;
using base::base;
using data_type = base::data_type;
using operand = base::operand;
using operation = base::operation;
using node_handler = typename base::node_handler;
using node_type = typename base::node_type;
using node_pointer = typename base::node_pointer;
using size_type = typename base::size_type;
inline void pull(const node_pointer& tree) const noexcept(NO_EXCEPT) {
if constexpr(ACC) {
if constexpr(Context::LEAF_ONLY) {
tree->data.val = this->val(tree->left) + this->val(tree->right);
}
else {
tree->data.acc = tree->left->data.acc + tree->length * tree->data.val + tree->right->data.acc;
}
}
}
inline void push(const node_pointer& tree) noexcept(NO_EXCEPT) {
if(tree->data.rev) {
tree->data.rev = false;
std::swap(tree->left, tree->right);
if(tree->left != node_handler::nil) {
this->clone(tree->left);
tree->left->data.rev ^= 1;
}
if(tree->right != node_handler::nil) {
this->clone(tree->right);
tree->right->data.rev ^= 1;
}
}
if constexpr(LAZY) {
if(tree->data.lazy != operation{}) {
if constexpr(Context::LEAF_ONLY) {
if(tree->left != node_handler::nil) {
this->clone(tree->left);
if(tree->left->is_leaf()) {
tree->left->data.val = ActionOrValue::mapping(tree->data.lazy, tree->left->data.val);
}
else {
tree->left->data.lazy = tree->data.lazy + tree->left->data.lazy;
tree->left->data.val = ActionOrValue::mapping(ActionOrValue::power(tree->data.lazy, tree->left->size), tree->left->data.val);
}
}
if(tree->right != node_handler::nil) {
this->clone(tree->right);
if(tree->right->is_leaf()) {
tree->right->data.val = ActionOrValue::mapping(tree->data.lazy, tree->right->data.val);
}
else {
tree->right->data.lazy = tree->data.lazy + tree->right->data.lazy;
tree->right->data.val = ActionOrValue::mapping(ActionOrValue::power(tree->data.lazy, tree->right->size), tree->right->data.val);
}
}
}
else {
if(tree->left != node_handler::nil) {
tree->left->data.lazy = tree->data.lazy + tree->left->data.lazy;
tree->left->data.acc = ActionOrValue::mapping(ActionOrValue::power(tree->data.lazy, tree->left->size), tree->left->data.acc);
}
if(tree->right != node_handler::nil) {
tree->right->data.lazy = tree->data.lazy + tree->right->data.lazy;
tree->right->data.acc = ActionOrValue::mapping(ActionOrValue::power(tree->data.lazy, tree->right->size), tree->right->data.acc);
}
}
tree->data.val = ActionOrValue::mapping(tree->data.lazy, tree->data.val);
tree->data.lazy = operation{};
}
}
}
inline void update(node_pointer& tree) noexcept(NO_EXCEPT) {
if(tree == node_handler::nil) return;
this->base::push(tree);
this->base::pull(tree);
}
void insert(node_pointer& tree, const size_type pos, const operand& val, const size_type count = 1) noexcept(NO_EXCEPT) {
assert(count >= 0);
if(count == 0) return;
node_pointer t0, t1;
this->split(tree, pos, t0, t1);
this->merge(tree, t0, this->create(val, count), t1);
}
template<std::input_iterator I, std::sized_sentinel_for<I> S>
void insert(node_pointer& tree, const size_type pos, I first, S last) noexcept(NO_EXCEPT) {
node_pointer t0, t1;
this->split(tree, pos, t0, t1);
this->merge(tree, t0, this->build(first, last), t1);
}
void add(node_pointer& tree, const size_type pos, const operand& val) noexcept(NO_EXCEPT) {
node_pointer t0, t1, t2;
this->split(tree, pos, t0, t1);
this->split(t1, 1, t1, t2);
const auto prev = this->val(t1);
this->dispose(t1);
t1 = this->create(data_type{ prev + val }, 1);
this->merge(tree, t0, t1, t2);
}
void fill(node_pointer& tree, const size_type l, const size_type r, const operand& val) noexcept(NO_EXCEPT) {
assert(l <= r);
if(l == r) return;
node_pointer t0, t1, t2;
this->split(tree, l, r, t0, t1, t2);
// this->split(tree, l, r, t0, t1, t2);
// this->split(tree, l, t0, t1);
// debug(this->dump_rich(t0), this->dump_rich(t1));
// this->split(t1, r - l, t1, t2);
// debug(this->dump_rich(t1), this->dump_rich(t2));
this->dispose(t1);
t1 = this->create(val, r - l);
this->merge(tree, t0, t1, t2);
// this->merge(t0, t0, t1);
// debug(this->dump_rich(t0));
// this->merge(tree, t0, t2);
// debug(this->dump_rich(tree));
}
template<std::input_iterator I, std::sized_sentinel_for<I> S>
void fill(node_pointer& tree, const size_type pos, I first, S last) noexcept(NO_EXCEPT) {
node_pointer t0, t1, t2;
this->split(tree, pos, pos + std::ranges::distance(first, last), t0, t1, t2);
this->dispose(t1);
this->merge(tree, t0, this->build(first, last), t2);
}
void apply(node_pointer& tree, const size_type l, const size_type r, const operation& val) noexcept(NO_EXCEPT)
requires LAZY
{
assert(l <= r);
if(l == r) return;
node_pointer t0, t1, t2;
this->split(tree, l, r, t0, t1, t2);
if(t1 == node_handler::nil) t1 = this->create(data_type{}, r - l);
t1->data.lazy = val + t1->data.lazy;
this->merge(tree, t0, t1, t2);
}
void reverse(node_pointer& tree, const size_type l, const size_type r) noexcept(NO_EXCEPT) {
assert(l <= r);
if(l == r) return;
node_pointer t0, t1, t2;
this->split(tree, l, r, t0, t1, t2);
if(t1 != node_handler::nil) t1->data.rev ^= 1;
this->merge(tree, t0, t1, t2);
}
void shift_left(node_pointer& tree, const size_type l, const size_type r, const size_type count = 1) noexcept(NO_EXCEPT) {
assert(l <= r);
if(count < 0) return this->shift_right(tree, l, r, -count);
if(count == 0) return;
if(count >= r - l) return this->fill(tree, l, r, {});
node_pointer t0, t1, t2, t3;
this->split(tree, l, l + count, r, t0, t1, t2, t3);
this->dispose(t1);
this->merge(t2, t2, this->create({}, count));
this->merge(tree, t0, t2, t3);
}
void shift_right(node_pointer& tree, const size_type l, const size_type r, const size_type count = 1) noexcept(NO_EXCEPT) {
assert(l <= r);
if(count < 0) return this->shift_left(tree, l, r, -count);
if(count == 0) return;
if(count >= r - l) return this->fill(tree, l, r, {});
node_pointer t0, t1, t2, t3;
this->split(tree, l, r - count, r, t0, t1, t2, t3);
this->dispose(t2);
this->merge(t1, this->create({}, count), t1);
this->merge(tree, t0, t1, t3);
}
void rotate(node_pointer& tree, const size_type l, const size_type m, const size_type r) noexcept(NO_EXCEPT) {
assert(l <= m && m < r);
if(l == m) return;
node_pointer t0, t1, t2, t3;
this->split(tree, l, m, r, t0, t1, t2, t3);
this->merge(t2, t2, t1);
this->merge(tree, t0, t2, t3);
}
template<bool LEFT>
size_type find(const node_pointer& tree, operand& val, const size_type offset) noexcept(NO_EXCEPT) {
if(tree->data.acc + val == val) {
return -1;
}
if constexpr(LEFT) {
if(tree->left != node_handler::nil and tree->left->data.acc + val != val) {
return this->find<true>(tree->left, val, offset);
}
else {
return tree->data.val + val != val ? offset + tree->left->size : this->find<true>(tree->right, val, offset + tree->left->size + 1);
}
}
else {
if(tree->right != node_handler::nil and tree->right->data.acc + val != val) {
return this->find<false>(tree->right, val, offset + tree->left->size + 1);
}
else {
return tree->data.val + val != val ? offset + tree->left->size : this->find<false>(tree->left, val, offset);
}
}
}
template<bool LEFT>
inline size_type find(node_pointer& tree, const size_type l, const size_type r, const operand& val) noexcept(NO_EXCEPT) {
if(l == r) return -1;
node_pointer t0, t1, t2;
this->split(tree, l, r, t0, t1, t2);
const size_type res = this->find<LEFT>(t1, val, l);
this->merge(tree, t0, t1, t2);
return res;
}
};
} // namespace dynamic_tree_impl
} // namespace internal
template<class ActionOrValue, class Context = treap_context<>>
requires internal::available_with<internal::dynamic_tree_impl::sequence_core, ActionOrValue, Context>
struct dynamic_sequence
: private internal::dumpable_tree<
dynamic_sequence<ActionOrValue, Context>,
internal::dynamic_tree_impl::sequence_core<ActionOrValue, Context>,
Context::LEAF_ONLY
>
{
private:
using sequence_core = internal::dynamic_tree_impl::sequence_core<ActionOrValue, Context>;
template<class T>
static consteval auto _to_operator() {
if constexpr(requires { typename T::value_type; }) return typename T::value_type{};
else return T{};
}
public:
using operand = typename sequence_core::operand;
using operation = typename sequence_core::operation;
using value_type = operand;
using operator_type = decltype(_to_operator<operation>());
using node_handler = typename sequence_core::node_handler;
using allocator_type = typename sequence_core::allocator_type;
using node_type = typename sequence_core::node_type;
using node_pointer = typename sequence_core::node_pointer;
using size_type = typename sequence_core::size_type;
private:
using dumper = internal::dumpable_tree<dynamic_sequence, sequence_core, Context::LEAF_ONLY>;
friend dumper;
sequence_core _impl;
node_pointer _root = node_handler::nil;
size_type _offset = 0;
template<std::same_as<size_type>... SizeTypes>
inline void _normalize_index(SizeTypes&... indices) noexcept(NO_EXCEPT) {
const auto min_index = std::min({ indices... });
((indices -= this->_offset), ...);
if(min_index < this->_offset) this->_offset = min_index;
}
public:
~dynamic_sequence() { this->_impl.dispose(this->_root); }
dynamic_sequence(const allocator_type& allocator = allocator_type()) noexcept(NO_EXCEPT) : _impl(allocator) {};
dynamic_sequence(const node_pointer& root, const size_type offset = 0, const allocator_type& allocator = allocator_type()) noexcept(NO_EXCEPT)
: _impl(allocator), _root(root), _offset(offset)
{};
template<std::input_iterator I, std::sized_sentinel_for<I> S>
dynamic_sequence(I first, S last, const allocator_type& allocator = allocator_type()) noexcept(NO_EXCEPT)
: _impl(allocator)
{
this->assign(first, last);
}
explicit dynamic_sequence(const size_type size, const value_type& val, const allocator_type& allocator = allocator_type()) noexcept(NO_EXCEPT)
: _impl(allocator)
{
this->assign(size, val);
}
explicit dynamic_sequence(const size_type size, const allocator_type& allocator = allocator_type()) noexcept(NO_EXCEPT)
: dynamic_sequence(size, value_type{}, allocator)
{}
template<std::ranges::input_range R>
requires (!std::same_as<std::remove_cvref_t<R>, dynamic_sequence>)
explicit dynamic_sequence(R&& range, const allocator_type& allocator = allocator_type()) noexcept(NO_EXCEPT)
: dynamic_sequence(ALL(range), allocator)
{}
template<std::convertible_to<value_type> T>
dynamic_sequence(const std::initializer_list<T>& values, const allocator_type& allocator = allocator_type()) noexcept(NO_EXCEPT)
: dynamic_sequence(values, allocator)
{}
inline auto offset() const noexcept(NO_EXCEPT) { return this->_offset; }
inline auto& root() noexcept(NO_EXCEPT) { return this->_root; }
inline const auto& root() const noexcept(NO_EXCEPT) { return this->_root; }
inline auto size() const noexcept(NO_EXCEPT) { return this->_root->size; }
inline bool empty() const noexcept(NO_EXCEPT) { return this->size() == 0; }
template<internal::resizable_range Container>
inline auto to() noexcept(NO_EXCEPT) {
Container res;
res.resize(this->size());
auto itr = std::ranges::begin(res);
this->_impl.enumerate(this->_root, itr);
return res;
}
inline void clear() noexcept(NO_EXCEPT) {
this->_impl.dispose(this->_root);
this->_root = node_handler::nil;
this->_offset = 0;
}
inline auto clone() const noexcept { return *this; }
inline auto clone(size_type l, size_type r) noexcept(NO_EXCEPT) {
this->_normalize_index(l, r);
node_pointer t0, t1, t2;
this->_impl.split(this->_root, l, r, t0, t1, t2);
this->_impl.merge(this->_root, t0, t1, t2);
return dynamic_sequence(t1, this->_offset);
}
inline auto split(size_type pos) noexcept(NO_EXCEPT) {
this->_normalize_index(pos);
node_pointer t0, t1;
this->_impl.split(this->_root, pos, t0, t1);
return std::make_pair(dynamic_sequence(t0, this->_offset), dynamic_sequence(t1, this->_offset));
}
inline auto extract(size_type l, size_type r) noexcept(NO_EXCEPT) {
this->_normalize_index(l, r);
node_pointer t0, t1, t2;
this->_impl.split(this->_root, l, r, t0, t1, t2);
this->_impl.merge(this->_root, t0, t2);
return dynamic_sequence(t1, this->_offset);
}
inline auto& insert(size_type pos, const dynamic_sequence& other) noexcept(NO_EXCEPT) {
this->_normalize_index(pos);
node_pointer t0, t1;
this->_impl.split(this->_root, pos, t0, t1);
this->_impl.merge(this->_root, t0, other._root, t1);
return *this;
}
inline auto& replace(size_type l, size_type r, const dynamic_sequence& other) noexcept(NO_EXCEPT) {
this->_normalize_index(l, r);
node_pointer t0, t1, t2;
this->_impl.split(this->_root, l, r, t0, t1, t2);
this->_impl.merge(this->_root, t0, other._root, t2);
return *this;
}
inline auto& merge(const dynamic_sequence& other) noexcept(NO_EXCEPT) {
this->_impl.merge(this->_root, this->_root, other._root);
return *this;
}
template<std::input_iterator I, std::sized_sentinel_for<I> S>
inline auto& assign(I first, S last) noexcept(NO_EXCEPT) {
this->clear();
this->_root = this->_impl.build(first, last);
return *this;
}
inline auto& assign(const size_type size, const value_type& val = value_type{}) noexcept(NO_EXCEPT) {
this->clear();
this->_impl.insert(this->_root, 0, val, size);
return *this;
}
template<std::ranges::input_range R>
inline auto& assign(R&& range) noexcept(NO_EXCEPT) {
return this->assign(ALL(range));
}
template<std::convertible_to<value_type> T>
inline auto& assign(const std::initializer_list<T>& values) noexcept(NO_EXCEPT) {
return this->assign(values);
}
inline auto& resize(const size_type size, const value_type& val = value_type{}) noexcept(NO_EXCEPT) {
if(this->size() > size) this->_impl.erase(this->_root, size, this->size());
if(this->size() < size) this->push_back(val, size - this->size());
return *this;
}
inline auto& expand(size_type l, size_type r) noexcept(NO_EXCEPT) {
this->_normalize_index(l, r);
node_pointer t0, t1, t2;
this->_impl.split(this->_root, l, r, t0, t1, t2);
this->_impl.merge(this->_root, t0, t1, t2);
return *this;
}
inline auto& expand(size_type pos) noexcept(NO_EXCEPT) {
this->_normalize_index(pos);
node_pointer t0, t1;
this->_impl.split(this->_root, pos, t0, t1);
this->_impl.merge(this->_root, t0, t1);
return *this;
}
inline auto& fill(const value_type& val) noexcept(NO_EXCEPT) {
this->_impl.fill(this->_root, 0, this->size(), val);
return *this;
}
inline auto fold() noexcept(NO_EXCEPT) {
return this->_impl.val(this->_root);
}
inline auto& apply(const operator_type& val) noexcept(NO_EXCEPT) {
this->_root->data.lazy = this->_root->data.lazy + val;
this->update(this->_root);
return *this;
}
inline auto front() noexcept(NO_EXCEPT) {
return this->_impl.fold(this->_root, 0, 1);
}
inline auto back() noexcept(NO_EXCEPT) {
return this->_impl.fold(this->_root, this->size() - 1, this->size());
}
inline auto& push_front(const value_type& val, const size_type count = 1) noexcept(NO_EXCEPT) {
this->_impl.insert(this->_root, 0, val, count);
return *this;
}
inline auto& push_back(const value_type& val, const size_type count = 1) noexcept(NO_EXCEPT) {
this->_impl.insert(this->_root, this->size(), val, count);
return *this;
}
inline auto& reverse() noexcept(NO_EXCEPT) {
this->_root->data.rev ^= 1;
this->_impl.update(this->_root);
return *this;
}
inline auto& shift_left(const size_type count = 1) noexcept(NO_EXCEPT) {
this->_impl.shift_left(this->_root, 0, this->size(), count);
return *this;
}
inline auto& shift_right(const size_type count = 1) noexcept(NO_EXCEPT) {
this->_impl.shift_right(this->_root, 0, this->size(), count);
return *this;
}
// Same usage as: std::rotate(:m:)
inline auto& rotate(size_type m) noexcept(NO_EXCEPT) {
this->_normalize_index(m);
this->_impl.rotate(this->_root, 0, m, this->size());
return *this;
}
// Same usage as: std::rotate(:m:)
inline auto& rotate_left(const size_type count = 1) noexcept(NO_EXCEPT) {
assert(!this->empty());
this->_impl.rotate(this->_root, 0, uni::mod(count, this->size()), this->size());
return *this;
}
// Same usage as: std::rotate(:m:)
inline auto& rotate_right(const size_type count = 1) noexcept(NO_EXCEPT) {
assert(!this->empty());
this->_impl.rotate(this->_root, 0, uni::mod(-count, this->size()), this->size());
return *this;
}
template<std::input_iterator I, std::sized_sentinel_for<I> S>
inline auto& insert(size_type pos, I first, S last) noexcept(NO_EXCEPT) {
this->_normalize_index(pos);
this->_impl.insert(this->_root, pos, first, last);
return *this;
}
inline auto& insert(size_type pos, const operand& val, const size_type count = 1) noexcept(NO_EXCEPT) {
this->_normalize_index(pos);
this->_impl.insert(this->_root, pos, val, count);
return *this;
}
inline auto& erase(size_type l, size_type r) noexcept(NO_EXCEPT) {
this->_normalize_index(l, r);
this->_impl.erase(this->_root, l, r);
return *this;
}
inline auto& erase(const size_type pos) noexcept(NO_EXCEPT) {
return this->erase(pos, pos + 1);
}
inline auto pop(size_type pos, const size_type count = 1) noexcept(NO_EXCEPT) {
this->_normalize_index(pos);
return this->_impl.pop(this->_root, pos, count);
}
inline auto get(size_type pos) noexcept(NO_EXCEPT) {
this->_normalize_index(pos);
return this->_impl.get(this->_root, pos);
}
inline auto& add(size_type pos, const value_type& val) noexcept(NO_EXCEPT) {
this->_normalize_index(pos);
this->_impl.add(this->_root, pos, val);
return *this;
}
inline auto& fill(size_type l, size_type r, const value_type& val) noexcept(NO_EXCEPT) {
this->_normalize_index(l, r);
this->_impl.fill(this->_root, l, r, val);
return *this;
}
inline auto fold(size_type l, size_type r) noexcept(NO_EXCEPT) {
this->_normalize_index(l, r);
return this->_impl.fold(this->_root, l, r);
}
inline auto& apply(size_type l, size_type r, const operation& val) noexcept(NO_EXCEPT) {
this->_normalize_index(l, r);
this->_impl.apply(this->_root, l, r, val);
return *this;
}
inline auto& reverse(size_type l, size_type r) noexcept(NO_EXCEPT) {
this->_normalize_index(l, r);
this->_impl.reverse(this->_root, l, r);
return *this;
}
inline auto& rotate(size_type l, size_type m, size_type r) noexcept(NO_EXCEPT) {
this->_normalize_index(l, m, r);
this->_impl.rotate(this->_root, l, m, r);
return *this;
}
inline auto& shift_left(size_type l, size_type r, const size_type count = 1) noexcept(NO_EXCEPT) {
this->_normalize_index(l, r);
this->_impl.shift_left(this->_root, l, r, count);
return *this;
}
inline auto& shift_right(size_type l, size_type r, const size_type count = 1) noexcept(NO_EXCEPT) {
this->_normalize_index(l, r);
this->_impl.shift_right(this->_root, l, r, count);
return *this;
}
inline auto pop_front(const size_type count = 1) noexcept(NO_EXCEPT) {
return this->_impl.pop(this->_root, 0, count);
}
inline auto pop_back(const size_type count = 1) noexcept(NO_EXCEPT) {
return this->_impl.pop(this->_root, this->size() - count, count);
}
template<std::ranges::input_range R>
requires (!std::same_as<std::remove_cvref_t<R>, dynamic_sequence>)
inline auto& insert(const size_type pos, R&& range) noexcept(NO_EXCEPT) {
return this->insert(pos, ALL(range));
}
inline auto& set(const size_type pos, const value_type& val) noexcept(NO_EXCEPT) {
return this->fill(pos, pos + 1, val);
}
inline auto& apply(const size_type pos, const operator_type& val) noexcept(NO_EXCEPT) {
return this->apply(pos, pos + 1, val);
}
inline auto& rotate_left(const size_type l, const size_type r, const size_type count = 1) noexcept(NO_EXCEPT) {
assert(l < r);
return this->rotate(l, l + uni::mod(count, r - l), r);
}
inline auto& rotate_right(const size_type l, const size_type r, const size_type count = 1) noexcept(NO_EXCEPT) {
assert(l < r);
return this->rotate(l, l + uni::mod(-count, r - l), r);
}
// Find the min / max k in [l, r) that satisfies (this[k] + x) != x.
// If no such k is found, return -1.
template<bool LEFT = true>
inline auto find(const size_type l, const size_type r, const value_type& val) noexcept(NO_EXCEPT) {
return this->template find<LEFT>(l, r - 1, r);
}
// Find the min / max k in whole that satisfies (this[k] + x) != x.
// If no such k is found, return -1.
template<bool LEFT = true>
inline auto find(const value_type& val) noexcept(NO_EXCEPT) {
return this->find<LEFT>(0, this->size(), val);
}
struct point_reference : internal::point_reference<dynamic_sequence, size_type> {
point_reference(dynamic_sequence *const super, const size_type pos) noexcept(NO_EXCEPT)
: internal::point_reference<dynamic_sequence, size_type>(super, pos)
{}
operator value_type() noexcept(NO_EXCEPT) { return this->_super->get(this->_pos); }
auto val() noexcept(NO_EXCEPT) { return this->_super->get(this->_pos); }
inline auto& operator=(const value_type& val) noexcept(NO_EXCEPT) {
this->_super->set(this->_pos, val);
return *this;
}
inline auto& operator+=(const value_type& val) noexcept(NO_EXCEPT) {
this->_super->add(this->_pos, val);
return *this;
}
inline auto& operator*=(const operator_type& val) noexcept(NO_EXCEPT) {
this->_super->apply(this->_pos, val);
return *this;
}
};
struct range_reference : internal::range_reference<dynamic_sequence, size_type> {
range_reference(dynamic_sequence *const super, const size_type l, const size_type r) noexcept(NO_EXCEPT)
: internal::range_reference<dynamic_sequence, size_type>(super, l, r)
{}
inline auto clone() noexcept(NO_EXCEPT) {
return this->_super->clone(this->_begin, this->_end);
}
inline auto fold() noexcept(NO_EXCEPT) {
return this->_super->fold(this->_begin, this->_end);
}
inline auto& operator=(const value_type& val) noexcept(NO_EXCEPT) {
this->_super->fill(this->_begin, this->_end, val);
return *this;
}
inline auto& operator*=(const operator_type& val) noexcept(NO_EXCEPT) {
this->_super->apply(this->_begin, this->_end, val);
return *this;
}
// Find the min / max k in [l, r) that satisfies (this[k] + x) != x.
// If no such k is found, return -1.
template<bool LEFT = true>
inline auto find(const value_type& val) noexcept(NO_EXCEPT) {
return this->_super->template find<LEFT>(this->_begin, this->_end, val);
}
};
inline auto operator[](const size_type pos) noexcept(NO_EXCEPT) { return point_reference(this, pos); }
inline auto operator()(const size_type l, const size_type r) noexcept(NO_EXCEPT) { return range_reference(this, l, r); }
struct iterator;
protected:
using iterator_interface = internal::container_iterator_interface<value_type, dynamic_sequence, iterator>;
public:
struct iterator : iterator_interface {
using iterator_interface::iterator_interface;
};
inline auto begin() noexcept(NO_EXCEPT) { return iterator(this, 0); }
inline auto end() noexcept(NO_EXCEPT) { return iterator(this, this->size()); }
inline auto rbegin() noexcept(NO_EXCEPT) { return std::make_reverse_iterator(this->end()); }
inline auto rend() noexcept(NO_EXCEPT) { return std::make_reverse_iterator(this->begin()); }
inline auto traverse() const noexcept(NO_EXCEPT) { return typename sequence_core::traverser(this->_root); }
using dumper::dump_rich;
using dumper::_debug;
debugger::debug_t dump_rich(const std::string prefix = " ") {
return "\n" + this->dump_rich(this->_root, prefix);
}
debugger::debug_t _debug() {
return "[ " + this->_debug(this->_root) + " ]";
}
};
} // namespace uni
#line 2 "data_structure/dynamic_set.hpp"
#line 12 "data_structure/dynamic_set.hpp"
#line 15 "data_structure/dynamic_set.hpp"
#line 22 "data_structure/dynamic_set.hpp"
#line 25 "data_structure/dynamic_set.hpp"
#line 27 "data_structure/dynamic_set.hpp"
#line 31 "data_structure/dynamic_set.hpp"
#line 33 "data_structure/dynamic_set.hpp"
#line 35 "data_structure/dynamic_set.hpp"
#line 38 "data_structure/dynamic_set.hpp"
#line 40 "data_structure/dynamic_set.hpp"
namespace uni {
namespace internal {
namespace dynamic_tree_impl {
template<class ActionOrValue, class Context>
requires (!Context::LEAF_ONLY)
struct set_core : internal::basic_core<ActionOrValue, set_core<ActionOrValue, Context>, Context> {
private:
using base = internal::basic_core<ActionOrValue, set_core, Context>;
public:
using base::base;
using data_type = base::data_type;
using operand = base::operand;
using node_handler = typename base::node_handler;
using node_type = typename base::node_type;
using node_pointer = typename base::node_pointer;
using size_type = typename base::size_type;
inline void pull(const node_pointer tree) const noexcept(NO_EXCEPT) {
tree->data.acc = tree->left->data.acc + tree->length * tree->data.val + tree->right->data.acc;
}
inline constexpr void push(const node_pointer) const noexcept(NO_EXCEPT) { /* do nothing */ }
template<std::random_access_iterator I, std::sized_sentinel_for<I> S>
node_pointer build(I first, S last) {
std::vector<i64> val;
val.assign(first, last);
std::ranges::sort(val);
return this->base::build(ALL(val));
}
void insert(node_pointer& tree, const operand& val, const size_type count = 1) noexcept(NO_EXCEPT) {
if(count == 0) return;
if(count < 0) return this->erase(tree, val, -count);
node_pointer t0, t1;
this->split(tree, { val }, t0, t1);
this->merge(tree, t0, this->create(val, count), t1);
}
void insert_unique(node_pointer& tree, const operand& val, const size_type count = 1) noexcept(NO_EXCEPT) {
if(count == 0) return;
if(count < 0) return this->erase(tree, val, -count);
node_pointer t0, t1;
bool exist = false;
this->template split<false, true>(tree, { val }, t0, t1, &exist);
if(exist) this->merge(tree, t0, t1);
else this->merge(tree, t0, this->create(val, count), t1);
}
void erase(node_pointer& tree, const operand& val, const size_type count = 1) noexcept(NO_EXCEPT) {
if(count == 0) return;
if(count < 0) return this->insert(tree, val, -count);
node_pointer t0, t1, t2;
this->split(tree, { val }, t0, t1);
this->split(t1, count, t1, t2);
this->dispose(t1);
this->merge(tree, t0, t2);
}
void erase_limit(node_pointer& tree, const operand& val, size_type count = 1) noexcept(NO_EXCEPT) {
if(count == 0) return;
if(count < 0) return this->insert(tree, val, -count);
node_pointer t0, t1, t2, t3;
this->split(tree, { val }, t0, t1);
this->template split<true>(t1, { val }, t1, t3);
if(count >= t1->size) count = t1->size;
this->split(t1, count, t1, t2);
this->dispose(t1);
this->merge(t2, t0, t2);
this->merge(tree, t2, t3);
}
auto fold(node_pointer tree, const size_type l, const size_type r) noexcept(NO_EXCEPT) {
assert(0 <= l && l <= r && r <= tree->size);
return this->base::fold(tree, l, r);
}
void erase(node_pointer& tree, const size_type l, const size_type r) noexcept(NO_EXCEPT) {
assert(0 <= l && l <= r && r <= tree->size);
this->base::erase(tree, l, r);
}
auto pop(node_pointer& tree, const size_type pos, const size_type count = 1) noexcept(NO_EXCEPT) {
assert(0 <= pos && 0 <= count && pos + count <= tree->size);
return this->base::pop(tree, pos, count);
}
auto get(node_pointer tree, const size_type pos) noexcept(NO_EXCEPT) {
assert(0 <= pos && pos < tree->size);
return this->base::get(tree, pos);
}
template<bool STRICT = false>
auto find(node_pointer& tree, const operand& val) noexcept(NO_EXCEPT) {
node_pointer t0, t1;
this->template split<STRICT>(tree, { val }, t0, t1);
const auto res = t0->size;
this->merge(tree, t0, t1);
return res;
}
auto equal_range(node_pointer& tree, const operand& val) noexcept(NO_EXCEPT) {
node_pointer t0, t1, t2;
this->template split<true>(tree, { val }, t1, t2);
this->split(t1, { val }, t0, t1);
const auto lower = t0->size;
this->merge(t1, t0, t1);
const auto upper = t1->size;
this->merge(tree, t1, t2);
return std::make_pair(std::move(lower), std::move(upper));
}
};
} // namespace dynamic_tree_impl
} // namespace internal
template<class Value, class Context = treap_context<>>
struct dynamic_set : dynamic_set<actions::make_full_t<Value>, Context> {
using dynamic_set<actions::make_full_t<Value>, Context>::dynamic_set;
};
template<actions::internal::full_action ActionOrValue, class Context>
requires internal::available_with<internal::dynamic_tree_impl::set_core, ActionOrValue, Context>
struct dynamic_set<ActionOrValue, Context>
: private internal::dumpable_tree<
dynamic_set<ActionOrValue, Context>,
internal::dynamic_tree_impl::set_core<ActionOrValue, Context>,
Context::LEAF_ONLY
>
{
public:
using action = ActionOrValue;
using operand = typename action::operand;
using value_type = operand;
using set_core = internal::dynamic_tree_impl::set_core<ActionOrValue, Context>;
using node_handler = typename set_core::node_handler;
using allocator_type = typename set_core::allocator_type;
using node_type = typename set_core::node_type;
using node_pointer = typename set_core::node_pointer;
using size_type = typename set_core::size_type;
private:
using dumper = internal::dumpable_tree<dynamic_set, set_core, Context::LEAF_ONLY>;
friend dumper;
set_core _impl;
node_pointer _root = node_handler::nil;
size_type _offset = 0;
public:
~dynamic_set() { this->_impl.dispose(this->_root); }
dynamic_set(const allocator_type& allocator = allocator_type()) noexcept(NO_EXCEPT) : _impl(allocator) {};
template<std::input_iterator I, std::sized_sentinel_for<I> S>
dynamic_set(I first, S last, const allocator_type& allocator = allocator_type()) noexcept(NO_EXCEPT)
: _impl(allocator)
{
this->assign(first, last);
}
explicit dynamic_set(const size_type size, const value_type& val, const allocator_type& allocator = allocator_type()) noexcept(NO_EXCEPT)
: _impl(allocator)
{
this->assign(size, val);
}
explicit dynamic_set(const size_type size, const allocator_type& allocator = allocator_type()) noexcept(NO_EXCEPT)
: dynamic_set(size, value_type{}, allocator)
{}
template<std::ranges::input_range R>
explicit dynamic_set(R&& range, const allocator_type& allocator = allocator_type()) noexcept(NO_EXCEPT)
: dynamic_set(ALL(range), allocator)
{}
template<std::convertible_to<value_type> T>
dynamic_set(const std::initializer_list<T>& values, const allocator_type& allocator = allocator_type()) noexcept(NO_EXCEPT)
: dynamic_set(values, allocator)
{}
inline node_pointer& root() noexcept(NO_EXCEPT) { return this->_root; }
inline const node_pointer& root() const noexcept(NO_EXCEPT) { return this->_root; }
size_type size() const noexcept(NO_EXCEPT) { return this->_root->size; }
bool empty() const noexcept(NO_EXCEPT) { return this->size() == 0; }
template<internal::resizable_range Container>
inline auto to() noexcept(NO_EXCEPT) {
Container res;
res.resize(this->size());
auto itr = std::ranges::begin(res);
this->_impl.enumerate(this->_root, itr);
return res;
}
inline void clear() noexcept(NO_EXCEPT) {
this->_impl.dispose(this->_root);
this->_root = node_handler::nil;
}
template<bool UNIQUE = false, std::input_iterator I, std::sized_sentinel_for<I> S>
inline auto& assign(I first, S last) noexcept(NO_EXCEPT) {
this->clear();
this->insert<UNIQUE>(first, last);
return *this;
}
template<bool UNIQUE = false>
inline auto& assign(const size_type size, const value_type& val = value_type{}) noexcept(NO_EXCEPT) {
this->clear();
this->insert<UNIQUE>(val, size);
return *this;
}
template<bool UNIQUE = false, std::ranges::input_range R>
inline auto& assign(R&& range) noexcept(NO_EXCEPT) {
return this->assign<UNIQUE>(ALL(range));
}
template<bool UNIQUE = false, std::convertible_to<value_type> T>
inline auto& assign(const std::initializer_list<T>& values) noexcept(NO_EXCEPT) {
return this->assign<UNIQUE>(values);
}
template<bool UNIQUE = false>
inline auto& insert(const operand& val, const size_type count = 1) noexcept(NO_EXCEPT) {
if constexpr(UNIQUE) this->_impl.insert_unique(this->_root, val, count);
else this->_impl.insert(this->_root, val, count);
return *this;
}
template<bool UNIQUE = false, std::input_iterator I, std::sized_sentinel_for<I> S>
inline auto& insert(I first, S last) noexcept(NO_EXCEPT) {
for(; first != last; ++first) this->template insert<UNIQUE>(*first);
return *this;
}
template<bool UNIQUE = false, std::ranges::input_range R>
inline auto& insert(R&& range) noexcept(NO_EXCEPT) {
return this->template insert<UNIQUE>(ALL(range));
}
inline auto& fill(const value_type& val) noexcept(NO_EXCEPT) {
const size_type size = this->size();
this->clear();
this->insert(val, size);
return *this;
}
template<bool LIMIT = true>
inline auto& erase(const value_type& val, const size_type count = 1) noexcept(NO_EXCEPT) {
if constexpr(LIMIT) this->_impl.erase_limit(this->_root, val, count);
else this->_impl.erase(this->_root, val, count);
return *this;
}
inline auto& erase(const size_type l, const size_type r) noexcept(NO_EXCEPT) {
this->_impl.erase(this->_root, l, r);
return *this;
}
inline value_type pop(const size_type pos, const size_type count = 1) noexcept(NO_EXCEPT) {
return this->_impl.pop(this->_root, pos, count);
}
inline value_type pop_min(const size_type count = 1) noexcept(NO_EXCEPT) {
return this->pop(0, count);
}
inline value_type pop_max(const size_type count = 1) noexcept(NO_EXCEPT) {
return this->pop(this->size() - count, count);
}
inline operand fold(const size_type l, const size_type r) noexcept(NO_EXCEPT) {
return this->_impl.fold(this->_root, l, r);
}
inline value_type get(const size_type k) noexcept(NO_EXCEPT) {
return this->_impl.get(this->_root, k);
}
inline operand median(const size_type l, const size_type r) noexcept(NO_EXCEPT) {
return this->get((r - l) >> 1);
}
inline value_type min() noexcept(NO_EXCEPT) {
return this->get(0);
}
inline value_type median() noexcept(NO_EXCEPT) {
return this->get(this->size() >> 1);
}
inline value_type max() noexcept(NO_EXCEPT) {
return this->get(this->size() - 1);
}
inline auto fold() noexcept(NO_EXCEPT) {
return this->_root->data.acc;
}
inline value_type operator[](const size_type k) noexcept(NO_EXCEPT) {
return this->get(k);
}
inline value_type operator()(const size_type l, const size_type r) noexcept(NO_EXCEPT) {
return this->fold(l, r);
}
struct iterator;
inline auto lower_bound(const value_type& val) noexcept(NO_EXCEPT) {
return iterator{ this, this->_impl.template find<false>(this->_root, val) };
}
inline auto upper_bound(const value_type& val) noexcept(NO_EXCEPT) {
return iterator{ this, this->_impl.template find<true>(this->_root, val) };
}
inline auto equal_range(const value_type& val) noexcept(NO_EXCEPT) {
const auto [ lower, upper ] = this->_impl.equal_range(this->_root, val);
return std::make_pair(iterator{ this, lower }, iterator{ this, upper });
}
inline size_type count(const value_type& val) noexcept(NO_EXCEPT) {
const auto [ lower, upper ] = this->_impl.equal_range(this->_root, val);
return upper - lower;
}
inline bool contains(const value_type& val) noexcept(NO_EXCEPT) {
return this->count(val) == 1;
}
inline auto& erase(const iterator& itr) noexcept(NO_EXCEPT) {
return this->erase(itr.pos(), itr.pos() + 1);
}
inline auto& erase(const iterator& l, const iterator& r) noexcept(NO_EXCEPT) {
return this->erase(l.pos(), r.pos());
}
protected:
using iterator_interface = internal::container_iterator_interface<value_type,dynamic_set,iterator>;
public:
struct iterator : iterator_interface {
using iterator_interface::iterator_interface;
};
inline auto begin() noexcept(NO_EXCEPT) { return iterator{ this, 0 }; }
inline auto end() noexcept(NO_EXCEPT) { return iterator{ this, this->size() }; }
inline auto rbegin() const noexcept(NO_EXCEPT) { return std::make_reverse_iterator(this->end()); }
inline auto rend() const noexcept(NO_EXCEPT) { return std::make_reverse_iterator(this->begin()); }
using dumper::dump_rich;
using dumper::_debug;
debugger::debug_t dump_rich(const std::string prefix = " ") {
return "\n" + this->dump_rich(this->_root, prefix);
}
debugger::debug_t _debug() {
return "[ " + this->_debug(this->_root) + " ]";
}
};
} // namespace uni
#line 2 "data_structure/fenwick_tree.hpp"
#line 12 "data_structure/fenwick_tree.hpp"
#line 21 "data_structure/fenwick_tree.hpp"
#line 24 "data_structure/fenwick_tree.hpp"
#line 27 "data_structure/fenwick_tree.hpp"
namespace uni {
namespace internal {
namespace fenwick_tree_impl {
// Thanks to: atcoder::fenwick_tree
template<algebraic::internal::monoid Operand>
struct core {
using operand = Operand;
using size_type = internal::size_t;
private:
size_type _n = 0, _bit_ceil = 0;
std::vector<operand> _data;
inline void _init() noexcept(NO_EXCEPT) {
FOR(i, 1, this->_n) {
size_type j = i + (i & -i);
if(j <= this->_n) this->_data[j-1] = this->_data[j-1] + this->_data[i-1];
}
}
public:
core() noexcept(NO_EXCEPT) {}
explicit core(const size_type n) noexcept(NO_EXCEPT)
: _n(n), _bit_ceil(std::bit_ceil<std::make_unsigned_t<size_type>>(n)), _data(n, operand{})
{}
inline size_type size() const noexcept(NO_EXCEPT) { return this->_n; }
template<std::input_iterator I, std::sentinel_for<I> S>
inline void assign(I first, S last) noexcept(NO_EXCEPT) {
if constexpr(std::sized_sentinel_for<S, I>) {
assert(std::ranges::distance(first, last) == this->size());
}
for(size_type i = 0; first < last; ++i, ++first) this->_data[i] = *first;
this->_init();
}
inline void add(size_type p, const operand& x) noexcept(NO_EXCEPT) {
for(p++; p<=this->_n; p += p & -p) this->_data[p-1] = this->_data[p-1] + x;
}
inline void set(const size_type p, const operand& x) noexcept(NO_EXCEPT) {
assert(this->get(p) == this->fold(p, p+1));
this->add(p, x + -this->get(p));
}
inline operand fold(size_type r) const noexcept(NO_EXCEPT) {
operand s = operand{};
for(; r>0; r -= r & -r) s = s + this->_data[r-1];
return s;
}
inline operand fold(size_type l, size_type r) const noexcept(NO_EXCEPT) {
operand s = operand{};
for(; l < r; r -= r & -r) s = s + this->_data[r-1];
for(; r < l; l -= l & -l) s = s + -this->_data[l-1];
return s;
}
inline operand get(size_type p) const noexcept(NO_EXCEPT) {
return this->fold(p, p+1);
}
template<class F>
inline size_type max_right(size_type l, F&& f) const noexcept(NO_EXCEPT)
requires algebraic::internal::invertible<operand>
{
assert(0 <= l && l <= this->_n);
assert(f(operand{}));
if(l == this->_n) return this->_n;
operand inv = -this->fold(l);
size_type p = 0, q = this->_bit_ceil;
for(size_type k=q; k>0; k >>= 1) {
if(p+k <= this->_n and f(this->_data[p+k-1] + inv)) {
inv = inv + this->_data[(p+=k)-1];
}
}
return p;
}
template<class F> inline size_type min_left(size_type r, F&& f) const noexcept(NO_EXCEPT)
requires algebraic::internal::invertible<operand>
{
assert(0 <= r && r <= this->_n);
assert(f(operand{}));
if(r == 0) return 0;
operand acc = this->fold(r);
size_type p = 0, q = std::bit_ceil<std::make_unsigned_t<size_type>>(r);
for(size_type k=q; k>0; k >>= 1) {
if(p+k < r and !f(acc + -this->_data[p+k-1])) {
acc = acc + -this->_data[(p+=k)-1];
}
}
if(p == 0 and f(acc)) return 0;
return p + 1;
}
};
} // namespace fenwick_tree_impl
} // namespace internal
template<class Value>
struct fenwick_tree : internal::unconstructible {};
template<algebraic::internal::monoid Monoid>
struct fenwick_tree<Monoid> : internal::fenwick_tree_impl::core<Monoid> {
static_assert(algebraic::internal::commutative<Monoid>);
private:
using core = typename internal::fenwick_tree_impl::core<Monoid>;
core _impl;
public:
using value_type = typename core::operand;
using size_type = typename core::size_type;
protected:
inline size_type _positivize_index(const size_type p) const noexcept(NO_EXCEPT) {
return p < 0 ? this->_impl.size() + p : p;
}
public:
fenwick_tree() noexcept(NO_EXCEPT) : _impl() {}
explicit fenwick_tree(const size_type n) noexcept(NO_EXCEPT) : _impl(n) {}
explicit fenwick_tree(const size_type n, const value_type& v) noexcept(NO_EXCEPT) : _impl(n) { this->_impl.fill(v); }
template<std::convertible_to<value_type> T>
fenwick_tree(const std::initializer_list<T>& init_list) noexcept(NO_EXCEPT) : fenwick_tree(ALL(init_list)) {}
template<std::input_iterator I, std::sized_sentinel_for<I> S>
explicit fenwick_tree(I first, S last) noexcept(NO_EXCEPT)
: fenwick_tree(static_cast<size_type>(std::ranges::distance(first, last)))
{ this->assign(first, last); }
template<std::ranges::input_range R>
explicit fenwick_tree(R&& range) noexcept(NO_EXCEPT) : fenwick_tree(ALL(range)) {}
template<std::convertible_to<value_type> T>
inline auto& assign(const std::initializer_list<T>& init_list) noexcept(NO_EXCEPT){ return this->assign(ALL(init_list)); }
template<std::input_iterator I, std::sentinel_for<I> S>
inline auto& assign(I first, S last) noexcept(NO_EXCEPT) {
this->_impl.assign(first, last);
return *this;
}
template<std::ranges::input_range R>
inline auto& assign(R&& range) noexcept(NO_EXCEPT) { return this->assign(ALL(range)); }
inline auto& fill(const value_type& v = value_type()) noexcept(NO_EXCEPT) {
std::fill(this->data(), this->data() + this->_impl.size(), v);
this->_init();
return *this;
}
inline auto size() const noexcept(NO_EXCEPT) { return this->_impl.size(); }
inline bool empty() const noexcept(NO_EXCEPT) { return this->_impl.size() == 0; }
struct point_reference : internal::point_reference<fenwick_tree> {
point_reference(fenwick_tree *const super, const size_type p) noexcept(NO_EXCEPT)
: internal::point_reference<fenwick_tree>(super, super->_positivize_index(p))
{
assert(0 <= this->_pos && this->_pos < this->_super->size());
}
operator value_type() const noexcept(NO_EXCEPT) { return this->_super->get(this->_pos); }
auto val() const noexcept(NO_EXCEPT) { return this->_super->get(this->_pos); }
inline auto& operator=(const value_type& v) noexcept(NO_EXCEPT) {
this->_super->set(this->_pos, v);
return *this;
}
inline auto& operator+=(const value_type& v) noexcept(NO_EXCEPT) {
this->_super->add(this->_pos, v);
return *this;
}
};
struct range_reference : internal::range_reference<fenwick_tree> {
range_reference(fenwick_tree *const super, const size_type l, const size_type r) noexcept(NO_EXCEPT)
: internal::range_reference<fenwick_tree>(super, super->_positivize_index(l), super->_positivize_index(r))
{
assert(0 <= this->_begin && this->_begin <= this->_end && this->_end <= this->_super->size());
}
inline auto fold() noexcept(NO_EXCEPT) {
if(this->_begin == 0 and this->_end == this->_super->size()) return this->_super->fold();
if(this->_begin == 0) return this->_super->fold(this->_end);
return this->_super->fold(this->_begin, this->_end);
}
};
inline auto& add(const size_type p, const value_type& x) noexcept(NO_EXCEPT) {
assert(0 <= p && p < this->_impl.size());
this->_impl.add(p, x);
return *this;
}
inline auto& set(const size_type p, const value_type& x) noexcept(NO_EXCEPT)
requires algebraic::internal::invertible<value_type>
{
assert(0 <= p && p < this->_impl.size());
this->_impl.set(p, x);
return *this;
}
inline value_type get(const size_type p) const noexcept(NO_EXCEPT)
requires algebraic::internal::invertible<value_type>
{
assert(0 <= p && p < this->_impl.size());
return this->_impl.get(p);
}
inline auto operator[](const size_type p) noexcept(NO_EXCEPT) { return point_reference(this, p); }
inline const auto operator()(const size_type l, const size_type r) const noexcept(NO_EXCEPT) {
return range_reference(this, l, r);
}
inline auto operator()(const size_type l, const size_type r) noexcept(NO_EXCEPT) {
return range_reference(this, l, r);
}
inline auto fold(const size_type l, const size_type r) const noexcept(NO_EXCEPT)
requires algebraic::internal::invertible<value_type>
{
assert(0 <= l && l <= r && r <= this->_impl.size());
return this->_impl.fold(l, r);
}
inline auto fold(const size_type r) const noexcept(NO_EXCEPT) {
assert(0 <= r && r <= this->_impl.size());
return this->_impl.fold(r);
}
inline auto fold() const noexcept(NO_EXCEPT) {
return this->_impl.fold(this->_impl.size());
}
struct iterator;
protected:
using iterator_interface = internal::container_iterator_interface<value_type, const fenwick_tree, iterator>;
public:
struct iterator : iterator_interface {
using iterator_interface::iterator_interface;
};
inline auto begin() const noexcept(NO_EXCEPT) { return iterator(this, 0); }
inline auto end() const noexcept(NO_EXCEPT) { return iterator(this, this->_impl.size()); }
inline auto rbegin() const noexcept(NO_EXCEPT) { return std::make_reverse_iterator(this->end()); }
inline auto rend() const noexcept(NO_EXCEPT) { return std::make_reverse_iterator(this->begin()); }
};
template<actions::internal::operatable_action Action>
struct fenwick_tree<Action> : fenwick_tree<typename Action::operand> {
using fenwick_tree<typename Action::operand>::fenwick_tree;
};
} // namespace uni
#line 2 "data_structure/foldable_deque.hpp"
#line 6 "data_structure/foldable_deque.hpp"
#line 2 "adaptor/stack.hpp"
#line 6 "adaptor/stack.hpp"
namespace uni {
template<class T, class Allocator = std::allocator<T>>
using stack = std::stack<T, std::vector<T, Allocator>>;
} // namespace uni
#line 2 "adaptor/deque_by_stack.hpp"
#line 9 "adaptor/deque_by_stack.hpp"
#line 12 "adaptor/deque_by_stack.hpp"
#line 14 "adaptor/deque_by_stack.hpp"
namespace uni {
template<class Front, class Back = Front>
struct deque_by_stack {
static_assert(std::same_as<typename Front::value_type, typename Back::value_type>);
static_assert(std::common_reference_with<typename Front::size_type, typename Back::size_type>);
using value_type = Front::value_type;
using size_type = std::common_type_t<typename Front::size_type, typename Back::size_type>;
protected:
Front _front;
Back _back;
private:
template<std::ptrdiff_t OFFSET>
inline void _distribute() noexcept(NO_EXCEPT) {
if(this->empty()) return;
std::vector<value_type> temp;
temp.reserve(this->size());
if(this->_front.empty()) {
while(!this->_back.empty()) {
temp.push_back(this->_back.top());
this->_back.pop();
}
std::ranges::reverse(temp);
}
else if(this->_back.empty()) {
while(!this->_front.empty()) {
temp.push_back(this->_front.top());
this->_front.pop();
}
}
else {
return;
}
assert(this->empty());
const auto size = std::ranges::ssize(temp);
const auto mid = (size + OFFSET) / 2;
REPD(i, mid) this->_front.push(temp[i]);
REP(i, mid, size) this->_back.push(temp[i]);
}
public:
deque_by_stack() noexcept = default;
inline bool empty() const noexcept(NO_EXCEPT) {
return this->_front.empty() && this->_back.empty();
}
inline auto size() const noexcept(NO_EXCEPT) {
return this->_front.size() + this->_back.size();
}
inline decltype(auto) front() const noexcept(NO_EXCEPT) {
this->_distribute<1>();
assert(!this->_front.empty());
return this->_front.top();
}
inline decltype(auto) back() const noexcept(NO_EXCEPT) {
this->_distribute<0>();
assert(!this->_back.empty());
return this->_back.top();
}
template<std::convertible_to<value_type> T = value_type>
requires std::is_move_constructible_v<T>
inline decltype(auto) front_or(T&& val) const noexcept(NO_EXCEPT) {
if(this->empty()) return static_cast<value_type>(std::forward<T>(val));
else return this->front();
}
template<std::convertible_to<value_type> T = value_type>
requires std::is_move_constructible_v<T>
inline decltype(auto) back_or(T&& val) const noexcept(NO_EXCEPT) {
if(this->empty()) return static_cast<value_type>(std::forward<T>(val));
else return this->back();
}
inline auto& clear() noexcept(NO_EXCEPT) {
this->_front.clear(), this->_back.clear();
return *this;
}
template<std::convertible_to<value_type> T = value_type>
inline auto& push_front(T&& val) noexcept(NO_EXCEPT) {
this->_front.push(std::forward<T>(val));
return *this;
}
template<std::convertible_to<value_type> T = value_type>
inline auto& push_back(T&& val) noexcept(NO_EXCEPT) {
this->_back.push(std::forward<T>(val));
return *this;
}
template<class... Args>
inline decltype(auto) emplace_front(Args&&... args) noexcept(NO_EXCEPT) {
return this->_front.emplace(std::forward<Args>(args)...);
}
template<class... Args>
inline decltype(auto) emplace_back(Args&&... args) noexcept(NO_EXCEPT) {
return this->_back.emplace(std::forward<Args>(args)...);
}
auto& pop_front() noexcept(NO_EXCEPT) {
this->_distribute<1>();
assert(!this->_front.empty());
this->_front.pop();
return *this;
}
auto& pop_back() noexcept(NO_EXCEPT) {
this->_distribute<0>();
assert(!this->_back.empty());
this->_back.pop();
return *this;
}
};
} // namespace uni
#line 9 "data_structure/foldable_deque.hpp"
#line 2 "algebraic/opposite.hpp"
#line 6 "algebraic/opposite.hpp"
#line 9 "algebraic/opposite.hpp"
#line 12 "algebraic/opposite.hpp"
namespace uni {
namespace algebraic {
template<internal::magma M>
struct opposite
:
std::conditional_t<internal::associative<M>, associative, uni::internal::dummy>,
std::conditional_t<internal::commutative<M>, commutative, uni::internal::dummy>
{
using value_type = M::value_type;
private:
M _value;
public:
template<std::convertible_to<M> T>
opposite(const T& v) : _value(v) {};
template<class... Args>
requires std::constructible_from<value_type, Args...>
opposite(Args&&... args) noexcept(NO_EXCEPT) : _value(std::forward<Args>(args)...) {}
inline explicit operator value_type() const noexcept(NO_EXCEPT) { return this->_value.val(); }
inline auto val() const noexcept(NO_EXCEPT) { return this->_value.val(); };
inline const value_type* operator->() const noexcept(NO_EXCEPT) { return this->_value.operator->(); };
inline value_type* operator->() noexcept(NO_EXCEPT) { return this->_value.operator->(); };
friend inline auto operator<=>(const opposite& lhs, const opposite& rhs) noexcept(NO_EXCEPT) {
return lhs._value <=> rhs._value;
};
friend inline bool operator==(const opposite& lhs, const opposite& rhs) noexcept(NO_EXCEPT) {
return lhs._value == rhs._value;
}
friend inline opposite operator+(const opposite& lhs, const opposite& rhs) noexcept(NO_EXCEPT) {
return rhs._value + lhs._value;
}
friend inline opposite operator-(const opposite& val) noexcept(NO_EXCEPT)
requires internal::invertible<M>
{
return -val._value;
}
};
template<internal::magma M>
struct make_opposite;
template<internal::magma M>
struct make_opposite<opposite<M>> {
using type = M;
};
template<internal::magma M>
requires internal::commutative<M>
struct make_opposite<M> {
using type = M;
};
template<internal::magma M>
requires (!internal::commutative<M>)
struct make_opposite<M> {
using type = opposite<M>;
};
template<internal::magma M>
using make_opposite_t = make_opposite<M>::type;
} // namespace algebraic
} // namespace uni
#line 12 "data_structure/foldable_deque.hpp"
#line 14 "data_structure/foldable_deque.hpp"
#line 2 "data_structure/foldable_stack.hpp"
#line 6 "data_structure/foldable_stack.hpp"
#line 10 "data_structure/foldable_stack.hpp"
#line 2 "adaptor/queue_by_stack.hpp"
#line 6 "adaptor/queue_by_stack.hpp"
#line 9 "adaptor/queue_by_stack.hpp"
namespace uni {
template<class In, class Out = In>
struct queue_by_stack {
static_assert(std::same_as<typename In::value_type, typename Out::value_type>);
static_assert(std::common_reference_with<typename In::size_type, typename Out::size_type>);
using value_type = In::value_type;
using size_type = std::common_type_t<typename In::size_type, typename Out::size_type>;
protected:
In _in;
Out _out;
private:
inline void _shift() noexcept(NO_EXCEPT) {
if(!this->_out.empty()) return;
while(!this->_in.empty()) {
this->_out.push(this->_in.top());
this->_in.pop();
}
}
public:
queue_by_stack() noexcept = default;
inline bool empty() const noexcept(NO_EXCEPT) {
return this->_in.empty() && this->_out.empty();
}
inline auto size() const noexcept(NO_EXCEPT) {
return this->_in.size() + this->_out.size();
}
inline decltype(auto) front() noexcept(NO_EXCEPT) {
this->_shift();
assert(!this->_out.empty());
return this->_out.top();
}
template<std::convertible_to<value_type> T = value_type>
requires std::is_move_constructible_v<T>
inline decltype(auto) front_or(T&& val) const noexcept(NO_EXCEPT) {
if(this->empty()) return static_cast<value_type>(std::forward<T>(val));
else return this->front();
}
inline auto& clear() noexcept(NO_EXCEPT) {
this->_in.clear(), this->_out.clear();
return *this;
}
template<std::convertible_to<value_type> T = value_type>
inline auto& push(T&& val) noexcept(NO_EXCEPT) {
this->_in.push(std::forward<T>(val));
return *this;
}
template<class... Args>
inline decltype(auto) emplace(Args&&... args) noexcept(NO_EXCEPT) {
return this->_in.emplace(std::forward<Args>(args)...);
}
auto& pop() noexcept(NO_EXCEPT) {
this->_shift();
assert(!this->_out.empty());
this->_out.pop();
return *this;
}
};
} // namespace uni
#line 14 "data_structure/foldable_stack.hpp"
#line 17 "data_structure/foldable_stack.hpp"
#line 19 "data_structure/foldable_stack.hpp"
namespace uni {
template<class, template<class...> class = stack>
struct foldable_stack : internal::unconstructible {};
template<algebraic::internal::monoid Monoid, template<class...> class Stack>
struct foldable_stack<Monoid, Stack> {
using fold_type = Monoid;
using value_type = Monoid::value_type;
using size_type = Stack<Monoid>::size_type;
Stack<value_type> _val;
Stack<fold_type> _acc;
inline bool empty() const noexcept(NO_EXCEPT) { return this->_val.empty(); }
inline auto size() const noexcept(NO_EXCEPT) { return this->_val.size(); }
inline decltype(auto) top() const noexcept(NO_EXCEPT) {
assert(!this->empty());
return this->_val.top();
}
template<std::convertible_to<value_type> T = value_type>
requires std::is_move_constructible_v<T>
inline decltype(auto) top_or(T&& val) const noexcept(NO_EXCEPT) {
if(this->empty()) return static_cast<value_type>(std::forward<T>(val));
else return this->top();
}
inline auto fold() const noexcept(NO_EXCEPT) {
if(this->empty()) return fold_type();
return this->_acc.top();
}
template<std::convertible_to<fold_type> T = value_type>
auto& push(T&& x) noexcept(NO_EXCEPT) {
const auto acc = this->fold();
this->_val.push(x);
this->_acc.push(acc + std::forward<T>(x));
return *this;
}
template<class... Args>
decltype(auto) emplace(Args&&... args) noexcept(NO_EXCEPT) {
const auto acc = this->fold();
decltype(auto) res = this->_val.emplace(std::forward<Args>(args)...);
this->_acc.push(acc + res);
return res;
}
inline auto& pop() noexcept(NO_EXCEPT) {
this->_val.pop(), this->_acc.pop();
return *this;
}
};
template<actions::internal::operatable_action Action, template<class...> class Stack>
struct foldable_stack<Action, Stack> : foldable_stack<typename Action::operand> {
using foldable_stack<typename Action::operand>::foldable_stack;
};
} // namespace uni
#line 16 "data_structure/foldable_deque.hpp"
namespace uni {
namespace internal {
template<algebraic::internal::monoid Monoid, template<class...> class Stack>
using foldable_deque_base = deque_by_stack<foldable_stack<algebraic::make_opposite_t<Monoid>, Stack>, foldable_stack<Monoid, Stack>>;
} // namespace internal
template<class, template<class...> class = stack>
struct foldable_deque : internal::unconstructible {};
template<algebraic::internal::monoid Monoid, template<class...> class Stack>
struct foldable_deque<Monoid, Stack> : internal::foldable_deque_base<Monoid, Stack> {
using internal::foldable_deque_base<Monoid, Stack>::foldable_deque_base;
inline auto fold() const noexcept(NO_EXCEPT) {
return Monoid(this->_front.fold()) + this->_back.fold();
}
};
template<actions::internal::operatable_action Action, template<class...> class Stack>
struct foldable_deque<Action, Stack> : foldable_deque<typename Action::operand> {
using foldable_deque<typename Action::operand>::foldable_deque;
};
} // namespace uni
#line 2 "data_structure/foldable_queue.hpp"
#line 6 "data_structure/foldable_queue.hpp"
#line 9 "data_structure/foldable_queue.hpp"
#line 12 "data_structure/foldable_queue.hpp"
#line 14 "data_structure/foldable_queue.hpp"
#line 16 "data_structure/foldable_queue.hpp"
namespace uni {
namespace internal {
template<algebraic::internal::monoid Monoid, template<class...> class Stack>
using foldable_queue_base = queue_by_stack<foldable_stack<Monoid, Stack>, foldable_stack<algebraic::make_opposite_t<Monoid>, Stack>>;
} // namespace internal
template<class, template<class...> class = stack>
struct foldable_queue : internal::unconstructible {};
template<algebraic::internal::monoid Monoid, template<class...> class Stack>
struct foldable_queue<Monoid, Stack> : internal::foldable_queue_base<Monoid, Stack> {
using internal::foldable_queue_base<Monoid, Stack>::foldable_queue_base;
inline auto fold() const noexcept(NO_EXCEPT) {
return Monoid(this->_out.fold()) + this->_in.fold();
}
};
template<actions::internal::operatable_action Action, template<class...> class Stack>
struct foldable_queue<Action, Stack> : foldable_queue<typename Action::operand> {
using foldable_queue<typename Action::operand>::foldable_queue;
};
} // namespace uni
#line 2 "data_structure/kth_element.hpp"
#line 11 "data_structure/kth_element.hpp"
#line 15 "data_structure/kth_element.hpp"
namespace uni {
// Thanks to: https://qiita.com/drken/items/1b7e6e459c24a83bb7fd
template<
class T,
std::ranges::output_range<T> Container = std::vector<T>,
std::strict_weak_order<T, T> Comparer = std::less<T>,
std::strict_weak_order<T, T> RevComparer = std::greater<T>,
std::integral Size = internal::size_t
>
struct kth_element {
using value_type = T;
using size_type = Size;
protected:
size_type _k;
std::priority_queue<T, Container, Comparer> _small;
std::priority_queue<T, Container, RevComparer> _large;
public:
kth_element(const size_type k = 0) noexcept(NO_EXCEPT) : _k(k + 1) { assert(k >= 0); }
inline bool has() const noexcept(NO_EXCEPT) { return std::ssize(this->_small) == this->_k; }
inline value_type value() const noexcept(NO_EXCEPT) { return this->_small.top(); }
inline std::optional<value_type> get() const noexcept(NO_EXCEPT) {
if(this->has()) return this->value();
return {};
}
template<std::convertible_to<T> U = T>
inline auto value_or(U&& v) const noexcept(NO_EXCEPT) {
return this->get().value_or(std::forward<U>(v));
}
inline void push(const value_type& v) noexcept(NO_EXCEPT) {
if(std::ssize(this->_small) < this->_k) {
this->_small.push(v);
return;
}
const auto kth = this->_small.top();
if(Comparer{}(v, kth)) {
this->_small.pop();
this->_small.push(v);
this->_large.push(kth);
}
else {
this->_large.push(v);
}
}
inline void pop() noexcept(NO_EXCEPT) {
assert(this->has());
this->_small.pop();
if(this->_large.empty()) return;
const auto v = this->_large.top();
this->_large.pop();
this->_small.push(v);
}
};
} // namespace uni
#line 2 "data_structure/lazy_segment_tree.hpp"
#line 12 "data_structure/lazy_segment_tree.hpp"
#line 15 "data_structure/lazy_segment_tree.hpp"
#line 21 "data_structure/lazy_segment_tree.hpp"
#line 24 "data_structure/lazy_segment_tree.hpp"
#line 26 "data_structure/lazy_segment_tree.hpp"
#line 29 "data_structure/lazy_segment_tree.hpp"
namespace uni {
namespace internal {
namespace lazy_segment_tree_impl {
// Thanks to: atcoder::lazy_segtree
template<actions::internal::full_action Action>
requires
algebraic::internal::monoid<typename Action::operand> &&
algebraic::internal::monoid<typename Action::operation>
struct core {
using size_type = internal::size_t;
using action = Action;
using operand = typename Action::operand;
using operation = typename Action::operation;
private:
size_type _n = 0, _size = 0, _depth = 0;
std::valarray<size_type> _lengths;
std::valarray<operand> _values;
std::valarray<operation> _lazy;
inline void _pull(const size_type p) noexcept(NO_EXCEPT) {
this->_values[p] = this->_values[p << 1] + this->_values[p << 1 | 1];
}
inline void _all_apply(const size_type p, const operation& f) noexcept(NO_EXCEPT) {
this->_values[p] = action::mapping(action::power(f, this->_lengths[p]), this->_values[p]);
if(p < this->_size) this->_lazy[p] = f + this->_lazy[p];
}
inline void _push(const size_type p) noexcept(NO_EXCEPT) {
this->_all_apply(p << 1, this->_lazy[p]);
this->_all_apply(p << 1 | 1, this->_lazy[p]);
this->_lazy[p] = operation{};
}
inline void _init() noexcept(NO_EXCEPT) {
REPD(p, 1, this->_size) {
this->_lengths[p] = this->_lengths[p << 1] + this->_lengths[p << 1 | 1];
this->_pull(p);
}
}
public:
core() noexcept = default;
explicit core(const size_type n) noexcept(NO_EXCEPT)
: _n(n), _size(std::bit_ceil(uni::to_unsigned(n))), _depth(std::countr_zero(uni::to_unsigned(this->_size))),
_lengths(this->_size << 1), _values(this->_size << 1), _lazy(this->_size)
{}
inline size_type size() const noexcept(NO_EXCEPT) { return this->_n; }
inline size_type allocated() const noexcept(NO_EXCEPT) { return this->_values.size(); }
inline size_type depth() const noexcept(NO_EXCEPT) { return this->_depth; }
inline operand fold_all() const noexcept(NO_EXCEPT) { return this->_values[1]; }
inline void fill( const operand& v = operand()) noexcept(NO_EXCEPT) {
REP(p, 0, this->_n) {
this->_lengths[this->_size + p] = 1, this->_values[this->_size + p] = v;
}
this->_init();
}
template<std::input_iterator I, std::sentinel_for<I> S>
inline void assign(I first, S last) noexcept(NO_EXCEPT) {
if constexpr(std::sized_sentinel_for<operand, I>) {
assert(std::ranges::distance(first, last) == this->_n);
}
size_type p = 0;
for(auto itr=first; itr!=last; ++itr, ++p) {
this->_lengths[this->_size + p] = 1, this->_values[this->_size + p] = static_cast<operand>(*itr);
}
this->_init();
}
inline void set(size_type p, const operand& x) noexcept(NO_EXCEPT) {
p += this->_size;
FORD(i, 1, this->_depth) this->_push(p >> i);
this->_values[p] = x;
FOR(i, 1, this->_depth) this->_pull(p >> i);
}
inline void add(size_type p, const operand& x) noexcept(NO_EXCEPT) {
p += this->_size;
FORD(i, 1, this->_depth) this->_push(p >> i);
this->_values[p] = this->_values[p] + x;
FOR(i, 1, this->_depth) this->_pull(p >> i);
}
inline operand get(size_type p) noexcept(NO_EXCEPT) {
p += this->_size;
FORD(i, 1, this->_depth) this->_push(p >> i);
return this->_values[p];
}
inline operand fold(size_type l, size_type r) noexcept(NO_EXCEPT) {
if(l == r) return {};
l += this->_size;
r += this->_size;
FORD(i, 1, this->_depth) {
if(((l >> i) << i) != l) this->_push(l >> i);
if(((r >> i) << i) != r) this->_push((r - 1) >> i);
}
operand sml = operand{}, smr = operand{};
while(l < r) {
if(l & 1) sml = sml + this->_values[l++];
if(r & 1) smr = this->_values[--r] + smr;
l >>= 1;
r >>= 1;
}
return sml + smr;
}
inline void apply(size_type p, const operation& f) noexcept(NO_EXCEPT) {
p += this->_size;
FORD(i, 1, this->_depth) this->_push(p >> i);
this->_values[p] = action::mapping(action::power(f, this->_lengths[p]), this->_values[p]);
FOR(i, 1, this->_depth) this->_pull(p >> i);
}
inline void apply(size_type l, size_type r, const operation& f) noexcept(NO_EXCEPT) {
if(l == r) return;
l += this->_size;
r += this->_size;
FORD(i, 1, this->_depth) {
if(((l >> i) << i) != l) this->_push(l >> i);
if(((r >> i) << i) != r) this->_push((r - 1) >> i);
}
{
size_type l2 = l, r2 = r;
while(l < r) {
if(l & 1) this->_all_apply(l++, f);
if(r & 1) this->_all_apply(--r, f);
l >>= 1;
r >>= 1;
}
l = l2;
r = r2;
}
FOR(i, 1, this->_depth) {
if(((l >> i) << i) != l) this->_pull(l >> i);
if(((r >> i) << i) != r) this->_pull((r - 1) >> i);
}
}
template<class F>
inline size_type max_right(size_type l, F&& f) noexcept(NO_EXCEPT) {
assert(0 <= l && l <= _n);
assert(f(operand{}));
if(l == _n) return _n;
l += this->_size;
FORD(i, 1, this->_depth) this->_push(l >> i);
operand sm;
do {
while(l % 2 == 0) l >>= 1;
if(!f(sm + this->_values[l])) {
while(l < this->_size) {
this->_push(l);
l = (2 * l);
if(f(sm + this->_values[l])) {
sm = sm + this->_values[l];
l++;
}
}
return l - this->_size;
}
sm = sm + this->_values[l];
l++;
} while((l & -l) != l);
return _n;
}
template<class F>
inline size_type min_left(size_type r, F&& f) noexcept(NO_EXCEPT) {
assert(0 <= r && r <= _n);
assert(f(operand{}));
if(r == 0) return 0;
r += this->_size;
FORD(i, 1, this->_depth) this->_push((r - 1) >> i);
operand sm;
do {
r--;
while(r > 1 && (r % 2)) r >>= 1;
if(!f(this->_values[r] + sm)) {
while(r < this->_size) {
this->_push(r);
r = (2 * r + 1);
if(f(this->_values[r] + sm)) {
sm = this->_values[r] + sm;
r--;
}
}
return r + 1 - this->_size;
}
sm = this->_values[r] + sm;
} while((r & -r) != r);
return 0;
}
};
} // namespace lazy_segment_tree_impl
} // namespace internal
template<class T>
struct lazy_segment_tree : lazy_segment_tree<actions::make_full_t<T>> {
using lazy_segment_tree<actions::make_full_t<T>>::lazy_segment_tree;
};
template<actions::internal::full_action Action>
requires internal::available<internal::lazy_segment_tree_impl::core<Action>>
struct lazy_segment_tree<Action> {
using action = Action;
using operand = Action::operand;
using operation = Action::operation;
private:
using core = internal::lazy_segment_tree_impl::core<action>;
core _impl;
public:
using value_type = operand;
using action_type = operation::value_type;
using size_type = core::size_type;
inline auto size() const noexcept(NO_EXCEPT) { return this->_impl.size(); }
inline auto allocated() const noexcept(NO_EXCEPT) { return this->_impl.allocated(); }
inline auto depth() const noexcept(NO_EXCEPT) { return this->_impl.depth(); }
protected:
inline size_type _positivize_index(const size_type p) const noexcept(NO_EXCEPT) {
return p < 0 ? this->_impl.size() + p : p;
}
public:
lazy_segment_tree() noexcept(NO_EXCEPT) : _impl() {}
explicit lazy_segment_tree(const size_type n, const value_type& v = value_type()) noexcept(NO_EXCEPT) : _impl(n) { this->_impl.fill(v); }
template<std::convertible_to<value_type> T>
lazy_segment_tree(const std::initializer_list<T>& init_list) noexcept(NO_EXCEPT) : lazy_segment_tree(ALL(init_list)) {}
template<std::input_iterator I, std::sized_sentinel_for<I> S>
lazy_segment_tree(I first, S last) noexcept(NO_EXCEPT)
: _impl(static_cast<size_type>(std::ranges::distance(first, last)))
{ this->assign(first, last); }
template<std::ranges::input_range R>
explicit lazy_segment_tree(R&& range) noexcept(NO_EXCEPT) : lazy_segment_tree(ALL(range)) {}
template<std::convertible_to<value_type> T>
inline auto& assign(const std::initializer_list<T>& init_list) noexcept(NO_EXCEPT)
{
return this->assign(ALL(init_list));
}
template<std::input_iterator I, std::sentinel_for<I> S>
inline auto& assign(I first, S last) noexcept(NO_EXCEPT) {
this->_impl.assign(first, last);
return *this;
}
template<std::ranges::input_range R>
inline auto& assign(R&& range) noexcept(NO_EXCEPT) { return this->assign(ALL(range)); }
inline auto& fill( const value_type& v = value_type()) noexcept(NO_EXCEPT) {
this->impl.fill(v);
return *this;
}
bool empty() const noexcept(NO_EXCEPT) { return this->_impl.size() == 0; }
struct point_reference : internal::point_reference<lazy_segment_tree> {
point_reference(lazy_segment_tree *const super, const size_type p) noexcept(NO_EXCEPT)
: internal::point_reference<lazy_segment_tree>(super, super->_positivize_index(p))
{
assert(0 <= this->_pos && this->_pos < this->_super->size());
}
operator value_type() noexcept(NO_EXCEPT) { return this->_super->get(this->_pos); }
auto val() noexcept(NO_EXCEPT) { return this->_super->get(this->_pos); }
inline auto& operator=(const value_type& v) noexcept(NO_EXCEPT) {
this->_super->set(this->_pos, v);
return *this;
}
inline auto& operator+=(const value_type& v) noexcept(NO_EXCEPT) {
this->_super->add(this->_pos, v);
return *this;
}
inline auto& operator*=(const action_type& v) noexcept(NO_EXCEPT) {
this->_super->apply(this->_pos, v);
return *this;
}
};
struct range_reference : internal::range_reference<lazy_segment_tree> {
range_reference(lazy_segment_tree *const super, const size_type l, const size_type r) noexcept(NO_EXCEPT)
: internal::range_reference<lazy_segment_tree>(super, super->_positivize_index(l), super->_positivize_index(r))
{
assert(0 <= this->_begin && this->_begin <= this->_end && this->_end <= this->_super->size());
}
inline auto& operator*=(const action_type& v) noexcept(NO_EXCEPT) {
this->_super->apply(this->_begin, this->_end, v);
return *this;
}
inline auto fold() noexcept(NO_EXCEPT) {
if(this->_begin == 0 && this->_end == this->_super->size()) return this->_super->fold();
return this->_super->fold(this->_begin, this->_end);
}
};
inline auto& set(size_type p, const value_type& v) noexcept(NO_EXCEPT) {
p = this->_positivize_index(p), assert(0 <= p && p < this->_impl.size());
this->_impl.set(p, v);
return *this;
}
inline auto& add(size_type p, const value_type& v) noexcept(NO_EXCEPT) {
p = this->_positivize_index(p), assert(0 <= p && p < this->_impl.size());
this->_impl.add(p, v);
return *this;
}
inline auto& apply(size_type l, size_type r, const action_type& v) noexcept(NO_EXCEPT) {
l = this->_positivize_index(l), r = this->_positivize_index(r);
assert(0 <= l && l <= r && r <= this->_impl.size());
this->_impl.apply(l, r, v);
return *this;
}
inline auto& apply(const size_type p, const action_type& v) noexcept(NO_EXCEPT) {
this->apply(p, p + 1, v);
return *this;
}
inline auto& apply(const action_type& v) noexcept(NO_EXCEPT) { this->apply(0, this->_impl.size(), v); return *this; }
inline auto get(size_type p) noexcept(NO_EXCEPT) {
p = this->_positivize_index(p), assert(0 <= p && p < this->_impl.size());
return this->_impl.get(p);
}
inline auto operator[](const size_type p) noexcept(NO_EXCEPT) { return point_reference(this, p); }
inline auto operator()(const size_type l, const size_type r) noexcept(NO_EXCEPT) { return range_reference(this, l, r); }
inline auto fold(size_type l, size_type r) noexcept(NO_EXCEPT) {
l = this->_positivize_index(l), r = this->_positivize_index(r);
assert(0 <= l && l <= r && r <= this->_impl.size());
return this->_impl.fold(l, r);
}
inline auto fold() noexcept(NO_EXCEPT) { return this->_impl.fold_all(); }
template<bool (*f)(value_type)>
inline auto max_right(const size_type l) noexcept(NO_EXCEPT) {
return this->max_right(l, [](operand x) { return f(x); });
}
template<class F>
inline auto max_right(const size_type l, F&& f) noexcept(NO_EXCEPT) {
return this->_impl.max_right(l, std::forward<F>(f));
}
template<bool (*f)(value_type)>
inline auto min_left(const size_type r) noexcept(NO_EXCEPT) {
return min_left(r, [](operand x) { return f(x); });
}
template<class F>
inline auto min_left(const size_type r, F&& f) noexcept(NO_EXCEPT) {
return this->_impl.min_left(r, std::forward<F>(f));
}
struct iterator;
protected:
using iterator_interface = internal::container_iterator_interface<value_type, lazy_segment_tree, iterator>;
public:
struct iterator : iterator_interface {
using iterator_interface::iterator_interface;
};
inline auto begin() noexcept(NO_EXCEPT) { return iterator(this, 0); }
inline auto end() noexcept(NO_EXCEPT) { return iterator(this, this->_impl.size()); }
inline auto rbegin() noexcept(NO_EXCEPT) { return std::make_reverse_iterator(this->end()); }
inline auto rend() noexcept(NO_EXCEPT) { return std::make_reverse_iterator(this->begin()); }
};
} // namespace uni
#line 2 "data_structure/persistent_queue.hpp"
#line 9 "data_structure/persistent_queue.hpp"
#line 12 "data_structure/persistent_queue.hpp"
#line 16 "data_structure/persistent_queue.hpp"
namespace uni {
// Thanks to: https://tk0-math.hatenablog.com/entry/2020/03/27/194150
template<class ValueType, u32 BUFFER_DEPTH = 20, class Allocator = std::allocator<ValueType>>
struct persistent_queue {
using value_type = ValueType;
using size_type = internal::size_t;
struct node_type;
using node_handler = node_handlers::cloneable<Allocator>::template handler<node_type>;
using node_pointer = typename node_handler::node_pointer;
using allocator_type = typename node_handler::allocator_type;
struct node_type {
value_type value;
node_pointer prev[BUFFER_DEPTH];
};
private:
size_type _size = 0;
node_pointer _head, _tail;
[[no_unique_address]] node_handler _node_handler;
public:
explicit persistent_queue(const allocator_type& allocator = allocator_type()) noexcept(NO_EXCEPT) : _node_handler(allocator) {}
persistent_queue(const persistent_queue& source, const allocator_type& allocator) noexcept(NO_EXCEPT)
: _size(source._size), _head(source._head), _tail(source._tail), _node_handler(allocator)
{}
persistent_queue(persistent_queue&& source, const allocator_type& allocator) noexcept(NO_EXCEPT)
: _size(source._size), _head(source._head), _tail(source._tail), _node_handler(allocator)
{}
inline auto clone() const noexcept(NO_EXCEPT) { return *this; }
inline bool empty() const noexcept(NO_EXCEPT) { return this->_size == 0; }
inline size_type size() const noexcept(NO_EXCEPT) { return this->_size; }
inline value_type front() const noexcept(NO_EXCEPT) {
assert(!this->empty());
return this->_head->value;
}
template<std::convertible_to<value_type> T = value_type>
requires std::is_move_constructible_v<T>
inline value_type front_or(T&& v) const noexcept(NO_EXCEPT) {
if(this->empty()) return static_cast<value_type>(std::forward<T>(v));
else return this->front();
}
inline value_type back() const noexcept(NO_EXCEPT) {
assert(!this->empty());
return this->_tail->value;
}
template<std::convertible_to<value_type> T = value_type>
requires std::is_move_constructible_v<T>
inline value_type back_or(T&& v) const noexcept(NO_EXCEPT) {
if(this->empty()) return static_cast<value_type>(std::forward<T>(v));
else return this->back();
}
inline auto& clear() noexcept(NO_EXCEPT) {
this->_head.reset(), this->_tail.reset();
this->_size = 0;
return *this;
}
template<std::convertible_to<value_type> T = value_type>
auto& push(T&& x) noexcept(NO_EXCEPT) {
node_pointer node = this->_node_handler.create(x);
node->prev[0] = this->_tail;
REP(i, 1, BUFFER_DEPTH) {
node_pointer prev = node->prev[i - 1];
if(prev) node->prev[i] = prev->prev[i - 1];
else break;
}
if(!this->_head) this->_head = node;
this->_tail = node;
++this->_size;
return *this;
}
auto& pop() noexcept(NO_EXCEPT) {
assert(!this->empty());
if(!this->_head || !this->_tail || this->_size == 1) {
this->clear();
return *this;
}
auto index = to_unsigned(this->_size - 2);
node_pointer node = this->_tail;
while(index != 0) {
const size_type msb = uni::highest_bit_pos(index);
index -= 1 << msb;
node = node->prev[msb];
}
this->_head = node;
--this->_size;
return *this;
}
};
namespace pmr {
template<class T, u32 BUFFER_DEPTH = 20>
using persistent_queue = uni::persistent_queue<T, BUFFER_DEPTH, std::pmr::polymorphic_allocator<T>>;
} // namesapce pmr
} // namespace uni
#line 2 "data_structure/persistent_stack.hpp"
#line 7 "data_structure/persistent_stack.hpp"
#line 10 "data_structure/persistent_stack.hpp"
#line 13 "data_structure/persistent_stack.hpp"
namespace uni {
template<class ValueType, class Allocator = std::allocator<ValueType>>
struct persistent_stack {
using value_type = ValueType;
using size_type = internal::size_t;
struct node_type;
using node_handler = node_handlers::cloneable<Allocator>::template handler<node_type>;
using allocator_type = typename node_handler::allocator_type;
using node_pointer = typename node_handler::node_pointer;
struct node_type {
value_type value;
node_pointer next;
node_type(node_pointer _next, value_type _value) noexcept(NO_EXCEPT)
: value(_value), next(_next)
{}
template<class... Args>
node_type(node_pointer _next, Args&&... args) noexcept(NO_EXCEPT)
: value(std::forward<Args>(args)...), next(_next)
{}
};
private:
size_type _size = 0;
node_pointer _head;
[[no_unique_address]] node_handler _node_handler;
public:
explicit persistent_stack(const allocator_type& allocator = allocator_type()) noexcept(NO_EXCEPT) : _node_handler(allocator) {};
persistent_stack(const persistent_stack& source, const allocator_type& allocator) noexcept(NO_EXCEPT)
: _size(source._size), _head(source._head), _node_handler(allocator)
{};
persistent_stack(persistent_stack&& source, const allocator_type& allocator) noexcept(NO_EXCEPT)
: _size(source._size), _head(source._head), _node_handler(allocator)
{};
inline auto clone() const noexcept(NO_EXCEPT) { return *this; }
inline bool empty() const noexcept(NO_EXCEPT) { return !this->_head; }
inline size_type size() const noexcept(NO_EXCEPT) { return this->_size; }
inline value_type top() const noexcept(NO_EXCEPT) {
assert(!this->empty());
return this->_head->value;
}
template<std::convertible_to<value_type> T = value_type>
requires std::is_move_constructible_v<T>
inline value_type top_or(T&& v) const noexcept(NO_EXCEPT) {
if(this->empty()) return static_cast<value_type>(std::forward<T>(v));
else return this->top();
}
inline auto& clear() noexcept(NO_EXCEPT) {
this->_head.reset();
this->_size = 0;
return *this;
}
template<std::convertible_to<value_type> T = value_type>
inline auto& push(T&& x) noexcept(NO_EXCEPT) {
this->_head = this->_node_handler.create(this->_head, std::forward<T>(x));
++this->_size;
return *this;
}
template<class... Args>
inline auto& emplace(Args&&... args) noexcept(NO_EXCEPT) {
this->_head = this->_node_handler.create(this->_head, std::forward<Args>(args)...);
++this->_size;
return this->_head->value;
}
inline auto& pop() noexcept(NO_EXCEPT) {
assert(!this->empty());
this->_head = this->_head->next;
--this->_size;
return *this;
}
};
namespace pmr {
template<class T>
using persistent_stack = uni::persistent_stack<T, std::pmr::polymorphic_allocator<T>>;
} // namesapce pmr
} // namespace uni
#line 2 "data_structure/red_black_tree.hpp"
#line 13 "data_structure/red_black_tree.hpp"
#line 17 "data_structure/red_black_tree.hpp"
#line 23 "data_structure/red_black_tree.hpp"
#line 25 "data_structure/red_black_tree.hpp"
#line 27 "data_structure/red_black_tree.hpp"
#line 29 "data_structure/red_black_tree.hpp"
#line 32 "data_structure/red_black_tree.hpp"
namespace uni {
namespace internal {
// Thanks to: http://blog.mitaki28.info/1447078746296/
template<class NodeHandler, class Derived, std::integral SizeType, class ValueType>
struct red_black_tree_impl {
using size_type = SizeType;
using rank_type = int;
using value_type = ValueType;
enum class node_colors : std::int8_t { RED, BLACK };
struct node_type;
using node_handler = typename NodeHandler::handler<node_type>;
using allocator_type = typename node_handler::allocator_type;
using node_pointer = typename node_handler::node_pointer;
struct node_type {
node_pointer left = node_handler::nil, right = node_handler::nil;
node_colors color = node_colors::BLACK;
size_type size = 0;
rank_type rank = 0;
inline constexpr bool is_leaf() const noexcept(NO_EXCEPT) {
return this->left == node_handler::nil && this->right == node_handler::nil;
}
[[no_unique_address]] value_type data;
node_type() noexcept = default;
node_type(const value_type& _data, const size_type _size) noexcept(NO_EXCEPT)
: size(_size), data(_data)
{}
node_type(const node_colors _color, const node_pointer& _left, const node_pointer& _right) noexcept(NO_EXCEPT)
: left(_left), right(_right), color(_color)
{}
};
private:
using derived = Derived;
inline auto* _derived() noexcept(NO_EXCEPT) {
return static_cast<derived*>(this);
}
inline const auto* _derived() const noexcept(NO_EXCEPT) {
return static_cast<const derived*>(this);
}
[[no_unique_address]] node_handler _node_handler;
public:
void pull(const node_pointer& tree) const noexcept(NO_EXCEPT) {
if(tree == node_handler::nil) return;
if(tree->is_leaf()) return;
tree->size = tree->left->size + tree->right->size;
tree->rank = tree->left->rank + (tree->left->color == node_colors::BLACK);
this->_derived()->pull(tree);
}
void push(node_pointer& tree) noexcept(NO_EXCEPT) {
if(tree == node_handler::nil) return;
this->clone(tree);
this->_derived()->push(tree);
this->pull(tree);
}
inline void clone(node_pointer& tree) noexcept(NO_EXCEPT) {
tree = this->_node_handler.clone(tree);
}
node_pointer create(const value_type& val, const size_type size) noexcept(NO_EXCEPT) {
if(size == 0) return node_handler::nil;
return this->_node_handler.create(val, size);
}
node_pointer create(const node_colors color, node_pointer left, node_pointer right) noexcept(NO_EXCEPT) {
this->push(left);
this->push(right);
return this->_node_handler.create(color, std::move(left), std::move(right));
}
void dispose(const node_pointer& tree) noexcept(NO_EXCEPT) {
if(this->_node_handler.disposable(tree)) {
this->dispose(tree->left);
this->dispose(tree->right);
this->_node_handler.dispose(tree);
}
}
private:
void _as_root(node_pointer& node) {
this->clone(node);
if(node->color == node_colors::RED) node->color = node_colors::BLACK;
this->push(node);
}
void _merge(node_pointer& tree, node_pointer left, node_pointer right) noexcept(NO_EXCEPT) {
if(left->rank < right->rank) {
this->push(right);
this->_merge(tree, left, right->left);
if(right->color == node_colors::BLACK && tree->color == node_colors::RED && tree->left->color == node_colors::RED) {
tree->color = node_colors::BLACK;
if(right->right->color == node_colors::BLACK) {
this->clone(right);
right->color = node_colors::RED;
right->left = tree->right;
this->pull(right);
this->clone(tree);
tree->right = std::move(right);
}
else {
this->clone(right->right);
right->right->color = node_colors::BLACK;
this->clone(right);
right->left = tree;
right->color = node_colors::RED;
tree = std::move(right);
}
}
else {
this->clone(right);
right->left = tree;
tree = std::move(right);
}
}
else if(left->rank > right->rank) {
this->push(left);
this->_merge(tree, left->right, right);
if(left->color == node_colors::BLACK && tree->color == node_colors::RED && tree->right->color == node_colors::RED) {
tree->color = node_colors::BLACK;
if(left->left->color == node_colors::BLACK) {
this->clone(left);
left->color = node_colors::RED;
left->right = tree->left;
this->pull(left);
this->clone(tree);
tree->left = std::move(left);
}
else {
this->clone(left->left);
left->left->color = node_colors::BLACK;
this->clone(left);
left->right = tree;
left->color = node_colors::RED;
tree = std::move(left);
}
}
else {
this->clone(left);
left->right = tree;
tree = std::move(left);
}
}
else {
tree = this->create(node_colors::RED, left, right);
}
this->pull(tree);
}
void _split(node_pointer tree, const size_type pos, node_pointer& left, node_pointer& right) {
if(tree == node_handler::nil) {
left = right = node_handler::nil;
return;
}
this->push(tree);
if(tree->is_leaf()) {
left = this->create(tree->data, pos);
right = this->create(tree->data, tree->size - pos);
return;
}
auto l = std::move(tree->left), r = std::move(tree->right);
this->_node_handler.dispose(tree);
if(pos < l->size) {
this->_split(std::move(l), pos, left, right);
this->_as_root(r);
this->merge(right, right, std::move(r));
this->_as_root(left);
return;
}
if(pos > l->size) {
this->_split(std::move(r), pos - l->size, left, right);
this->_as_root(l);
this->merge(left, std::move(l), left);
this->_as_root(right);
return;
}
left = std::move(l), right = std::move(r);
this->_as_root(left), this->_as_root(right);
}
public:
explicit red_black_tree_impl(const allocator_type& allocator = allocator_type()) noexcept(NO_EXCEPT) : _node_handler(allocator) {}
template<std::random_access_iterator I, std::sized_sentinel_for<I> S>
requires std::constructible_from<value_type, std::iter_value_t<I>>
node_pointer build(I first, S last) noexcept(NO_EXCEPT) {
if(first == last) return node_handler::nil;
if(std::ranges::next(first) == last) return this->create(value_type{ *first }, 1);
const auto length = std::ranges::distance(first, last);
const auto middle = std::ranges::next(first, std::bit_floor(to_unsigned(length - 1)));
node_pointer tree;
this->merge(tree, this->build(std::move(first), middle), this->build(middle, std::move(last)));
return tree;
}
template<std::random_access_iterator I, std::sized_sentinel_for<I> S>
requires
std::constructible_from<value_type, typename std::iter_value_t<I>::first_type> &&
std::integral<typename std::iter_value_t<I>::second_type>
node_pointer build(I first, S last) noexcept(NO_EXCEPT) {
if(first == last) return node_handler::nil;
if(std::ranges::next(first) == last) return this->create(value_type{ first->first }, first->second);
const auto length = std::ranges::distance(first, last);
const auto middle = std::ranges::next(first, std::bit_floor(to_unsigned(length - 1)));
node_pointer tree;
this->merge(tree, this->build(std::move(first), middle), this->build(middle, std::move(last)));
return tree;
}
void split(const node_pointer& tree, const size_type pos, node_pointer& left, node_pointer& right) noexcept(NO_EXCEPT) {
if(pos <= 0) {
left = node_handler::nil;
this->merge(right, this->create(value_type{}, -pos), tree);
}
else if(tree->size <= pos) {
right = node_handler::nil;
this->merge(left, tree, this->create(value_type{}, pos - tree->size));
}
else {
this->_split(tree, pos, left, right);
}
}
void merge(node_pointer& tree, const node_pointer& left, const node_pointer& right) noexcept(NO_EXCEPT) {
if(left == node_handler::nil) {
tree = right;
this->push(tree);
}
else if(right == node_handler::nil) {
tree = left;
this->push(tree);
}
else {
this->_merge(tree, left, right);
tree->color = node_colors::BLACK;
}
this->pull(tree);
}
};
} // namespace internal
template<std::integral SizeType = i64, class NodeHandler = uni::node_handlers::reusing<std::allocator<SizeType>>>
struct red_black_tree_context {
static constexpr bool LEAF_ONLY = true;
template<class Derived, class ValueType = internal::dummy>
using substance = internal::red_black_tree_impl<NodeHandler, Derived, SizeType, ValueType>;
};
template<std::integral SizeType = i64, class Allocator = std::allocator<SizeType>>
struct persistent_red_black_tree_context {
static constexpr bool LEAF_ONLY = true;
template<class Derived, class ValueType = internal::dummy>
using substance = internal::red_black_tree_impl<uni::node_handlers::cloneable<Allocator>, Derived, SizeType, ValueType>;
};
namespace pmr {
template<std::integral SizeType = i64>
using red_black_tree_context = uni::red_black_tree_context<SizeType, std::pmr::polymorphic_allocator<SizeType>>;
template<std::integral SizeType = i64>
using persistent_red_black_tree_context = uni::persistent_red_black_tree_context<SizeType, std::pmr::polymorphic_allocator<SizeType>>;
} // namespace pmr
} // namespace uni
#line 2 "data_structure/removable_priority_queue.hpp"
#line 8 "data_structure/removable_priority_queue.hpp"
#line 12 "data_structure/removable_priority_queue.hpp"
namespace uni {
namespace internal {
template<class T, class... Ts>
concept can_removable_priority_queue =
sizeof...(Ts) == 0 &&
requires (T pq, typename T::value_type v) {
{ pq.size() } -> std::same_as<typename T::size_type>;
{ pq.empty() } -> std::same_as<bool>;
pq.top();
pq.pop();
pq.push(v);
pq.emplace(v);
};
} // namespace internal
template<class... Ts>
struct removable_priority_queue {};
template<class ValueType, class... Args>
requires
(!internal::can_removable_priority_queue<ValueType, Args...>) &&
requires () {
typename std::priority_queue<ValueType, Args...>;
}
struct removable_priority_queue<ValueType, Args...> : removable_priority_queue<std::priority_queue<ValueType, Args...>> {
using removable_priority_queue<std::priority_queue<ValueType, Args...>>::removable_priority_queue;
};
template<internal::can_removable_priority_queue PriorityQueue>
struct removable_priority_queue<PriorityQueue>
: removable_priority_queue<PriorityQueue, internal::dummy>
{
using removable_priority_queue<PriorityQueue, internal::dummy>::removable_priority_queue;
};
template<
internal::can_removable_priority_queue PriorityQueue,
class Multiset
>
struct removable_priority_queue<PriorityQueue, Multiset> : PriorityQueue {
using base_type = PriorityQueue;
using multiset_type = Multiset;
using size_type = typename PriorityQueue::size_type;
using value_type = typename PriorityQueue::value_type;
using const_reference = typename PriorityQueue::const_reference;
private:
using self = removable_priority_queue<PriorityQueue, Multiset>;
base_type _deleted;
multiset_type _elements;
static constexpr bool CHECK_EXISTANCE = !std::same_as<multiset_type, internal::dummy>;
void _delete() noexcept(NO_EXCEPT) {
while(!this->_deleted.empty() && this->_deleted.top() == this->base_type::top()) {
this->base_type::pop();
this->_deleted.pop();
}
}
public:
using base_type::base_type;
size_type size() noexcept(NO_EXCEPT) {
if constexpr(!self::CHECK_EXISTANCE) {
assert(this->base_type::size() >= this->_deleted.size());
}
return this->base_type::size() - this->_deleted.size();
}
size_type empty() noexcept(NO_EXCEPT) {
if constexpr(!self::CHECK_EXISTANCE) {
assert(this->base_type::size() >= this->_deleted.size());
}
return this->base_type::size() == this->_deleted.size();
}
void push(const value_type& v) noexcept(NO_EXCEPT) {
if constexpr(self::CHECK_EXISTANCE) this->_elements.insert(v);
return this->base_type::push(v);
}
void push(value_type&& v) noexcept(NO_EXCEPT) {
if constexpr(self::CHECK_EXISTANCE) this->_elements.insert(std::move(v));
return this->base_type::push(std::move(v));
}
template<class... Args>
decltype(auto) emplace(Args&&... args) noexcept(NO_EXCEPT) {
if constexpr(self::CHECK_EXISTANCE) this->_elements.emplace(args...);
return this->base_type::emplace(std::forward<Args>(args)...);
}
std::conditional_t<self::CHECK_EXISTANCE, bool, void> remove(const value_type& v) noexcept(NO_EXCEPT) {
if constexpr(self::CHECK_EXISTANCE) {
if(!this->_elements.contains(v)) return false;
}
this->_deleted.push(v);
if constexpr(self::CHECK_EXISTANCE) return true;
}
std::conditional_t<self::CHECK_EXISTANCE, bool, void> remove(value_type&& v) noexcept(NO_EXCEPT) {
if constexpr(self::CHECK_EXISTANCE) {
if(!this->_elements.contains(v)) return false;
}
this->_deleted.push(std::move(v));
if constexpr(self::CHECK_EXISTANCE) return true;
}
template<class... Args>
std::conditional_t<self::CHECK_EXISTANCE, bool, void> eliminate(Args&&... args) noexcept(NO_EXCEPT) {
if constexpr(self::CHECK_EXISTANCE) {
if(!this->_elements.contains({ args... })) return false;
}
this->_deleted.emplace(std::forward<Args>(args)...);
if constexpr(self::CHECK_EXISTANCE) return true;
}
const_reference top() noexcept(NO_EXCEPT) {
this->_delete();
return this->base_type::top();
}
void pop() noexcept(NO_EXCEPT) {
this->_delete();
this->base_type::pop();
}
};
} // namespace uni
#line 2 "data_structure/restorable_stack.hpp"
#line 6 "data_structure/restorable_stack.hpp"
#line 8 "data_structure/restorable_stack.hpp"
namespace uni {
template<class T, class ID = int, template<class,class> class storage = std::unordered_map>
struct restorable_stack {
using value_type = T;
using key_type = ID;
protected:
struct node;
using node_ptr = std::shared_ptr<node>;
struct node {
std::optional<value_type> val = std::nullopt;
node_ptr parent;
};
node_ptr _current;
storage<key_type, node_ptr> _storage;
public:
restorable_stack() noexcept(NO_EXCEPT) { this->clear(); };
inline bool empty() const noexcept(NO_EXCEPT) {
return !this->_current->val.has_value();
}
inline bool stored(const key_type& x) const noexcept(NO_EXCEPT) {
return this->_storage.count(x);
}
inline const value_type& top() const noexcept(NO_EXCEPT) {
return this->_current->val.value();
}
inline auto get() const noexcept(NO_EXCEPT) {
return this->_current.val;
}
template<std::convertible_to<T> U = T>
inline auto top_or(U &&v) const noexcept(NO_EXCEPT) {
return this->_current->val.value_or(std::forward<U>(v));
}
inline auto& push(const value_type& x) noexcept(NO_EXCEPT) {
this->_current.reset(new node{ x, this->_current });
return *this;
}
inline auto& pop() noexcept(NO_EXCEPT) {
this->_current = this->_current->parent;
return *this;
}
inline auto& save(const key_type& x) noexcept(NO_EXCEPT) {
this->_storage[x] = this->_current;
return *this;
}
inline auto& load(const key_type& x) noexcept(NO_EXCEPT) {
assert(this->stored(x));
this->_current = this->_storage[x];
return *this;
}
inline auto& clear() noexcept(NO_EXCEPT) {
this->_current.reset(new node{});
return *this;
}
inline auto& load_or_clear(const key_type& x) noexcept(NO_EXCEPT) {
if(this->stored(x)) this->load(x);
else this->clear();
return *this;
}
};
} // namespace uni
#line 2 "data_structure/segment_tree_rooter.hpp"
#line 5 "data_structure/segment_tree_rooter.hpp"
#line 9 "data_structure/segment_tree_rooter.hpp"
namespace uni {
template<std::integral SizeType>
struct segment_tree_rooter {
using size_type = SizeType;
private:
size_type _n = 0;
public:
segment_tree_rooter() noexcept = default;
explicit segment_tree_rooter(const size_type n) noexcept(NO_EXCEPT) : _n(n) {};
inline size_type size() const noexcept(NO_EXCEPT) { return this->_n; }
inline size_type allocated() const noexcept(NO_EXCEPT) { return (this->_n << 1) - 1; }
template<std::invocable<size_type> F>
void range_to_nodes(size_type l, size_type r, F&& f) noexcept(NO_EXCEPT) {
l += this->_n;
r += this->_n;
while(l < r) {
if(l & 1) f(l++ - 1);
if(r & 1) f(--r - 1);
l >>= 1;
r >>= 1;
}
}
size_type point_to_node(const size_type p) noexcept(NO_EXCEPT) { return this->_n + p - 1; }
template<std::invocable<size_type> F>
void point_to_path(size_type p, F&& f) noexcept(NO_EXCEPT) {
p += this->_n;
while(p > 0) f(p - 1), p >>= 1;
}
};
}
#line 2 "data_structure/wavelet_matrix.hpp"
#line 19 "data_structure/wavelet_matrix.hpp"
#line 22 "data_structure/wavelet_matrix.hpp"
#line 27 "data_structure/wavelet_matrix.hpp"
#line 2 "adaptor/gnu/hash_table.hpp"
#line 5 "adaptor/gnu/hash_table.hpp"
#include <stdexcept>
#include <ext/pb_ds/assoc_container.hpp>
#line 11 "adaptor/gnu/hash_table.hpp"
namespace uni {
namespace gnu {
template<class Base>
struct hash_table : Base {
using key_type = typename Base::key_type;
using value_type = typename Base::value_type;
using mapped_type = typename Base::mapped_type;
inline bool contains(const key_type& key) const noexcept(NO_EXCEPT) {
return this->Base::find(key) != this->Base::end();
}
template<class K, class T>
inline decltype(auto) emplace(K&& key, T&& val) noexcept(NO_EXCEPT) {
return this->Base::insert({ std::forward<K>(key), std::forward<T>(val) });
}
mapped_type& at(const key_type& key) {
auto itr = this->Base::find(key);
if(itr == this->Base::end()) throw std::out_of_range("hash_table::at()");
return itr->second;
};
const mapped_type& at(const key_type & key) const {
auto itr = this->Base::find(key);
if(itr == this->Base::end()) throw std::out_of_range("hash_table::at()");
return itr->second;
};
};
template<class Key, class T, class Hash = void>
struct cc_hash_table : hash_table<__gnu_pbds::cc_hash_table<Key, T, Hash>> {
using hash_table<__gnu_pbds::cc_hash_table<Key, T, Hash>>::hash_table;
};
template<class Key, class T>
struct cc_hash_table<Key, T, void> : hash_table<__gnu_pbds::cc_hash_table<Key, T>> {
using hash_table<__gnu_pbds::cc_hash_table<Key, T>>::hash_table;
};
template<class Key, class T, class Hash = void>
struct gp_hash_table : hash_table<__gnu_pbds::gp_hash_table<Key, T, Hash>> {
using hash_table<__gnu_pbds::gp_hash_table<Key, T, Hash>>::hash_table;
};
template<class Key, class T>
struct gp_hash_table<Key, T, void> : hash_table<__gnu_pbds::gp_hash_table<Key, T>> {
using hash_table<__gnu_pbds::gp_hash_table<Key, T>>::hash_table;
};
} // namespace gnu
} // namespace uni
#line 29 "data_structure/wavelet_matrix.hpp"
#line 31 "data_structure/wavelet_matrix.hpp"
#line 2 "iterable/compressed.hpp"
#line 10 "iterable/compressed.hpp"
#line 15 "iterable/compressed.hpp"
#line 17 "iterable/compressed.hpp"
namespace uni {
template<class T, class Container = vector<internal::size_t>>
struct compressed : Container {
using size_type = internal::size_t;
using value_type = T;
std::vector<value_type> values;
public:
compressed() noexcept(NO_EXCEPT) = default;
template<std::input_iterator I, std::sized_sentinel_for<I> S>
compressed(I first, S last) noexcept(NO_EXCEPT) {
this->values.assign(first, last);
std::ranges::sort(ALL(this->values));
this->values.erase(std::unique(ALL(this->values)), std::ranges::end(this->values));
this->resize(std::ranges::distance(first, last));
{
auto itr = std::ranges::begin(*this);
auto e = first;
for(; e!=last; ++itr, ++e) *itr = this->rank(*e);
}
}
template<std::ranges::input_range R>
explicit compressed(R&& range) noexcept(NO_EXCEPT) : compressed(ALL(range)) {}
inline size_type rank_sup() const { return static_cast<size_type>(this->values.size()); }
inline size_type rank(const value_type& val) const noexcept(NO_EXCEPT) {
return static_cast<size_type>(
std::ranges::distance(std::ranges::begin(this->values), std::ranges::lower_bound(this->values, val))
);
}
inline size_type rank2(const value_type& val) const noexcept(NO_EXCEPT) {
return static_cast<size_type>(
std::ranges::distance(std::ranges::begin(this->values), std::ranges::upper_bound(this->values, val))
) - 1;
}
inline value_type value(const size_type rank) const noexcept(NO_EXCEPT) {
assert(0 <= rank && rank < this->rank_sup());
return this->values[rank];
}
};
template<std::input_iterator I, std::sized_sentinel_for<I> S>
explicit compressed(I, S) -> compressed<typename std::iterator_traits<I>::value_type>;
template<std::ranges::input_range R>
explicit compressed(R&&) -> compressed<typename std::ranges::range_value_t<R>>;
} // namespace uni
#line 33 "data_structure/wavelet_matrix.hpp"
#line 35 "data_structure/wavelet_matrix.hpp"
#line 38 "data_structure/wavelet_matrix.hpp"
namespace uni {
namespace internal {
namespace wavelet_matrix_impl {
// Thanks to: https://github.com/NyaanNyaan/library/blob/master/data-structure-2d/wavelet-matrix.hpp
template<std::unsigned_integral T, class MapType>
requires std::same_as<T, typename MapType::key_type>
struct base {
using size_type = internal::size_t;
using impl_type = T;
private:
size_type _n;
int _bits;
std::vector<bit_vector> _index;
std::vector<std::vector<impl_type>> _sum;
MapType _first_pos;
impl_type _max = 0;
public:
base() = default;
template<std::ranges::input_range R>
explicit base(R&& range) noexcept(NO_EXCEPT) : base(ALL(range)) {}
template<std::input_iterator I, std::sentinel_for<I> S>
base(I first, S last) noexcept(NO_EXCEPT) { this->build(first, last); }
template<std::convertible_to<impl_type> U>
base(const std::initializer_list<U>& init_list) noexcept(NO_EXCEPT) : base(ALL(init_list)) {}
inline size_type size() const noexcept(NO_EXCEPT) { return this->_n; }
inline size_type bits() const noexcept(NO_EXCEPT) { return this->_bits; }
template<std::ranges::input_range R>
inline void build(R&& range) noexcept(NO_EXCEPT) { this->build(ALL(range)); }
template<std::input_iterator I, std::sized_sentinel_for<I> S>
__attribute__((optimize("O3")))
void build(I first, S last) noexcept(NO_EXCEPT) {
this->_n = static_cast<size_type>(std::ranges::distance(first, last));
this->_max = first == last ? -1 : *std::ranges::max_element(first, last);
this->_bits = std::bit_width(this->_max + 1);
this->_index.assign(this->_bits, this->_n);
std::vector<impl_type> bit(first, last), nxt(this->_n);
this->_sum.assign(this->_bits + 1, std::vector<impl_type>(this->_n + 1));
{
size_type i = 0;
for(auto itr=first; itr!=last; ++i, ++itr) {
assert(*itr >= 0);
this->_sum[this->_bits][i + 1] = this->_sum[this->_bits][i] + *itr;
}
}
REPD(h, this->_bits) {
std::vector<size_type> vals;
for(size_type i = 0; i < this->_n; ++i) {
if((bit[i] >> h) & 1) this->_index[h].set(i);
}
this->_index[h].build();
std::array<typename std::vector<impl_type>::iterator, 2> itrs{
std::ranges::begin(nxt), std::ranges::next(std::ranges::begin(nxt), this->_index[h].zeros())
};
REP(i, this->_n) *itrs[this->_index[h].get(i)]++ = bit[i];
REP(i, this->_n) this->_sum[h][i + 1] = this->_sum[h][i] + nxt[i];
std::swap(bit, nxt);
}
REPD(i, this->_n) this->_first_pos[bit[i]] = static_cast<MapType::mapped_type>(i);
}
protected:
inline auto get(const size_type k) const noexcept(NO_EXCEPT) {
return this->_sum[this->_bits][k + 1] - this->_sum[this->_bits][k];
}
auto select(const impl_type& v, const size_type rank) const noexcept(NO_EXCEPT) {
if(v > this->_max) return this->_n;
if(not this->_first_pos.contains(v)) return this->_n;
size_type pos = this->_first_pos.at(v) + rank;
REP(h, this->_bits) {
if(uni::bit(v, h)) pos = this->_index[h].select1(pos - this->_index[h].zeros());
else pos = this->_index[h].select0(pos);
}
return pos;
}
auto kth_smallest(size_type *const l, size_type *const r, size_type *const k) const noexcept(NO_EXCEPT) {
impl_type val = 0;
for(size_type h = this->_bits - 1; h >= 0; --h) {
size_type l0 = this->_index[h].rank0(*l), r0 = this->_index[h].rank0(*r);
if(*k < r0 - l0) {
*l = l0, *r = r0;
}
else {
*k -= r0 - l0;
val |= impl_type{1} << h;
*l += this->_index[h].zeros() - l0;
*r += this->_index[h].zeros() - r0;
}
}
return val;
}
inline auto kth_smallest(size_type l, size_type r, size_type k) const noexcept(NO_EXCEPT) {
return this->kth_smallest(&l, &r, &k);
}
auto kth_smallest_index(size_type l, size_type r, size_type k) const noexcept(NO_EXCEPT) {
const impl_type val = this->kth_smallest(&l, &r, &k);
size_type left = 0;
REPD(h, this->_bits) {
if(uni::bit(val, h)) left = this->_index[h].rank1(left) + this->_index[h].zeros();
else left = this->_index[h].rank0(left);
}
return this->select(val, l + k - left);
}
inline auto kth_largest(const size_type l, const size_type r, const size_type k) const noexcept(NO_EXCEPT) {
return this->kth_smallest(l, r, r - l - k - 1);
}
inline auto kth_largest_index(const size_type l, const size_type r, const size_type k) const noexcept(NO_EXCEPT) {
return this->kth_smallest_index(l, r, r - l - k - 1);
}
inline auto succ0(const size_type l, const size_type r, const size_type h) const noexcept(NO_EXCEPT) {
return std::make_pair(this->_index[h].rank0(l), this->_index[h].rank0(r));
}
inline auto succ1(const size_type l, const size_type r, const size_type h) const noexcept(NO_EXCEPT) {
const size_type l0 = this->_index[h].rank0(l);
const size_type r0 = this->_index[h].rank0(r);
const size_type vals = this->_index[h].zeros();
return std::make_pair(l + vals - l0, r + vals - r0);
}
impl_type sum_in_range(
const size_type l, const size_type r,
const impl_type& x, const impl_type& y,
const impl_type& cur, const size_type bit
) const noexcept(NO_EXCEPT)
{
if(l == r) return 0;
if(bit == -1) {
if(x <= cur && cur <= y) return cur * (r - l);
return 0;
}
const impl_type nxt = (impl_type{1} << bit) | cur;
const impl_type ones = ((impl_type{1} << bit) - 1) | nxt;
if(ones < x || y < cur) return 0;
if(x <= cur && ones <= y) return this->_sum[bit + 1][r] - this->_sum[bit + 1][l];
const size_type l0 = this->_index[bit].rank0(l), r0 = this->_index[bit].rank0(r);
const size_type l1 = l - l0, r1 = r - r0;
return
this->sum_in_range(l0, r0, x, y, cur, bit - 1) +
this->sum_in_range(this->_index[bit].zeros() + l1, this->_index[bit].zeros() + r1, x, y, nxt, bit - 1);
}
inline auto sum_in_range(const size_type l, const size_type r, const impl_type& x, const impl_type& y) const noexcept(NO_EXCEPT) {
return this->sum_in_range(l, r, x, y, 0, this->_bits - 1);
}
inline auto sum_under(const size_type l, const size_type r, const impl_type& v) const noexcept(NO_EXCEPT) {
return this->sum_in_range(l, r, 0, v - 1);
}
inline auto sum_over(const size_type l, const size_type r, const impl_type& v) const noexcept(NO_EXCEPT) {
return this->sum_in_range(l, r, v + 1, std::numeric_limits<impl_type>::max());
}
inline auto sum_or_under(const size_type l, const size_type r, const impl_type& v) const noexcept(NO_EXCEPT) {
return this->sum_in_range(l, r, 0, v);
}
inline auto sum_or_over(const size_type l, const size_type r, const impl_type& v) const noexcept(NO_EXCEPT) {
return this->sum_in_range(l, r, v, std::numeric_limits<impl_type>::max());
}
inline auto sum(const size_type l, const size_type r) const noexcept(NO_EXCEPT) {
return this->_sum[this->_bits][r] - this->_sum[this->_bits][l];
}
auto count_under(size_type l, size_type r, const impl_type& y) const noexcept(NO_EXCEPT) {
if(y >= (impl_type{1} << this->_bits)) return r - l;
size_type res = 0;
REPD(h, this->_bits) {
bool f = (y >> h) & 1;
size_type l0 = this->_index[h].rank0(l), r0 = this->_index[h].rank0(r);
if(f) {
res += r0 - l0;
l += this->_index[h].zeros() - l0;
r += this->_index[h].zeros() - r0;
} else {
l = l0;
r = r0;
}
}
return res;
}
inline auto count_or_under(const size_type l, const size_type r, const impl_type& v) const noexcept(NO_EXCEPT) {
return this->count_under(l, r, v + 1);
}
inline auto count_or_over(const size_type l, const size_type r, const impl_type& v) const noexcept(NO_EXCEPT) {
return r - l - this->count_under(l, r, v);
}
inline auto count_over(const size_type l, const size_type r, const impl_type& v) const noexcept(NO_EXCEPT) {
return this->count_or_over(l, r, v + 1);
}
inline auto count_in_range(const size_type l, const size_type r, const impl_type& x, const impl_type& y) const noexcept(NO_EXCEPT) {
return this->count_or_under(l, r, y) - this->count_under(l, r, x);
}
inline auto count_equal_to(const size_type l, const size_type r, const impl_type& v) const noexcept(NO_EXCEPT) {
return this->count_in_range(l, r, v, v);
}
inline std::optional<impl_type> next(const size_type l, const size_type r, const impl_type& v, const size_type k) const noexcept(NO_EXCEPT) {
const size_type rank = this->count_under(l, r, v) + k;
if(rank < 0 || rank >= r - l) return {};
return { this->kth_smallest(l, r, rank) };
}
inline std::optional<impl_type> prev(const size_type l, const size_type r, const impl_type& v, const size_type k) const noexcept(NO_EXCEPT) {
const size_type rank = this->count_over(l, r, v) + k;
if(rank < 0 || rank >= r - l) return {};
return this->kth_largest(l, r, rank);
}
};
} // namespace wavelet_matrix_impl
} // namespace internal
template<std::integral T, template<class...> class MapTemplate = gnu::gp_hash_table>
struct compressed_wavelet_matrix;
template<std::integral T, template<class...> class MapTemplate = gnu::gp_hash_table>
struct wavelet_matrix : internal::wavelet_matrix_impl::base<std::make_unsigned_t<T>, MapTemplate<std::make_unsigned_t<T>, u32>> {
using value_type = T;
using impl_type = std::make_unsigned_t<T>;
using map_type = MapTemplate<impl_type, u32>;
using size_type = internal::size_t;
using compressed = compressed_wavelet_matrix<value_type, MapTemplate>;
private:
using base = internal::wavelet_matrix_impl::base<impl_type, map_type>;
public:
protected:
inline size_type _positivize_index(const size_type p) const noexcept(NO_EXCEPT) {
return p < 0 ? this->size() + p : p;
}
public:
using base::base;
inline bool empty() const noexcept(NO_EXCEPT) { return this->size() == 0; }
inline value_type get(size_type p) const noexcept(NO_EXCEPT) {
p = this->_positivize_index(p), assert(0 <= p && p < this->size());
return this->base::get(p);
}
inline auto operator[](const size_type p) const noexcept(NO_EXCEPT) { return this->get(p); }
inline auto select(const value_type& v, const size_type p) const noexcept(NO_EXCEPT) {
return this->base::select(v, p);
}
struct iterator;
struct range_reference;
template<uni::interval_notation rng = uni::interval_notation::right_open>
inline auto range(const size_type l, const size_type r) const noexcept(NO_EXCEPT) {
if constexpr(rng == uni::interval_notation::right_open) return range_reference(this, l, r);
if constexpr(rng == uni::interval_notation::left_open) return range_reference(this, l + 1, r + 1);
if constexpr(rng == uni::interval_notation::open) return range_reference(this, l + 1, r);
if constexpr(rng == uni::interval_notation::closed) return range_reference(this, l, r + 1);
}
inline auto range() const noexcept(NO_EXCEPT) { return range_reference(this, 0, this->size()); }
inline auto operator()(const size_type l, const size_type r) const noexcept(NO_EXCEPT) { return range_reference(this, l, r); }
inline auto subseq(const size_type p, const size_type c) const noexcept(NO_EXCEPT) { return range_reference(this, p, p+c); }
inline auto subseq(const size_type p) const noexcept(NO_EXCEPT) { return range_reference(this, p, this->size()); }
struct range_reference : internal::range_reference<const wavelet_matrix> {
range_reference(const wavelet_matrix *const super, const size_type l, const size_type r) noexcept(NO_EXCEPT)
: internal::range_reference<const wavelet_matrix>(super, super->_positivize_index(l), super->_positivize_index(r))
{
assert(0 <= this->_begin && this->_begin <= this->_end && this->_end <= this->_super->size());
}
inline auto get(const size_type k) const noexcept(NO_EXCEPT) {
k = this->_super->_positivize_index(k);
assert(0 <= k && k < this->size());
return this->_super->get(this->_begin + k);
}
inline auto operator[](const size_type k) const noexcept(NO_EXCEPT) { return this->get(k); }
inline value_type kth_smallest(const size_type k) const noexcept(NO_EXCEPT) {
assert(0 <= k && k < this->size());
return this->_super->base::kth_smallest(this->_begin, this->_end, k);
}
inline auto kth_smallest_element(const size_type k) const noexcept(NO_EXCEPT) {
if(k == this->size()) return this->end();
assert(0 <= k && k < this->size());
return std::ranges::next(this->_super->begin(), this->_super->base::kth_smallest_index(this->_begin, this->_end, k));
}
inline value_type kth_largest(const size_type k) const noexcept(NO_EXCEPT) {
assert(0 <= k && k < this->size());
return this->_super->base::kth_largest(this->_begin, this->_end, k);
}
inline auto kth_largest_element(const size_type k) const noexcept(NO_EXCEPT) {
if(k == this->size()) return this->end();
assert(0 <= k && k < this->size());
return std::ranges::next(this->_super->begin(), this->_super->base::kth_largest_index(this->_begin, this->_end, k));
}
inline auto min() const noexcept(NO_EXCEPT) { return this->kth_smallest(0); }
inline auto max() const noexcept(NO_EXCEPT) { return this->kth_largest(0); }
// (r-l)/2 th smallest (0-origin)
inline auto median() const noexcept(NO_EXCEPT) { return this->kth_smallest(this->size() / 2); }
inline value_type sum_in_range(const value_type& x, const value_type& y) const noexcept(NO_EXCEPT) { return this->_super->base::sum_in_range(this->_begin, this->_end, x, y); }
inline value_type sum_under(const value_type& v) const noexcept(NO_EXCEPT) { return this->_super->base::sum_under(this->_begin, this->_end, v); }
inline value_type sum_over(const value_type& v) const noexcept(NO_EXCEPT) { return this->_super->base::sum_over(this->_begin, this->_end, v); }
inline value_type sum_or_under(const value_type& v) const noexcept(NO_EXCEPT) { return this->_super->base::sum_or_under(this->_begin, this->_end, v); }
inline value_type sum_or_over(const value_type& v) const noexcept(NO_EXCEPT) { return this->_super->base::sum_or_over(this->_begin, this->_end, v); }
inline value_type sum(const value_type& x, const value_type& y) const noexcept(NO_EXCEPT) { return this->_super->base::sum_in_range(this->_begin, this->_end, x, y); }
inline value_type sum() const noexcept(NO_EXCEPT) { return this->_super->base::sum(this->_begin, this->_end); }
template<comparison com>
inline auto sum(const value_type& v) const noexcept(NO_EXCEPT) {
if constexpr(com == comparison::under) return this->sum_under(v);
if constexpr(com == comparison::over) return this->sum_over(v);
if constexpr(com == comparison::or_under) return this->sum_or_under(v);
if constexpr(com == comparison::or_over) return this->sum_or_over(v);
assert(false);
}
inline auto count_in_range(const value_type& x, const value_type& y) const noexcept(NO_EXCEPT) {
return this->_super->base::count_in_range(this->_begin, this->_end, x, y);
}
inline auto count_equal_to(const value_type& v) const noexcept(NO_EXCEPT) { return this->_super->base::count_equal_to(this->_begin, this->_end, v); }
inline auto count_under(const value_type& v) const noexcept(NO_EXCEPT) { return this->_super->base::count_under(this->_begin, this->_end, v); }
inline auto count_over(const value_type& v) const noexcept(NO_EXCEPT) { return this->_super->base::count_over(this->_begin, this->_end, v); }
inline auto count_or_under(const value_type& v) const noexcept(NO_EXCEPT) { return this->_super->base::count_or_under(this->_begin, this->_end, v); }
inline auto count_or_over(const value_type& v) const noexcept(NO_EXCEPT) { return this->_super->base::count_or_over(this->_begin, this->_end, v); }
template<comparison com = comparison::equal_to>
inline auto count(const value_type& v) const noexcept(NO_EXCEPT) {
if constexpr(com == comparison::equal_to) return this->count_equal_to(v);
if constexpr(com == comparison::under) return this->count_under(v);
if constexpr(com == comparison::over) return this->count_over(v);
if constexpr(com == comparison::or_under) return this->count_or_under(v);
if constexpr(com == comparison::or_over) return this->count_or_over(v);
assert(false);
}
inline auto next_element(const value_type& v, const size_type k = 0) const noexcept(NO_EXCEPT) {
return this->kth_smallest_element(std::clamp(this->count_under(v) + k, size_type{ 0 }, this->size()));
}
inline auto prev_element(const value_type& v, const size_type k = 0) const noexcept(NO_EXCEPT) {
return this->kth_largest_element(std::clamp(this->count_over(v) - k, size_type{ 0 }, this->size()));
}
inline std::optional<value_type> next(const value_type& v, const size_type k = 0) const noexcept(NO_EXCEPT) {
return this->_super->base::next(this->_begin, this->_end, v, k);
}
inline std::optional<value_type> prev(const value_type& v, const size_type k = 0) const noexcept(NO_EXCEPT) {
return this->_super->base::prev(this->_begin, this->_end, v, k);
}
};
inline auto kth_smallest(const size_type k) const noexcept(NO_EXCEPT) { return this->range().kth_smallest(k); }
inline auto kth_smallest_element(const size_type k) const noexcept(NO_EXCEPT) { return this->range().kth_smallest_element(k); }
inline auto kth_largest(const size_type k) const noexcept(NO_EXCEPT) { return this->range().kth_largest(k); }
inline auto kth_largest_element(const size_type k) const noexcept(NO_EXCEPT) { return this->range().kth_largest_element(k); }
inline auto min() const noexcept(NO_EXCEPT) { return this->range().kth_smallest(0); }
inline auto max() const noexcept(NO_EXCEPT) { return this->range().kth_largest(0); }
// (size)/2 th smallest (0-origin)
inline auto median() const noexcept(NO_EXCEPT) { return this->range().median(); }
inline auto sum_in_range(const value_type& x, const value_type& y) const noexcept(NO_EXCEPT) { return this->range().sum_in_range(x, y); }
inline auto sum_under(const value_type& v) const noexcept(NO_EXCEPT) { return this->range().sum_under(v); }
inline auto sum_over(const value_type& v) const noexcept(NO_EXCEPT) { return this->range().sum_over(v); }
inline auto sum_or_under(const value_type& v) const noexcept(NO_EXCEPT) { return this->range().sum_or_under(v); }
inline auto sum_or_over(const value_type& v) const noexcept(NO_EXCEPT) { return this->range().sum_or_over(v); }
inline auto sum(const value_type& x, const value_type& y) const noexcept(NO_EXCEPT) { return this->range().sum_in_range(x, y); }
inline auto sum() const noexcept(NO_EXCEPT) { return this->range().sum(); }
template<comparison com>
inline auto sum(const value_type& v) const noexcept(NO_EXCEPT) { return this->range().template sum<com>(v); }
inline auto count_in_range(const value_type& x, const value_type& y) const noexcept(NO_EXCEPT) { return this->range().count_in_range(x, y); }
inline auto count_equal_to(const value_type& v) const noexcept(NO_EXCEPT) { return this->range().count_equal_to(v); }
inline auto count_under(const value_type& v) const noexcept(NO_EXCEPT) { return this->range().count_under(v); }
inline auto count_over(const value_type& v) const noexcept(NO_EXCEPT) { return this->range().count_over(v); }
inline auto count_or_under(const value_type& v) const noexcept(NO_EXCEPT) { return this->range().count_or_under(v); }
inline auto count_or_over(const value_type& v) const noexcept(NO_EXCEPT) { return this->range().count_or_over(v); }
template<comparison com = comparison::equal_to>
inline auto count(const value_type& v) const noexcept(NO_EXCEPT) { return this->range().template count<com>(v); }
inline auto next_element(const value_type& v) const noexcept(NO_EXCEPT) { return this->range().next_element(v); }
inline auto prev_element(const value_type& v) const noexcept(NO_EXCEPT) { return this->range().prev_element(v); }
inline auto next(const value_type& v, const size_type k = 0) const noexcept(NO_EXCEPT) { return this->range().next(v, k); }
inline auto prev(const value_type& v, const size_type k = 0) const noexcept(NO_EXCEPT) { return this->range().prev(v, k); }
struct iterator;
protected:
using iterator_interface = internal::container_iterator_interface<value_type, const wavelet_matrix, const iterator>;
public:
struct iterator : iterator_interface {
using iterator_interface::iterator_interface;
};
inline auto begin() const noexcept(NO_EXCEPT) { return iterator(this, 0); }
inline auto end() const noexcept(NO_EXCEPT) { return iterator(this, this->size()); }
inline auto rbegin() const noexcept(NO_EXCEPT) { return std::make_reverse_iterator(this->end()); }
inline auto rend() const noexcept(NO_EXCEPT) { return std::make_reverse_iterator(this->begin()); }
};
template<std::integral T, template<class...> class MapTemplate>
struct compressed_wavelet_matrix : protected wavelet_matrix<u32, MapTemplate> {
using value_type = T;
using size_type = internal::size_t;
protected:
using core = wavelet_matrix<u32, MapTemplate>;
using compresser = compressed<value_type, valarray<u32>>;
compresser _comp;
public:
compressed_wavelet_matrix() = default;
template<std::ranges::input_range R>
explicit compressed_wavelet_matrix(R&& range) noexcept(NO_EXCEPT) : compressed_wavelet_matrix(ALL(range)) {}
template<std::input_iterator I, std::sentinel_for<I> S>
compressed_wavelet_matrix(I first, S last) noexcept(NO_EXCEPT) { this->build(first, last); }
template<std::input_iterator I, std::sentinel_for<I> S>
inline void build(I first, S last) noexcept(NO_EXCEPT) {
this->_comp = compresser(first, last);
this->core::build(ALL(this->_comp));
}
inline auto get(const size_type k) const noexcept(NO_EXCEPT) { return this->_comp.value(this->core::get(k)); }
inline auto operator[](const size_type k) const noexcept(NO_EXCEPT) { return this->_comp.value(this->core::get(k)); }
struct iterator;
struct range_reference;
template<uni::interval_notation rng = uni::interval_notation::right_open>
inline auto range(const size_type l, const size_type r) const noexcept(NO_EXCEPT) {
if constexpr(rng == uni::interval_notation::right_open) return range_reference(this, l, r);
if constexpr(rng == uni::interval_notation::left_open) return range_reference(this, l + 1, r + 1);
if constexpr(rng == uni::interval_notation::open) return range_reference(this, l + 1, r);
if constexpr(rng == uni::interval_notation::closed) return range_reference(this, l, r + 1);
}
inline auto range() const noexcept(NO_EXCEPT) { return range_reference(this, 0, this->size()); }
inline auto operator()(const size_type l, const size_type r) const noexcept(NO_EXCEPT) { return range_reference(this, l, r); }
inline auto subseq(const size_type p, const size_type c) const noexcept(NO_EXCEPT) { return range_reference(this, p, p+c); }
inline auto subseq(const size_type p) const noexcept(NO_EXCEPT) { return range_reference(this, p, this->size()); }
struct range_reference : internal::range_reference<const compressed_wavelet_matrix> {
range_reference(const compressed_wavelet_matrix *const super, const size_type l, const size_type r) noexcept(NO_EXCEPT)
: internal::range_reference<const compressed_wavelet_matrix>(super, super->_positivize_index(l), super->_positivize_index(r))
{
assert(0 <= this->_begin && this->_begin <= this->_end && this->_end <= this->_super->size());
}
private:
inline auto _range() const noexcept(NO_EXCEPT) { return this->_super->core::range(this->_begin, this->_end); }
public:
inline auto get(const size_type k) const noexcept(NO_EXCEPT) { return this->_super->_comp.value(this->_range().get(k)); }
inline auto operator[](const size_type k) const noexcept(NO_EXCEPT) { return this->get(k); }
inline auto kth_smallest(const size_type k) const noexcept(NO_EXCEPT) { return this->_super->_comp.value(this->_range().kth_smallest(k)); }
inline auto kth_smallest_element(const size_type k) const noexcept(NO_EXCEPT) {
return std::ranges::next(this->_super->begin(), std::ranges::distance(this->_super->core::begin(), this->_range().kth_smallest_element(k)));
}
inline auto kth_largest(const size_type k) const noexcept(NO_EXCEPT) { return this->_super->_comp.value(this->_range().kth_largest(k));}
inline auto kth_largest_element(const size_type k) const noexcept(NO_EXCEPT) {
return std::ranges::next(this->_super->begin(), std::ranges::distance(this->_super->core::begin(), this->_range().kth_largest_element(k)));
}
inline auto min() const noexcept(NO_EXCEPT) { return this->kth_smallest(0); }
inline auto max() const noexcept(NO_EXCEPT) { return this->kth_largest(0); }
// (r-l)/2 th smallest (0-origin)
inline auto median() const noexcept(NO_EXCEPT) { return this->kth_smallest(this->size() / 2); }
inline auto count_in_range(const value_type& x, const value_type& y) const noexcept(NO_EXCEPT) {
return this->_range().count_in_range(this->_super->_comp.rank(x), this->_super->_comp.rank2(y));
}
inline size_type count_equal_to(const value_type& v) const noexcept(NO_EXCEPT) {
const auto p = this->_super->_comp.rank(v);
const auto q = this->_super->_comp.rank2(v);
if(p != q) return 0;
return this->_range().count_equal_to(p);
}
inline auto count_under(const value_type& v) const noexcept(NO_EXCEPT) { return this->_range().count_under(this->_super->_comp.rank(v)); }
inline auto count_over(const value_type& v) const noexcept(NO_EXCEPT) { return this->_range().count_over(this->_super->_comp.rank2(v)); }
inline auto count_or_under(const value_type& v) const noexcept(NO_EXCEPT) { return this->_range().count_or_under(this->_super->_comp.rank2(v)); }
inline auto count_or_over(const value_type& v) const noexcept(NO_EXCEPT) { return this->_range().count_or_over(this->_super->_comp.rank(v)); }
template<comparison com = comparison::equal_to>
inline auto count(const value_type& v) const noexcept(NO_EXCEPT) {
if constexpr(com == comparison::equal_to) return this->count_equal_to(v);
if constexpr(com == comparison::under) return this->count_under(v);
if constexpr(com == comparison::over) return this->count_over(v);
if constexpr(com == comparison::or_under) return this->count_or_under(v);
if constexpr(com == comparison::or_over) return this->count_or_over(v);
assert(false);
}
inline auto next_element(const value_type& v, const size_type k = 0) const noexcept(NO_EXCEPT) {
return this->kth_smallest_element(std::clamp(this->_range().count_under(this->_super->_comp.rank(v) + k), size_type{ 0 }, this->size()));
}
inline auto prev_element(const value_type& v, const size_type k = 0) const noexcept(NO_EXCEPT) {
return this->kth_largest_element(std::clamp(this->_range().count_over(this->_super->_comp.rank2(v) + k), size_type{ 0 }, this->size()));
}
inline std::optional<value_type> next(const value_type& v, const size_type k = 0) const noexcept(NO_EXCEPT) {
const auto res = this->_range().next(this->_super->_comp.rank(v), k);
if(res.has_value()) return this->_super->_comp.value(res.value());
return {};
}
inline std::optional<value_type> prev(const value_type& v, const size_type k = 0) const noexcept(NO_EXCEPT) {
const auto res = this->_range().prev(this->_super->_comp.rank2(v), k);
if(res.has_value()) return this->_super->_comp.value(res.value());
return {};
}
};
inline auto kth_smallest(const size_type k) const noexcept(NO_EXCEPT) { return this->range().kth_smallest(k); }
inline auto kth_smallest_element(const size_type k) const noexcept(NO_EXCEPT) { return this->range().kth_smallest_element(k); }
inline auto kth_largest(const size_type k) const noexcept(NO_EXCEPT) { return this->range().kth_largest(k); }
inline auto kth_largest_element(const size_type k) const noexcept(NO_EXCEPT) { return this->range().kth_largest_element(k); }
inline auto min() const noexcept(NO_EXCEPT) { return this->range().kth_smallest(0); }
inline auto max() const noexcept(NO_EXCEPT) { return this->range().kth_largest(0); }
inline auto median() const noexcept(NO_EXCEPT) { return this->range().median(); }
inline auto count_in_range(const value_type& x, const value_type& y) const noexcept(NO_EXCEPT) { return this->range().count_in_range(x, y); }
inline auto count_equal_to(const value_type& v) const noexcept(NO_EXCEPT) { return this->range().count_equal_to(v); }
inline auto count_under(const value_type& v) const noexcept(NO_EXCEPT) { return this->range().count_under(v); }
inline auto count_over(const value_type& v) const noexcept(NO_EXCEPT) { return this->range().count_over(v); }
inline auto count_or_under(const value_type& v) const noexcept(NO_EXCEPT) { return this->range().count_or_under(v); }
inline auto count_or_over(const value_type& v) const noexcept(NO_EXCEPT) { return this->range().count_or_over(v); }
template<comparison com = comparison::equal_to>
inline auto count(const value_type& v) const noexcept(NO_EXCEPT) { return this->range().template count<com>(v); }
inline auto next_element(const value_type& v) const noexcept(NO_EXCEPT) { return this->range().next_element(v); }
inline auto prev_element(const value_type& v) const noexcept(NO_EXCEPT) { return this->range().prev_element(v); }
inline auto next(const value_type& v, const size_type k = 0) const noexcept(NO_EXCEPT) { return this->range().next(v, k); }
inline auto prev(const value_type& v, const size_type k = 0) const noexcept(NO_EXCEPT) { return this->range().prev(v, k); }
struct iterator;
protected:
using iterator_interface = internal::container_iterator_interface<value_type, const compressed_wavelet_matrix, const iterator>;
public:
struct iterator : iterator_interface {
using iterator_interface::iterator_interface;
};
inline auto begin() const noexcept(NO_EXCEPT) { return iterator(this, 0); }
inline auto end() const noexcept(NO_EXCEPT) { return iterator(this, this->size()); }
inline auto rbegin() const noexcept(NO_EXCEPT) { return std::make_reverse_iterator(this->end()); }
inline auto rend() const noexcept(NO_EXCEPT) { return std::make_reverse_iterator(this->begin()); }
};
template<std::ranges::input_range R>
explicit wavelet_matrix(R&&) -> wavelet_matrix<std::ranges::range_value_t<R>>;
template<std::input_iterator I, std::sentinel_for<I> S>
explicit wavelet_matrix(I, S) -> wavelet_matrix<std::iter_value_t<I>>;
template<std::ranges::input_range R>
explicit compressed_wavelet_matrix(R&&) -> compressed_wavelet_matrix<std::ranges::range_value_t<R>>;
template<std::input_iterator I, std::sentinel_for<I> S>
explicit compressed_wavelet_matrix(I, S) -> compressed_wavelet_matrix<std::iter_value_t<I>>;
} // namespace uni
#line 26 "include/data_structures.hpp"
include/data_structures.hpp