#pragma region preprocessor #ifdef LOCAL //* #define _GLIBCXX_DEBUG // gcc /*/ #define _LIBCPP_DEBUG 0 // clang //*/ // #define __buffer_check__ #else #pragma GCC optimize("Ofast") // #define NDEBUG #endif #define __precision__ 15 #define __iostream_untie__ true #include #include #ifdef LOCAL #include "dump.hpp" #define mesg(str) std::cerr << "[ " << __LINE__ << " : " << __FUNCTION__ << " ] " << str << "\n" #else #define dump(...) ((void)0) #define mesg(str) ((void)0) #endif #pragma endregion #pragma region std-overload namespace std { // hash template size_t hash_combine(size_t seed, T const &key) { return seed ^ (hash()(key) + 0x9e3779b9 + (seed << 6) + (seed >> 2)); } template struct hash> { size_t operator()(pair const &pr) const { return hash_combine(hash_combine(0, pr.first), pr.second); } }; template ::value - 1> struct tuple_hash_calc { static size_t apply(size_t seed, tuple_t const &t) { return hash_combine(tuple_hash_calc::apply(seed, t), get(t)); } }; template struct tuple_hash_calc { static size_t apply(size_t seed, tuple_t const &t) { return hash_combine(seed, get<0>(t)); } }; template struct hash> { size_t operator()(tuple const &t) const { return tuple_hash_calc>::apply(0, t); } }; // iostream template istream &operator>>(istream &is, pair &p) { return is >> p.first >> p.second; } template ostream &operator<<(ostream &os, const pair &p) { return os << p.first << ' ' << p.second; } template struct tupleis { static istream &apply(istream &is, tuple_t &t) { tupleis::apply(is, t); return is >> get(t); } }; template struct tupleis { static istream &apply(istream &is, tuple_t &t) { return is; } }; template istream &operator>>(istream &is, tuple &t) { return tupleis, tuple_size>::value - 1>::apply(is, t); } template <> istream &operator>>(istream &is, tuple<> &t) { return is; } template struct tupleos { static ostream &apply(ostream &os, const tuple_t &t) { tupleos::apply(os, t); return os << ' ' << get(t); } }; template struct tupleos { static ostream &apply(ostream &os, const tuple_t &t) { return os << get<0>(t); } }; template ostream &operator<<(ostream &os, const tuple &t) { return tupleos, tuple_size>::value - 1>::apply(os, t); } template <> ostream &operator<<(ostream &os, const tuple<> &t) { return os; } template , string>::value, nullptr_t> = nullptr> istream& operator>>(istream& is, Container &cont) { for(auto&& e : cont) is >> e; return is; } template , string>::value, nullptr_t> = nullptr> ostream& operator<<(ostream& os, const Container &cont) { bool flag = 1; for(auto&& e : cont) flag ? flag = 0 : (os << ' ', 0), os << e; return os; } } // namespace std #pragma endregion #pragma region config namespace config { const auto start_time{std::chrono::system_clock::now()}; int64_t elapsed() { using namespace std::chrono; const auto end_time{std::chrono::system_clock::now()}; return duration_cast(end_time - start_time).count(); } __attribute__((constructor)) void setup() { using namespace std; if(__iostream_untie__) ios::sync_with_stdio(false), cin.tie(nullptr); cout << fixed << setprecision(__precision__); #ifdef DEBUG freopen("debug.out","w",stdout); freopen("debug.err","w",stderr); if(!freopen("debug.in","r",stdin)) { cerr << "error: \"./debug.in\" not found.\n"; exit(EXIT_FAILURE); } #endif #ifdef stderr_path freopen(stderr_path, "a", stderr); #endif #ifdef LOCAL cerr << fixed << setprecision(__precision__) << boolalpha << "\n----- stderr at LOCAL -----\n\n"; atexit([]{ cerr << "\n----- Exec time : " << elapsed() << " ms -----\n\n"; }); #endif #ifdef __buffer_check__ atexit([]{ ofstream cnsl("CON"); char bufc; if(cin >> bufc) cnsl << "\n\033[1;35mwarning\033[0m: buffer not empty.\n\n"; }); #endif } } // namespace config #pragma endregion #pragma region utility // lambda wrapper for recursive method. template class fixed_point { lambda_type func; public: fixed_point(lambda_type &&f) : func(std::move(f)) {} template auto operator()(Args &&... args) const { return func(*this, std::forward(args)...); } }; // read with std::cin. template struct read { typename std::remove_const::type value; template read(types... args) : value(args...) { std::cin >> value; } operator T() const { return value; } }; template <> struct read { template operator T() const { T value; std::cin >> value; return value; } }; // substitute y for x if x > y. template inline bool chmin(T &x, const T &y) { return x > y ? x = y, true : false; } // substitute y for x if x < y. template inline bool chmax(T &x, const T &y) { return x < y ? x = y, true : false; } // binary search on discrete range. template iter_type binary(iter_type __ok, iter_type __ng, pred_type pred) { assert(__ok != __ng); std::ptrdiff_t dist(__ng - __ok); while(std::abs(dist) > 1) { iter_type mid(__ok + dist / 2); if(pred(mid)) __ok = mid, dist -= dist / 2; else __ng = mid, dist /= 2; } return __ok; } // binary search on real numbers. template long double binary(long double __ok, long double __ng, const long double eps, pred_type pred) { assert(__ok != __ng); while(std::abs(__ok - __ng) > eps) { long double mid{(__ok + __ng) / 2}; (pred(mid) ? __ok : __ng) = mid; } return __ok; } // trinary search on discrete range. template iter_type trinary(iter_type __first, iter_type __last, comp_type comp) { assert(__first < __last); std::ptrdiff_t dist(__last - __first); while(dist > 2) { iter_type __left(__first + dist / 3), __right(__first + dist * 2 / 3); if(comp(__left, __right)) __last = __right, dist = dist * 2 / 3; else __first = __left, dist -= dist / 3; } if(dist > 1 && comp(next(__first), __first)) ++__first; return __first; } // trinary search on real numbers. template long double trinary(long double __first, long double __last, const long double eps, comp_type comp) { assert(__first < __last); while(__last - __first > eps) { long double __left{(__first * 2 + __last) / 3}, __right{(__first + __last * 2) / 3}; if(comp(__left, __right)) __last = __right; else __first = __left; } return __first; } // size of array. template size_t size(A (&array)[N]) { return N; } // be careful that val is type-sensitive. template void init(A (&array)[N], const T &val) { std::fill((T*)array, (T*)(array + N), val); } #pragma endregion #pragma region alias using namespace std; using i32 = int_least32_t; using i64 = int_least64_t; using u32 = uint_least32_t; using u64 = uint_least64_t; using p32 = pair; using p64 = pair; template > using heap = priority_queue, Comp>; template using hashset = unordered_set; template using hashmap = unordered_map; using namespace __gnu_cxx; #pragma endregion #pragma region library #pragma endregion struct solver; template void main_(); int main() { main_(); } template void main_() { unsigned t = 1; #ifdef LOCAL t = 1; #endif // t = -1; // infinite loop // cin >> t; // case number given while(t--) solver(); } #include template class random_number_generator { template struct unif_t { std::uniform_int_distribution unif; unif_t(num_t lower, num_t upper) : unif(lower, upper) {} num_t operator()(std::mt19937 &engine) { return unif(engine); } }; template struct unif_t { std::uniform_real_distribution unif; unif_t(num_t lower, num_t upper) : unif(lower, upper) {} num_t operator()(std::mt19937 &engine) { return unif(engine); } }; unif_t::value> unif; std::mt19937 engine; public: // generate random number in [lower, upper]. random_number_generator(num_t lower = std::numeric_limits::min(), num_t upper = std::numeric_limits::max()) : unif(lower, upper), engine(std::random_device{}()) {} num_t operator()() { return unif(engine); } }; // class random_number_generator #include #include template class segment_tree { using size_type = typename std::vector::size_type; class unique_queue { size_type *que, *begin, *end; bool *in; public: unique_queue() : que(), begin(), end(), in() {} unique_queue(size_type n) : que(new size_type[n]), begin(que), end(que), in(new bool[n]{}) {} ~unique_queue() { delete[] que; delete[] in; } void clear() { begin = end = que; } bool empty() const { return begin == end; } bool push(size_type index) { if(in[index]) return false; return in[*end++ = index] = true; } size_type pop() { return in[*begin] = false, *begin++; } }; // struct unique_queue size_type size_orig, height, size_ext; std::vector data; unique_queue que; void recalc(const size_type node) { data[node] = data[node << 1] + data[node << 1 | 1]; } void rebuild() { while(!que.empty()) { const size_type index = que.pop() >> 1; if(index && que.push(index)) recalc(index); } que.clear(); } template size_type left_search_subtree(size_type index, const pred_type pred, monoid mono) const { assert(index); while(index < size_ext) { const monoid tmp = data[(index <<= 1) | 1] + mono; if(pred(tmp)) mono = tmp; else ++index; } return ++index -= size_ext; } template size_type right_search_subtree(size_type index, const pred_type pred, monoid mono) const { assert(index); while(index < size_ext) { const monoid tmp = mono + data[index <<= 1]; if(pred(tmp)) ++index, mono = tmp; } return (index -= size_ext) < size_orig ? index : size_orig; } public: segment_tree(const size_type n = 0) : size_orig{n}, height(n > 1 ? 32 - __builtin_clz(n - 1) : 0), size_ext{1u << height}, data(size_ext << 1), que(size_ext << 1) {} segment_tree(const size_type n, const monoid &init) : segment_tree(n) { std::fill(std::next(std::begin(data), size_ext), std::end(data), init); for(size_type i{size_ext}; --i; ) recalc(i); } template ::value_type> segment_tree(iter_type first, iter_type last) : size_orig(std::distance(first, last)), height(size_orig > 1 ? 32 - __builtin_clz(size_orig - 1) : 0), size_ext{1u << height}, data(size_ext << 1), que(size_ext << 1) { static_assert(std::is_constructible::value, "monoid(iter_type::value_type) is not constructible."); for(auto iter{std::next(std::begin(data), size_ext)}; iter != std::end(data) && first != last; ++iter, ++first) *iter = monoid{*first}; for(size_type i{size_ext}; --i; ) recalc(i); } template segment_tree(const container_type &cont) : segment_tree(std::begin(cont), std::end(cont)) {} size_type size() const { return size_orig; } size_type capacity() const { return size_ext; } // reference to the element at the index. typename decltype(data)::reference operator[](size_type index) { assert(index < size_orig); que.push(index |= size_ext); return data[index]; } // const reference to the element at the index. typename decltype(data)::const_reference operator[](size_type index) const { assert(index < size_orig); return data[index |= size_orig]; } monoid fold(size_type first, size_type last) { assert(last <= size_orig); rebuild(); monoid leftval{}, rightval{}; first += size_ext, last += size_ext; while(first < last) { if(first & 1) leftval = leftval + data[first++]; if(last & 1) rightval = data[--last] + rightval; first >>= 1, last >>= 1; } return leftval + rightval; } monoid fold() { return fold(0, size_orig); } template size_type left_search(size_type right, const pred_type pred) { assert(right <= size_orig); rebuild(); right += size_ext; monoid mono{}; for(size_type left{size_ext}; left != right; left >>= 1, right >>= 1) { if((left & 1) != (right & 1)) { const monoid tmp = data[--right] + mono; if(!pred(tmp)) return left_search_subtree(right, pred, mono); mono = tmp; } } return 0; } template size_type right_search(size_type left, const pred_type pred) { assert(left <= size_orig); rebuild(); left += size_ext; monoid mono{}; for(size_type right{size_ext << 1}; left != right; left >>= 1, right >>= 1) { if((left & 1) != (right & 1)) { const monoid tmp = mono + data[left]; if(!pred(tmp)) return right_search_subtree(left, pred, mono); mono = tmp; ++left; } } return size_orig; } }; // class segment_tree struct solver { solver() { struct mono { int val,id; mono(int v=INT_MAX,int id=-1): val(v),id(id) {} mono operator+(const mono& rhs) const { if(val seg(n); for(int i=0; i