#line 1 "atcoder-workspace/a.cc" #line 1 "atcoder-workspace/a.cc" // #undef _GLIBCXX_DEBUG // #define NDEBUG #include #line 2 "Library/lib/alias" /** * @file alias * @brief Alias */ #line 13 "Library/lib/alias" #line 1 "Library/lib/bit" #if __cplusplus > 201703L #include #else #ifndef _GLIBCXX_BIT #define _GLIBCXX_BIT 1 #include #include namespace std { template constexpr _Tp __rotl(_Tp __x, int __s) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; const int __r = __s % _Nd; if (__r == 0) return __x; else if (__r > 0) return (__x << __r) | (__x >> ((_Nd - __r) % _Nd)); else return (__x >> -__r) | (__x << ((_Nd + __r) % _Nd)); // rotr(x, -r) } template constexpr _Tp __rotr(_Tp __x, int __s) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; const int __r = __s % _Nd; if (__r == 0) return __x; else if (__r > 0) return (__x >> __r) | (__x << ((_Nd - __r) % _Nd)); else return (__x << -__r) | (__x >> ((_Nd + __r) % _Nd)); // rotl(x, -r) } template constexpr int __countl_zero(_Tp __x) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; if (__x == 0) return _Nd; constexpr auto _Nd_ull = numeric_limits::digits; constexpr auto _Nd_ul = numeric_limits::digits; constexpr auto _Nd_u = numeric_limits::digits; if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_u) { constexpr int __diff = _Nd_u - _Nd; return __builtin_clz(__x) - __diff; } else if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_ul) { constexpr int __diff = _Nd_ul - _Nd; return __builtin_clzl(__x) - __diff; } else if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_ull) { constexpr int __diff = _Nd_ull - _Nd; return __builtin_clzll(__x) - __diff; } else // (_Nd > _Nd_ull) { static_assert(_Nd <= (2 * _Nd_ull), "Maximum supported integer size is 128-bit"); unsigned long long __high = __x >> _Nd_ull; if (__high != 0) { constexpr int __diff = (2 * _Nd_ull) - _Nd; return __builtin_clzll(__high) - __diff; } constexpr auto __max_ull = numeric_limits::max(); unsigned long long __low = __x & __max_ull; return (_Nd - _Nd_ull) + __builtin_clzll(__low); } } template constexpr int __countl_one(_Tp __x) noexcept { if (__x == numeric_limits<_Tp>::max()) return numeric_limits<_Tp>::digits; return __countl_zero<_Tp>((_Tp)~__x); } template constexpr int __countr_zero(_Tp __x) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; if (__x == 0) return _Nd; constexpr auto _Nd_ull = numeric_limits::digits; constexpr auto _Nd_ul = numeric_limits::digits; constexpr auto _Nd_u = numeric_limits::digits; if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_u) return __builtin_ctz(__x); else if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_ul) return __builtin_ctzl(__x); else if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_ull) return __builtin_ctzll(__x); else // (_Nd > _Nd_ull) { static_assert(_Nd <= (2 * _Nd_ull), "Maximum supported integer size is 128-bit"); constexpr auto __max_ull = numeric_limits::max(); unsigned long long __low = __x & __max_ull; if (__low != 0) return __builtin_ctzll(__low); unsigned long long __high = __x >> _Nd_ull; return __builtin_ctzll(__high) + _Nd_ull; } } template constexpr int __countr_one(_Tp __x) noexcept { if (__x == numeric_limits<_Tp>::max()) return numeric_limits<_Tp>::digits; return __countr_zero((_Tp)~__x); } template constexpr int __popcount(_Tp __x) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; if (__x == 0) return 0; constexpr auto _Nd_ull = numeric_limits::digits; constexpr auto _Nd_ul = numeric_limits::digits; constexpr auto _Nd_u = numeric_limits::digits; if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_u) return __builtin_popcount(__x); else if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_ul) return __builtin_popcountl(__x); else if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_ull) return __builtin_popcountll(__x); else // (_Nd > _Nd_ull) { static_assert(_Nd <= (2 * _Nd_ull), "Maximum supported integer size is 128-bit"); constexpr auto __max_ull = numeric_limits::max(); unsigned long long __low = __x & __max_ull; unsigned long long __high = __x >> _Nd_ull; return __builtin_popcountll(__low) + __builtin_popcountll(__high); } } template constexpr bool __has_single_bit(_Tp __x) noexcept { return __popcount(__x) == 1; } template constexpr _Tp __bit_ceil(_Tp __x) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; if (__x == 0 || __x == 1) return 1; auto __shift_exponent = _Nd - __countl_zero((_Tp)(__x - 1u)); #ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED if (!__builtin_is_constant_evaluated()) { __glibcxx_assert(__shift_exponent != numeric_limits<_Tp>::digits); } #endif using __promoted_type = decltype(__x << 1); if _GLIBCXX17_CONSTEXPR (!is_same<__promoted_type, _Tp>::value) { const int __extra_exp = sizeof(__promoted_type) / sizeof(_Tp) / 2; __shift_exponent |= (__shift_exponent & _Nd) << __extra_exp; } return (_Tp)1u << __shift_exponent; } template constexpr _Tp __bit_floor(_Tp __x) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; if (__x == 0) return 0; return (_Tp)1u << (_Nd - __countl_zero((_Tp)(__x >> 1))); } template constexpr _Tp __bit_width(_Tp __x) noexcept { constexpr auto _Nd = numeric_limits<_Tp>::digits; return _Nd - __countl_zero(__x); } } // namespace std #endif #endif #line 15 "Library/lib/alias" namespace workspace { constexpr char eol = '\n'; using namespace std; using i32 = int_least32_t; using u32 = uint_least32_t; using i64 = int_least64_t; using u64 = uint_least64_t; #ifdef __SIZEOF_INT128__ using i128 = __int128_t; using u128 = __uint128_t; #else #warning 128bit integer is not available. #endif template > using priority_queue = std::priority_queue, Comp>; template using stack = std::stack>; template constexpr _Tp __bsf(_Tp __x) noexcept { return std::__countr_zero(__x); } template constexpr _Tp __bsr(_Tp __x) noexcept { return std::__bit_width(__x) - 1; } } // namespace workspace #line 6 "atcoder-workspace/a.cc" // #include "lib/cxx20" #line 2 "Library/lib/direct" /* * @file direct * @brief Pragma Directive */ #ifdef ONLINE_JUDGE #pragma GCC optimize("O3") #pragma GCC target("avx,avx2") #pragma GCC optimize("unroll-loops") #endif #line 8 "atcoder-workspace/a.cc" // #include "lib/limits" // #include "lib/opt" #line 2 "Library/src/sys/clock.hpp" /* * @fn clock.hpp * @brief Clock */ #line 9 "Library/src/sys/clock.hpp" namespace workspace { using namespace std::chrono; namespace internal { // The start time of the program. const auto start_time{system_clock::now()}; } // namespace internal /* * @fn elapsed * @return elapsed time of the program */ int64_t elapsed() { const auto end_time{system_clock::now()}; return duration_cast(end_time - internal::start_time).count(); } } // namespace workspace #line 2 "Library/src/sys/ejection.hpp" /** * @file ejection.hpp * @brief Ejection */ #line 9 "Library/src/sys/ejection.hpp" namespace workspace { namespace internal { struct ejection { bool exit = 0; }; } // namespace internal /** * @brief eject from a try block, throw nullptr * @param arg output */ template void eject(Tp const &arg) { std::cout << arg << "\n"; throw internal::ejection{}; } void exit() { throw internal::ejection{true}; } } // namespace workspace #line 2 "Library/src/sys/iteration.hpp" /** * @file iteration.hpp * @brief Case Iteration */ #line 9 "Library/src/sys/iteration.hpp" #line 11 "Library/src/sys/iteration.hpp" namespace workspace { void main(); struct { // 1-indexed unsigned current{0}; unsigned total{1}; void read() { (std::cin >> total).ignore(); } int iterate() { static bool once = false; assert(!once); once = true; while (current++ < total) { try { main(); } catch (internal::ejection const &status) { if (status.exit) break; } } return 0; } } case_info; } // namespace workspace #line 2 "Library/src/utils/cat.hpp" /** * @file cat.hpp * @brief Cat */ #line 9 "Library/src/utils/cat.hpp" namespace workspace { template constexpr C1 &&cat(C1 &&__c1, C2 const &__c2) noexcept { __c1.insert(__c1.end(), std::begin(__c2), std::end(__c2)); return __c1; } } // namespace workspace #line 2 "Library/src/utils/chval.hpp" /* * @file chval.hpp * @brief Change Less/Greater */ #line 9 "Library/src/utils/chval.hpp" namespace workspace { /* * @fn chle * @brief Substitute y for x if comp(y, x) is true. * @param x Reference * @param y Const reference * @param comp Compare function * @return Whether or not x is updated */ template > bool chle(Tp &x, const Tp &y, Comp comp = Comp()) { return comp(y, x) ? x = y, true : false; } /* * @fn chge * @brief Substitute y for x if comp(x, y) is true. * @param x Reference * @param y Const reference * @param comp Compare function * @return Whether or not x is updated */ template > bool chge(Tp &x, const Tp &y, Comp comp = Comp()) { return comp(x, y) ? x = y, true : false; } } // namespace workspace #line 2 "Library/src/utils/fixed_point.hpp" /* * @file fixed_point.hpp * @brief Fixed Point Combinator */ #line 9 "Library/src/utils/fixed_point.hpp" namespace workspace { /* * @class fixed_point * @brief Recursive calling of lambda expression. */ template class fixed_point { lambda_type func; public: /* * @param func 1st arg callable with the rest of args, and the return type * specified. */ fixed_point(lambda_type &&func) : func(std::move(func)) {} /* * @brief Recursively apply *this to 1st arg of func. * @param args Arguments of the recursive method. */ template auto operator()(Args &&... args) const { return func(*this, std::forward(args)...); } }; } // namespace workspace #line 5 "Library/lib/utils" // #include "src/utils/grid.hpp" // #include "src/utils/hash.hpp" #line 2 "Library/src/utils/io/istream.hpp" /** * @file istream.hpp * @brief Input Stream */ #include #line 13 "Library/src/utils/io/istream.hpp" #line 2 "Library/src/utils/sfinae.hpp" /** * @file sfinae.hpp * @brief SFINAE */ #line 10 "Library/src/utils/sfinae.hpp" #include #ifndef __INT128_DEFINED__ #ifdef __SIZEOF_INT128__ #define __INT128_DEFINED__ 1 #else #define __INT128_DEFINED__ 0 #endif #endif namespace std { #if __INT128_DEFINED__ template <> struct make_signed<__uint128_t> { using type = __int128_t; }; template <> struct make_signed<__int128_t> { using type = __int128_t; }; template <> struct make_unsigned<__uint128_t> { using type = __uint128_t; }; template <> struct make_unsigned<__int128_t> { using type = __uint128_t; }; #endif } // namespace std namespace workspace { template struct variadic_front { using type = Tp; }; template struct variadic_back; template struct variadic_back { using type = Tp; }; template struct variadic_back { using type = typename variadic_back::type; }; template class trait> using enable_if_trait_type = typename std::enable_if::value>::type; template using element_type = typename std::decay()))>::type; template struct has_begin : std::false_type {}; template struct has_begin()), nullptr)> : std::true_type {}; template struct mapped_of { using type = element_type; }; template struct mapped_of::first_type> { using type = typename T::mapped_type; }; template using mapped_type = typename mapped_of::type; template struct is_integral_ext : std::false_type {}; template struct is_integral_ext< T, typename std::enable_if::value>::type> : std::true_type {}; #if __INT128_DEFINED__ template <> struct is_integral_ext<__int128_t> : std::true_type {}; template <> struct is_integral_ext<__uint128_t> : std::true_type {}; #endif #if __cplusplus >= 201402 template constexpr static bool is_integral_ext_v = is_integral_ext::value; #endif template struct multiplicable_uint { using type = uint_least32_t; }; template struct multiplicable_uint< T, typename std::enable_if<(2 < sizeof(T)) && (!__INT128_DEFINED__ || sizeof(T) <= 4)>::type> { using type = uint_least64_t; }; #if __INT128_DEFINED__ template struct multiplicable_uint::type> { using type = __uint128_t; }; #endif template struct multiplicable_int { using type = typename std::make_signed::type>::type; }; } // namespace workspace #line 15 "Library/src/utils/io/istream.hpp" namespace workspace { namespace internal { template struct istream_helper { istream_helper(std::istream &is, Tp &x) { if constexpr (has_begin::value) for (auto &&e : x) istream_helper::type>(is, e); else static_assert(has_begin::value, "istream unsupported type."); } }; template struct istream_helper< Tp, decltype(std::declval() >> std::declval())>>(), nullptr)> { istream_helper(std::istream &is, Tp &x) { is >> x; } }; #ifdef __SIZEOF_INT128__ template <> struct istream_helper<__uint128_t, std::nullptr_t> { istream_helper(std::istream &__is, __uint128_t &__x) { std::string __s; __is >> __s; bool __neg = false; if (__s.front() == '-') __neg = true, __s.erase(__s.begin()); __x = 0; for (char __d : __s) { __x *= 10; __d -= '0'; if (__neg) __x -= __d; else __x += __d; } } }; template <> struct istream_helper<__int128_t, std::nullptr_t> { istream_helper(std::istream &__is, __int128_t &__x) { std::string __s; __is >> __s; bool __neg = false; if (__s.front() == '-') __neg = true, __s.erase(__s.begin()); __x = 0; for (char __d : __s) { __x *= 10; __d -= '0'; if (__neg) __x -= __d; else __x += __d; } } }; #endif // INT128 template struct istream_helper> { istream_helper(std::istream &is, std::pair &x) { istream_helper(is, x.first), istream_helper(is, x.second); } }; template struct istream_helper> { istream_helper(std::istream &is, std::tuple &x) { iterate(is, x); } private: template void iterate(std::istream &is, Tp &x) { if constexpr (N == std::tuple_size::value) return; else istream_helper::type>(is, std::get(x)), iterate(is, x); } }; } // namespace internal /** * @brief A wrapper class for std::istream. */ class istream : public std::istream { public: /** * @brief Wrapped operator. */ template istream &operator>>(Tp &x) { internal::istream_helper(*this, x); if (std::istream::fail()) { static auto once = atexit([] { std::cerr << "\n\033[43m\033[30mwarning: failed to read \'" << abi::__cxa_demangle(typeid(Tp).name(), 0, 0, 0) << "\'.\033[0m\n\n"; }); assert(!once); } return *this; } }; namespace internal { auto *const cin_ptr = (istream *)&std::cin; } auto &cin = *internal::cin_ptr; } // namespace workspace #line 2 "Library/src/utils/io/ostream.hpp" /** * @file ostream.hpp * @brief Output Stream */ #line 9 "Library/src/utils/io/ostream.hpp" namespace workspace { /** * @brief Stream insertion operator for std::pair. * * @param __os Output stream * @param __p Pair * @return Reference to __os. */ template Os &operator<<(Os &__os, const std::pair &__p) { return __os << __p.first << ' ' << __p.second; } /** * @brief Stream insertion operator for std::tuple. * * @param __os Output stream * @param __t Tuple * @return Reference to __os. */ template typename std::enable_if::value + 1), Os &>::type operator<<(Os &__os, const Tp &__t) { if constexpr (N != std::tuple_size::value) { if constexpr (N) __os << ' '; __os << std::get(__t); operator<<(__os, __t); } return __os; } template ()))> typename std::enable_if< !std::is_same::type, std::string>::value && !std::is_same::type, char *>::value, Os &>::type operator<<(Os &__os, const Container &__cont) { bool __h = true; for (auto &&__e : __cont) __h ? __h = 0 : (__os << ' ', 0), __os << __e; return __os; } #ifdef __SIZEOF_INT128__ /** * @brief Stream insertion operator for __int128_t. * * @param __os Output Stream * @param __x 128-bit integer * @return Reference to __os. */ template Os &operator<<(Os &__os, __int128_t __x) { if (!__x) return __os << '0'; if (__x < 0) __os << '-'; char __s[40], *__p = __s; while (__x) { auto __d = __x % 10; *__p++ = '0' + (__x < 0 ? -__d : __d); __x /= 10; } *__p = 0; for (char *__t = __s; __t < --__p; ++__t) *__t ^= *__p ^= *__t ^= *__p; return __os << __s; } /** * @brief Stream insertion operator for __uint128_t. * * @param __os Output Stream * @param __x 128-bit unsigned integer * @return Reference to __os. */ template Os &operator<<(Os &__os, __uint128_t __x) { if (!__x) return __os << '0'; char __s[40], *__p = __s; while (__x) *__p++ = '0' + __x % 10, __x /= 10; *__p = 0; for (char *__t = __s; __t < --__p; ++__t) *__t ^= *__p ^= *__t ^= *__p; return __os << __s; } #endif } // namespace workspace #line 9 "Library/lib/utils" // #include "src/utils/io/read.hpp" #line 2 "Library/src/utils/io/setup.hpp" /* * @file setup.hpp * @brief I/O Setup */ #line 10 "Library/src/utils/io/setup.hpp" namespace workspace { /* * @fn io_setup * @brief Setup I/O. * @param precision Standard output precision */ void io_setup(int precision) { std::ios::sync_with_stdio(false); std::cin.tie(nullptr); std::cout << std::fixed << std::setprecision(precision); #ifdef _buffer_check atexit([] { char bufc; if (std::cin >> bufc) std::cerr << "\n\033[43m\033[30mwarning: buffer not empty.\033[0m\n\n"; }); #endif } } // namespace workspace #line 2 "Library/src/utils/iterator/category.hpp" /* * @file category.hpp * @brief Iterator Category */ #line 10 "Library/src/utils/iterator/category.hpp" namespace workspace { /* * @tparam Tuple Tuple of iterator types */ template ::value - 1> struct common_iterator_category { using type = typename std::common_type< typename common_iterator_category::type, typename std::iterator_traits::type>::iterator_category>::type; }; template struct common_iterator_category { using type = typename std::iterator_traits< typename std::tuple_element<0, Tuple>::type>::iterator_category; }; } // namespace workspace #line 12 "Library/lib/utils" // #include "src/utils/iterator/reverse.hpp" #line 2 "Library/src/utils/make_vector.hpp" /* * @file make_vector.hpp * @brief Multi-dimensional Vector */ #if __cplusplus >= 201703L #include #include namespace workspace { /* * @brief Make a multi-dimensional vector. * @tparam Tp type of the elements * @tparam N dimension * @tparam S integer type * @param sizes The size of each dimension * @param init The initial value */ template constexpr auto make_vector([[maybe_unused]] S *sizes, Tp const &init = Tp()) { static_assert(std::is_convertible_v); if constexpr (N) return std::vector(*sizes, make_vector(std::next(sizes), init)); else return init; } /* * @brief Make a multi-dimensional vector. * @param sizes The size of each dimension * @param init The initial value */ template constexpr auto make_vector(const S (&sizes)[N], Tp const &init = Tp()) { return make_vector((S *)sizes, init); } /* * @brief Make a multi-dimensional vector. * @param sizes The size of each dimension * @param init The initial value */ template constexpr auto make_vector([[maybe_unused]] std::array const &sizes, Tp const &init = Tp()) { static_assert(std::is_convertible_v); if constexpr (I == N) return init; else return std::vector(sizes[I], make_vector(sizes, init)); } /* * @brief Make a multi-dimensional vector. * @param sizes The size of each dimension * @param init The initial value */ template constexpr auto make_vector([[maybe_unused]] std::tuple const &sizes, Tp const &init = Tp()) { using tuple_type = std::tuple; if constexpr (I == std::tuple_size_v || I == N) return init; else { static_assert( std::is_convertible_v, size_t>); return std::vector(std::get(sizes), make_vector(sizes, init)); } } /* * @brief Make a multi-dimensional vector. * @param sizes The size of each dimension * @param init The initial value */ template constexpr auto make_vector(std::pair const &sizes, Tp const &init = Tp()) { static_assert(std::is_convertible_v); static_assert(std::is_convertible_v); return make_vector({(size_t)sizes.first, (size_t)sizes.second}, init); } } // namespace workspace #endif #line 2 "Library/src/utils/py-like/enumerate.hpp" /* * @file enumerate.hpp * @brief Enumerate */ #line 2 "Library/src/utils/py-like/range.hpp" /** * @file range.hpp * @brief Range */ #line 9 "Library/src/utils/py-like/range.hpp" #line 2 "Library/src/utils/iterator/reverse.hpp" /* * @file reverse_iterator.hpp * @brief Reverse Iterator */ #if __cplusplus >= 201703L #include #include namespace workspace { /* * @class reverse_iterator * @brief Wrapper class for `std::reverse_iterator`. * @see http://gcc.gnu.org/PR51823 */ template class reverse_iterator : public std::reverse_iterator { using base_std = std::reverse_iterator; std::optional deref; public: using base_std::reverse_iterator; constexpr typename base_std::reference operator*() noexcept { if (!deref) { Iterator tmp = base_std::current; deref = *--tmp; } return deref.value(); } constexpr reverse_iterator &operator++() noexcept { base_std::operator++(); deref.reset(); return *this; } constexpr reverse_iterator &operator--() noexcept { base_std::operator++(); deref.reset(); return *this; } constexpr reverse_iterator operator++(int) noexcept { base_std::operator++(); deref.reset(); return *this; } constexpr reverse_iterator operator--(int) noexcept { base_std::operator++(); deref.reset(); return *this; } }; } // namespace workspace #endif #line 2 "Library/src/utils/py-like/reversed.hpp" /** * @file reversed.hpp * @brief Reversed */ #include #line 10 "Library/src/utils/py-like/reversed.hpp" namespace workspace { namespace internal { template class reversed { Container cont; public: constexpr reversed(Container &&cont) : cont(cont) {} constexpr auto begin() { return std::rbegin(cont); } constexpr auto end() { return std::rend(cont); } }; } // namespace internal template constexpr auto reversed(Container &&cont) noexcept { return internal::reversed{std::forward(cont)}; } template constexpr auto reversed(std::initializer_list &&cont) noexcept { return internal::reversed>{ std::forward>(cont)}; } } // namespace workspace #line 12 "Library/src/utils/py-like/range.hpp" #if __cplusplus >= 201703L namespace workspace { template class range { Index first, last; public: class iterator { Index current; public: using difference_type = std::ptrdiff_t; using value_type = Index; using reference = typename std::add_const::type &; using pointer = iterator; using iterator_category = std::bidirectional_iterator_tag; constexpr iterator(Index const &__i = Index()) noexcept : current(__i) {} constexpr bool operator==(iterator const &rhs) const noexcept { return current == rhs.current; } constexpr bool operator!=(iterator const &rhs) const noexcept { return current != rhs.current; } constexpr iterator &operator++() noexcept { ++current; return *this; } constexpr iterator &operator--() noexcept { --current; return *this; } constexpr reference operator*() const noexcept { return current; } }; constexpr range(Index first, Index last) noexcept : first(first), last(last) {} constexpr range(Index last) noexcept : first(), last(last) {} constexpr iterator begin() const noexcept { return iterator{first}; } constexpr iterator end() const noexcept { return iterator{last}; } constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator(end()); } constexpr reverse_iterator rend() const noexcept { return reverse_iterator(begin()); } }; template constexpr auto rrange(Args &&... args) noexcept { return internal::reversed(range(std::forward(args)...)); } } // namespace workspace #endif #line 2 "Library/src/utils/py-like/zip.hpp" /** * @file zip.hpp * @brief Zip */ #line 11 "Library/src/utils/py-like/zip.hpp" #line 14 "Library/src/utils/py-like/zip.hpp" #if __cplusplus >= 201703L namespace workspace { namespace internal { template struct zipped_iterator; template struct zipped_iterator_tuple; template class zipped { using ref_tuple = std::tuple; ref_tuple args; template constexpr auto begin_cat() const noexcept { if constexpr (N != std::tuple_size::value) { return std::tuple_cat(std::tuple(std::begin(std::get(args))), begin_cat()); } else return std::tuple<>(); } template constexpr auto end_cat() const noexcept { if constexpr (N != std::tuple_size::value) { return std::tuple_cat(std::tuple(std::end(std::get(args))), end_cat()); } else return std::tuple<>(); } public: constexpr zipped(Args &&... args) noexcept : args(args...) {} class iterator { using base_tuple = typename zipped_iterator_tuple::type; public: using iterator_category = typename common_iterator_category::type; using difference_type = std::ptrdiff_t; using value_type = zipped_iterator; using reference = zipped_iterator &; using pointer = iterator; protected: value_type current; template constexpr bool equal(const iterator &rhs) const noexcept { if constexpr (N != std::tuple_size::value) { return std::get(current) == std::get(rhs.current) || equal(rhs); } else return false; } template constexpr void increment() noexcept { if constexpr (N != std::tuple_size::value) { ++std::get(current); increment(); } } template constexpr void decrement() noexcept { if constexpr (N != std::tuple_size::value) { --std::get(current); decrement(); } } template constexpr void advance(difference_type __d) noexcept { if constexpr (N != std::tuple_size::value) { std::get(current) += __d; advance(__d); } } public: constexpr iterator() noexcept = default; constexpr iterator(base_tuple const ¤t) noexcept : current(current) {} constexpr bool operator==(const iterator &rhs) const noexcept { return equal(rhs); } constexpr bool operator!=(const iterator &rhs) const noexcept { return !equal(rhs); } constexpr iterator &operator++() noexcept { increment(); return *this; } constexpr iterator &operator--() noexcept { decrement(); return *this; } constexpr bool operator<(const iterator &rhs) const noexcept { return std::get<0>(current) < std::get<0>(rhs.current); } constexpr bool operator<=(const iterator &rhs) const noexcept { return std::get<0>(current) <= std::get<0>(rhs.current); } constexpr iterator &operator+=(difference_type __d) noexcept { advance(__d); return *this; } constexpr iterator &operator-=(difference_type __d) noexcept { advance(-__d); return *this; } constexpr iterator operator+(difference_type __d) const noexcept { return iterator{*this} += __d; } constexpr iterator operator-(difference_type __d) const noexcept { return iterator{*this} -= __d; } constexpr difference_type operator-(const iterator &rhs) const noexcept { return std::get<0>(current) - std::get<0>(rhs.current); } constexpr reference operator*() noexcept { return current; } }; constexpr iterator begin() const noexcept { return iterator{begin_cat()}; } constexpr iterator end() const noexcept { return iterator{end_cat()}; } constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator{end()}; } constexpr reverse_iterator rend() const noexcept { return reverse_iterator{begin()}; } }; template struct zipped_iterator_tuple { using type = decltype(std::tuple_cat( std::declval()))>>(), std::declval::type>())); }; template <> struct zipped_iterator_tuple<> { using type = std::tuple<>; }; template struct zipped_iterator : Iter_tuple { constexpr zipped_iterator(Iter_tuple const &__t) noexcept : Iter_tuple::tuple(__t) {} constexpr zipped_iterator(zipped_iterator const &__t) = default; constexpr zipped_iterator &operator=(zipped_iterator const &__t) = default; // Avoid move initialization. constexpr zipped_iterator(zipped_iterator &&__t) : zipped_iterator(static_cast(__t)) {} // Avoid move assignment. zipped_iterator &operator=(zipped_iterator &&__t) { return operator=(static_cast(__t)); } template friend constexpr auto &get(zipped_iterator const &__z) noexcept { return *std::get(__z); } template friend constexpr auto get(zipped_iterator &&__z) noexcept { return *std::get(__z); } }; } // namespace internal } // namespace workspace namespace std { template struct tuple_element> { using type = typename remove_reference::type>::reference>::type; }; template struct tuple_size> : tuple_size {}; } // namespace std namespace workspace { template constexpr auto zip(Args &&... args) noexcept { return internal::zipped(std::forward(args)...); } template constexpr auto zip(std::initializer_list const &... args) noexcept { return internal::zipped...>(args...); } } // namespace workspace #endif #line 10 "Library/src/utils/py-like/enumerate.hpp" #if __cplusplus >= 201703L namespace workspace { constexpr size_t min_size() noexcept { return SIZE_MAX; } template constexpr size_t min_size(Container const &cont, Args &&... args) noexcept { return std::min(std::size(cont), min_size(std::forward(args)...)); } template constexpr auto enumerate(Args &&... args) noexcept { return zip(range(min_size(args...)), std::forward(args)...); } template constexpr auto enumerate(std::initializer_list const &... args) noexcept { return zip(range(min_size(args...)), std::vector(args)...); } } // namespace workspace #endif #line 16 "Library/lib/utils" // #include "src/utils/py-like/reversed.hpp" #line 18 "Library/lib/utils" // #include "src/utils/rand/rng.hpp" // #include "src/utils/rand/shuffle.hpp" // #include "src/utils/round_div.hpp" // #include "src/utils/sfinae.hpp" #line 12 "atcoder-workspace/a.cc" signed main() { using namespace workspace; io_setup(15); /* given case_info.read(); //*/ /* unspecified case_info.total = -1; //*/ return case_info.iterate(); } #line 2 "Library/src/data_structure/segment_tree/basic.hpp" /** * @file basic.hpp * @brief Segment Tree */ #line 10 "Library/src/data_structure/segment_tree/basic.hpp" #if __cplusplus >= 201703L #include #endif #line 2 "Library/src/algebra/system/monoid.hpp" /* * @file monoid.hpp * @brief Monoid */ #line 9 "Library/src/algebra/system/monoid.hpp" namespace workspace { template struct min_monoid { using value_type = T; static T min, max; T value; min_monoid() : value(max) {} min_monoid(const T &value) : value(value) {} operator T() const { return value; } min_monoid operator+(const min_monoid &rhs) const { return value < rhs.value ? *this : rhs; } min_monoid operator*(const E &rhs) const; }; template T min_monoid::min = std::numeric_limits::min() / 2; template T min_monoid::max = std::numeric_limits::max() / 2; template struct max_monoid : min_monoid { using base = min_monoid; using base::min_monoid; max_monoid() : base(base::min) {} max_monoid operator+(const max_monoid &rhs) const { return !(base::value < rhs.value) ? *this : rhs; } max_monoid operator*(const E &rhs) const; }; } // namespace workspace #line 16 "Library/src/data_structure/segment_tree/basic.hpp" namespace workspace { namespace segtree_impl { template class Container_tmpl = std::vector> struct base { static_assert(std::is_same() + std::declval())>::value, "\'Monoid\' has no proper binary \'operator+\'."); using container_type = Container_tmpl; using size_type = typename container_type::size_type; class iterator { base *__p; size_type __i; public: using difference_type = typename std::make_signed::type; using value_type = Monoid; using reference = Monoid &; using pointer = iterator; using iterator_category = std::random_access_iterator_tag; /** * @brief Construct a new iterator object * */ iterator() = default; /** * @brief Construct a new iterator object * * @param __p Pointer to a segment tree object * @param __i Index */ iterator(base *__p, size_type __i) : __p(__p), __i(__i) {} bool operator==(iterator const &rhs) const { return __p == rhs.__p && __i == rhs.__i; } bool operator!=(iterator const &rhs) const { return !operator==(rhs); } bool operator<(iterator const &rhs) const { return __i < rhs.__i; } bool operator>(iterator const &rhs) const { return __i > rhs.__i; } bool operator<=(iterator const &rhs) const { return __i <= rhs.__i; } bool operator>=(iterator const &rhs) const { return __i >= rhs.__i; } iterator &operator++() { return ++__i, *this; } iterator &operator--() { return --__i, *this; } difference_type operator-(iterator const &rhs) const { return __i - rhs.__i; } /** * @brief * * @return reference */ reference operator*() const { return __p->operator[](__i); } }; iterator begin() { return {this, 0}; } iterator end() { return {this, size_orig}; } auto rbegin() { return std::make_reverse_iterator(end()); } auto rend() { return std::make_reverse_iterator(begin()); } using value_type = typename iterator::value_type; using reference = typename iterator::reference; /** * @brief Construct a new segment tree object * * @param __n Number of elements. */ base(size_type __n = 0) : size_orig{__n}, height(__n > 1 ? 64 - __builtin_clzll(__n - 1) : 0), size_ext{size_type{1} << height} { if constexpr (std::is_constructible::value) data = container_type(size_ext << 1); data[0].reset(); } /** * @brief Construct a new segment tree object * * @tparam Tp * @param __n Number of elements. * @param init */ template ::value>::type * = nullptr> base(size_type __n, Tp const &init) : base(__n) { for (auto i = begin(); i != end(); ++i) *i = init; } /** * @brief Construct a new segment tree object * * @tparam Iterator * @param __first * @param __last */ template ::value_type, Monoid>::value> * = nullptr> base(Iterator __first, Iterator __last) : base(std::distance(__first, __last)) { for (auto i = begin(); __first != __last; ++i, ++__first) *i = *__first; } /** * @return Number of elements. */ size_type size() const { return size_orig; } /** * @param __i Index of the element * @return Reference to the element. */ virtual reference operator[](size_type __i) { assert(__i < size_orig); reference __ref = *data[__i |= size_ext]; while (data[__i >>= 1]) data[__i].reset(); return __ref; } /** * @param first Left end, inclusive * @param last Right end, exclusive * @return Sum of elements in the interval. */ value_type fold(size_type first, size_type last) { assert(last <= size_orig); if (!(first < last)) return {}; first += size_ext, last += size_ext; if constexpr (lazy_tag) for (auto __i{height}, __fp{first}, __lp{last - 1}; __i; --__i) push(__fp >> __i), push(__lp >> __i); Monoid left{}, right{}; while (first < last) { if (first & 1) left = left + *pull(first++); if (last & 1) right = *pull(--last) + right; first >>= 1, last >>= 1; // if constexpr (lazy_tag) { // if (auto const &__z = data[__fp >>= 1].__z) left = left * *__z; // if (auto const &__z = data[__lp >>= 1].__z) right = right * *__z; // } } // if constexpr (lazy_tag) // while (__fp >>= 1, __lp >>= 1) { // if (auto const &__z = data[__fp].__z) left = left * *__z; // if (auto const &__z = data[__lp].__z) right = right * *__z; // } return left + right; } /** * @return The whole sum. */ value_type fold() { return fold(0, size_orig); } /** * @brief Binary search for the partition point. * @param right Right fixed end of the interval, exclusive * @param pred Predicate in the form of either 'bool(Monoid)' or 'bool(Monoid, * size_type)' * @return Left end of the extremal interval satisfying the condition, * inclusive. */ template size_type left_partition(size_type right, Pred pred) { assert(right <= size_orig); right += size_ext; Monoid mono{}; if constexpr (lazy_tag) for (size_t i{height}; i; --i) push(right >> i); for (size_type left{size_ext}, step{}; left != right; left >>= 1, right >>= 1, ++step) { if ((left & 1) != (right & 1)) { const Monoid tmp = *pull(--right) + mono; if (!pass_args(pred, tmp, (right << step) ^ size_ext)) return left_partition_subtree(right, mono, step, pred); mono = tmp; } } return 0; } /** * @brief Binary search for the partition point. * @param left Left fixed end of the interval, inclusive * @param pred Predicate in the form of either 'bool(Monoid)' or 'bool(Monoid, * size_type)' * @return Right end of the extremal interval satisfying the condition, * exclusive. */ template size_type right_partition(size_type left, Pred pred) { assert(left <= size_orig); left += size_ext; Monoid mono{}; if constexpr (lazy_tag) for (size_t i{height}; i; --i) push(left >> i); for (size_type right{size_ext << 1}, step{}; left != right; left >>= 1, right >>= 1, ++step) { if ((left & 1) != (right & 1)) { const Monoid tmp = mono + *pull(left); if (!pass_args(pred, tmp, ((left + 1) << step) ^ size_ext)) return right_partition_subtree(left, mono, step, pred); mono = tmp; ++left; } } return size_orig; } protected: constexpr static bool lazy_tag = Node::lazy_tag; size_type size_orig, height, size_ext; container_type data; virtual void push(size_type) noexcept {} Node &pull(size_type __i) noexcept { if (!data[__i]) data[__i] = *pull(__i << 1) + *pull(__i << 1 | 1); return data[__i]; } template size_type left_partition_subtree(size_type __i, Monoid mono, size_type step, Pred pred) { assert(__i); while (__i < size_ext) { if constexpr (lazy_tag) push(__i); const Monoid tmp = *pull((__i <<= 1) | 1) + mono; if (pass_args(pred, tmp, ((__i | 1) << --step) ^ size_ext)) mono = tmp; else ++__i; } return ++__i -= size_ext; } template size_type right_partition_subtree(size_type __i, Monoid mono, size_type step, Pred pred) { assert(__i); while (__i < size_ext) { if constexpr (lazy_tag) push(__i); const Monoid tmp = mono + *pull(__i <<= 1); if (pass_args(pred, tmp, ((__i | 1) << --step) ^ size_ext)) ++__i, mono = tmp; } return (__i -= size_ext) < size_orig ? __i : size_orig; } template constexpr decltype(std::declval()(Monoid{})) pass_args( Pred pred, Monoid const &_1, [[maybe_unused]] size_type _2) { return pred(_1); } template constexpr decltype(std::declval()(Monoid{}, size_type{})) pass_args( Pred pred, Monoid const &_1, size_type _2) { return pred(_1, _2); } }; #if __cplusplus < 201703L template struct node { constexpr static bool lazy_tag = false; node() = default; node(Tp const &__x) : __v(__x) {} operator bool() const { return __f; } void operator=(Tp const &__x) { __v = __x; __f = true; } Tp &operator*() { return __v; } Tp const &operator*() const { return __v; } void reset() { __f = false; } private: Tp __v{}; bool __f{true}; }; template struct lazy_node : node { constexpr static bool lazy_tag = true; node __z; }; #else template struct node : std::optional { constexpr static bool lazy_tag = false; using std::optional::operator=; node() : std::optional(Tp{}) {} }; template struct lazy_node : node { constexpr static bool lazy_tag = true; using node::operator=; std::optional __z; }; #endif template class Container_tmpl = std::vector> struct [[deprecated]] lazy : base, Container_tmpl> { using _base = base, Container_tmpl>; using size_type = typename _base::size_type; using _base::base; void update(size_type first, size_type last, Endomorphism const &endo) { assert(last <= _base::size_orig); if (first >= last) return; first += _base::size_ext, last += _base::size_ext - 1; for (auto i = _base::height; i; --i) push(first >> i), push(last >> i); for (auto l = first, r = last + 1;; l >>= 1, r >>= 1) { if (l < r) { if (l & 1) apply_top(l++, endo); if (r & 1) apply_top(--r, endo); } if (first >>= 1, last >>= 1) { // _base::data[first].reset(); // _base::data[last].reset(); pull_f(first); pull_f(last); } else break; } } protected: void pull_f(size_type __i) { _base::data[__i] = *_base::pull(__i << 1) + *_base::pull(__i << 1 | 1); } void push(size_type __i) noexcept override { if (auto &__lz = _base::data[__i].__z) { apply(__i <<= 1, *__lz); apply(__i |= 1, *__lz); __lz.reset(); } } void apply(size_type __i, Endomorphism const &__e) noexcept { auto &__nd = _base::data[__i]; *__nd = *__nd * __e; if (__i < _base::size_ext) __nd.__z = __nd.__z ? *__nd.__z * __e : __e; } void apply_top(size_type __i, Endomorphism const &__e) noexcept { auto &__nd = _base::pull(__i); *__nd = *__nd * __e; if (__i < _base::size_ext) __nd.__z = __nd.__z ? *__nd.__z * __e : __e; } }; } // namespace segtree_impl template class Container_tmpl = std::vector> using _segment_tree = typename std::conditional< std::is_void::value, segtree_impl::base, Container_tmpl>, segtree_impl::lazy>::type; /** * @tparam Monoid `operator+`, `operator=` * @tparam Container_tmpl `operator[]`, `size_type` */ template class Container_tmpl = std::vector> class segment_tree { static_assert(std::is_same() + std::declval())>::value, "\'Monoid\' has no proper binary \'operator+\'."); constexpr static bool __support_lazy = !std::is_void::value; #if __cplusplus < 201703L struct node_base { node_base() = default; node_base(Monoid const &__x) : __v(__x) {} operator bool() const { return __f; } void operator=(Monoid const &__x) { __v = __x; __f = true; } Monoid &operator*() { return __v; } Monoid const &operator*() const { return __v; } void reset() { __f = false; } private: Monoid __v{}; bool __f{true}; }; #else struct node_base : std::optional { using std::optional::operator=; node_base() : std::optional(Monoid{}) {} }; #endif struct node_lazy : node_base { using node_base::operator=; std::optional __z; }; using node = typename std::conditional<__support_lazy, node_lazy, node_base>::type; using container_type = Container_tmpl; public: using size_type = typename container_type::size_type; class iterator { segment_tree *__p; size_type __i; public: using difference_type = typename std::make_signed::type; using value_type = Monoid; using reference = Monoid &; using pointer = iterator; using iterator_category = std::random_access_iterator_tag; /** * @brief Construct a new iterator object * */ iterator() = default; /** * @brief Construct a new iterator object * * @param __p Pointer to a segment tree object * @param __i Index */ iterator(segment_tree *__p, size_type __i) : __p(__p), __i(__i) {} bool operator==(iterator const &rhs) const { return __p == rhs.__p && __i == rhs.__i; } bool operator!=(iterator const &rhs) const { return !operator==(rhs); } bool operator<(iterator const &rhs) const { return __i < rhs.__i; } bool operator>(iterator const &rhs) const { return __i > rhs.__i; } bool operator<=(iterator const &rhs) const { return __i <= rhs.__i; } bool operator>=(iterator const &rhs) const { return __i >= rhs.__i; } iterator &operator++() { return ++__i, *this; } iterator &operator--() { return --__i, *this; } difference_type operator-(iterator const &rhs) const { return __i - rhs.__i; } /** * @brief * * @return reference */ reference operator*() const { return __p->operator[](__i); } }; using value_type = typename iterator::value_type; using reference = typename iterator::reference; iterator begin() { return {this, 0}; } iterator end() { return {this, size_orig}; } auto rbegin() { return std::make_reverse_iterator(end()); } auto rend() { return std::make_reverse_iterator(begin()); } protected: size_type size_orig, height, size_ext; container_type data; node &pull(size_type __i) noexcept { if (!data[__i]) data[__i] = *pull(__i << 1) + *pull(__i << 1 | 1); return data[__i]; } void push(size_type __i) { if (auto &__lz = data[__i].__z) { apply(data[__i << 1], *__lz); apply(data[__i << 1 | 1], *__lz); __lz.reset(); } } void sync(size_type __i) { if (!data[__i]) data[__i] = *pull(__i << 1) + *pull(__i << 1 | 1); else if (data[__i].__z) { apply(data[__i << 1], *data[__i].__z); apply(data[__i << 1 | 1], *data[__i].__z); data[__i].__z.reset(); } } template void apply(node &__nd, _End const &endo) { *__nd = *__nd * endo; __nd.__z = __nd.__z ? *__nd.__z * endo : endo; } // template // void apply_top(size_t __i, _End const &endo) { // auto &__nd = pull(__i); // *__nd = *__nd * endo; // __nd.__z = __nd.__z ? *__nd.__z * endo : endo; // } template constexpr decltype(std::declval()(Monoid{})) pass_args( Pred pred, Monoid const &_1, [[maybe_unused]] size_type _2) { return pred(_1); } template constexpr decltype(std::declval()(Monoid{}, size_type{})) pass_args( Pred pred, Monoid const &_1, size_type _2) { return pred(_1, _2); } template size_type left_partition_subtree(size_type __i, Monoid mono, size_type step, Pred pred) { assert(__i); while (__i < size_ext) { if constexpr (__support_lazy) push(__i); const Monoid tmp = *pull((__i <<= 1) | 1) + mono; if (pass_args(pred, tmp, ((__i | 1) << --step) ^ size_ext)) mono = tmp; else ++__i; } return ++__i -= size_ext; } template size_type right_partition_subtree(size_type __i, Monoid mono, size_type step, Pred pred) { assert(__i); while (__i < size_ext) { if constexpr (__support_lazy) push(__i); const Monoid tmp = mono + *pull(__i <<= 1); if (pass_args(pred, tmp, ((__i | 1) << --step) ^ size_ext)) ++__i, mono = tmp; } return (__i -= size_ext) < size_orig ? __i : size_orig; } public: /** * @brief Construct a new segment tree object * * @param __n Number of elements. */ segment_tree(size_type __n = 0) : size_orig{__n}, height(__n > 1 ? 64 - __builtin_clzll(__n - 1) : 0), size_ext{size_type{1} << height} { if constexpr (std::is_constructible::value) data = container_type(size_ext << 1); data[0].reset(); } /** * @brief Construct a new segment tree object * * @param __n Number of elements. * @param init */ segment_tree(size_type __n, Monoid const &init) : segment_tree(__n) { for (auto i = begin(); i != end(); ++i) *i = init; } /** * @brief Construct a new segment tree object * * @tparam Tp * @param __n Number of elements. * @param init */ template ::value>::type * = nullptr> segment_tree(size_type __n, Tp &&init) : segment_tree(__n) { for (auto i = begin(); i != end(); ++i) *i = init; } /** * @brief Construct a new segment tree object * * @tparam Iterator * @param __first * @param __last */ template ::value_type, Monoid>::value> * = nullptr> segment_tree(Iterator __first, Iterator __last) : segment_tree(std::distance(__first, __last)) { for (auto i = begin(); __first != __last; ++i, ++__first) *i = *__first; } operator Container_tmpl() const { Container_tmpl __c(size()); for (size_type __i = 0; __i != size(); ++__i) __c[__i] = *data[__i | size_ext]; return __c; } /** * @return Number of elements. */ size_type size() const { return size_orig; } /** * @param __i Index of the element * @return Reference to the element. */ reference operator[](size_type __i) { assert(__i < size_orig); reference __ref = *data[__i |= size_ext]; if constexpr (__support_lazy) { for (size_t __h{height}; __h; --__h) { push(__i >> __h); data[__i >> __h].reset(); } } else { while (data[__i >>= 1]) data[__i].reset(); } return __ref; } /** * @param first Left end, inclusive * @param last Right end, exclusive * @return Sum of elements in the interval. */ value_type fold(size_type first, size_type last) { assert(last <= size_orig); if (!(first < last)) return {}; first += size_ext, last += size_ext; value_type left{}, right{}; for (size_t l = first, r = last--; l != r; l >>= 1, r >>= 1) { if (l & 1) left = left + *pull(l++); if (r & 1) right = *pull(--r) + right; if constexpr (__support_lazy) { if (data[first >>= 1].__z) left = left * *data[first].__z; if (data[last >>= 1].__z) right = right * *data[last].__z; } } if constexpr (__support_lazy) { while (first >>= 1, last >>= 1) { if (data[first].__z) left = left * *data[first].__z; if (data[last].__z) right = right * *data[last].__z; } } // if (first >= last) return Monoid{}; // first += size_ext, last += size_ext - 1; // Monoid left{}, right{}; // for (size_t l = first, r = last + 1; last; l >>= 1, r >>= 1) { // if (l < r) { // if (l & 1) left = left + data[l++]; // if (r & 1) right = data[--r] + right; // } // if (first >>= 1, last >>= 1) { // left = left * lazy[first]; // right = right * lazy[last]; // } // } // return left + right; return left + right; } /** * @return The whole sum. */ value_type fold() { return fold(0, size_orig); } template void update(size_type first, size_type last, _End const &endo) { static_assert(__support_lazy); assert(last <= size_orig); if (!(first < last)) return; first += size_ext, last += size_ext; --last; for (auto i = height; i; --i) push(first >> i), push(last >> i); ++last; for (auto l = first, r = last; l < r; l >>= 1, r >>= 1) { if (l & 1) apply(pull(l++), endo); if (r & 1) apply(pull(--r), endo); } for (first >>= __builtin_ffs(first); data[first]; first >>= 1) data[first].reset(); for (last >>= __builtin_ffs(last); data[last]; last >>= 1) data[last].reset(); } /** * @brief Binary search for the partition point. * @param right Right fixed end of the interval, exclusive * @param pred Predicate in the form of either 'bool(Monoid)' or 'bool(Monoid, * size_type)' * @return Left end of the extremal interval satisfying the condition, * inclusive. */ template size_type left_partition(size_type right, Pred pred) { assert(right <= size_orig); right += size_ext; if constexpr (__support_lazy) for (size_t i{height}; i; --i) push(right >> i); Monoid mono{}; for (size_type left{size_ext}, step{}; left != right; left >>= 1, right >>= 1, ++step) { if ((left & 1) != (right & 1)) { Monoid tmp = *pull(--right) + mono; if (!pass_args(pred, tmp, (right << step) ^ size_ext)) return left_partition_subtree(right, mono, step, pred); mono = tmp; } } return 0; } /** * @brief Binary search for the partition point. * @param left Left fixed end of the interval, inclusive * @param pred Predicate in the form of either 'bool(Monoid)' or 'bool(Monoid, * size_type)' * @return Right end of the extremal interval satisfying the condition, * exclusive. */ template size_type right_partition(size_type left, Pred pred) { assert(left <= size_orig); left += size_ext; if constexpr (__support_lazy) for (size_t i{height}; i; --i) push(left >> i); Monoid mono{}; for (size_type right{size_ext << 1}, step{}; left != right; left >>= 1, right >>= 1, ++step) { if ((left & 1) != (right & 1)) { Monoid tmp = mono + *pull(left); if (!pass_args(pred, tmp, ((left + 1) << step) ^ size_ext)) return right_partition_subtree(left, mono, step, pred); mono = tmp; ++left; } } return size_orig; } }; } // namespace workspace #line 28 "atcoder-workspace/a.cc" namespace workspace { void main() { // start here! int n; cin >> n; vector a(n); cin >> a; for (auto &&x : a) { --x; } if (a[n - 2] < a[n - 1]) a.push_back(-1); else a.push_back(n); if (a[0] < a[1]) a.insert(a.begin(), n); else a.insert(a.begin(), -1); i64 ans = 0; vector> v, m; for (auto i : range(1, n + 1)) { if (a[i] > a[i + 1]) m.emplace_back(a[i], max(a[i - 1], a[i + 1])); else v.emplace_back(a[i], min(a[i - 1], a[i + 1])); } sort(begin(v), end(v)); sort(begin(m), end(m), [](auto p1, auto p2) { return p1.second < p2.second; }); auto iter = m.begin(); segment_tree s(n); for (auto &&[x, y] : v) { while (iter != m.end() && iter->second < x) { ++s[iter->first]; ++iter; } ans += s.fold(0, y); } for (auto &&[x, y] : m) { x = n - 1 - x; y = n - 1 - y; } i64 ans2{}; for (auto _ : range(2)) { s = segment_tree(n); v.swap(m); auto v2 = v; sort(rbegin(v), rend(v)); sort(rbegin(v2), rend(v2), [](auto p1, auto p2) { return p1.second < p2.second; }); auto iter = v2.begin(); for (auto &&[x, y] : v) { while (iter != v2.end() && iter->second > x) { s[iter->first]++; ++iter; } ans2 += s.fold(0, y); } } ans += (ans2 - n) / 2; cout << ans << "\n"; } // namespace workspace } // namespace workspace