結果
問題 | No.2361 Many String Compare Queries |
ユーザー | suisen |
提出日時 | 2023-06-23 23:18:36 |
言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
結果 |
WA
|
実行時間 | - |
コード長 | 30,983 bytes |
コンパイル時間 | 4,602 ms |
コンパイル使用メモリ | 345,372 KB |
実行使用メモリ | 63,352 KB |
最終ジャッジ日時 | 2024-07-01 03:05:42 |
合計ジャッジ時間 | 10,221 ms |
ジャッジサーバーID (参考情報) |
judge3 / judge4 |
(要ログイン)
テストケース
テストケース表示入力 | 結果 | 実行時間 実行使用メモリ |
---|---|---|
testcase_00 | AC | 2 ms
6,816 KB |
testcase_01 | AC | 2 ms
6,812 KB |
testcase_02 | AC | 2 ms
6,944 KB |
testcase_03 | WA | - |
testcase_04 | WA | - |
testcase_05 | WA | - |
testcase_06 | WA | - |
testcase_07 | AC | 2 ms
6,944 KB |
testcase_08 | WA | - |
testcase_09 | WA | - |
testcase_10 | WA | - |
testcase_11 | AC | 488 ms
62,456 KB |
testcase_12 | WA | - |
testcase_13 | WA | - |
testcase_14 | WA | - |
testcase_15 | WA | - |
コンパイルメッセージ
main.cpp: In member function 'int suisen::RangeChMinMaxAddRangeSum<T>::max_right(int)': main.cpp:719:24: warning: expected 'template' keyword before dependent template name [-Wmissing-template-keyword] 719 | return seg.max_right<pred>(l); | ^~~~~~~~~ main.cpp: In member function 'int suisen::RangeChMinMaxAddRangeSum<T>::min_left(int)': main.cpp:727:24: warning: expected 'template' keyword before dependent template name [-Wmissing-template-keyword] 727 | return seg.min_left<pred>(r); | ^~~~~~~~
ソースコード
#include <bits/stdc++.h> #ifdef _MSC_VER # include <intrin.h> #else # include <x86intrin.h> #endif #include <limits> #include <type_traits> namespace suisen { // ! utility template <typename ...Types> using constraints_t = std::enable_if_t<std::conjunction_v<Types...>, std::nullptr_t>; template <bool cond_v, typename Then, typename OrElse> constexpr decltype(auto) constexpr_if(Then&& then, OrElse&& or_else) { if constexpr (cond_v) { return std::forward<Then>(then); } else { return std::forward<OrElse>(or_else); } } // ! function template <typename ReturnType, typename Callable, typename ...Args> using is_same_as_invoke_result = std::is_same<std::invoke_result_t<Callable, Args...>, ReturnType>; template <typename F, typename T> using is_uni_op = is_same_as_invoke_result<T, F, T>; template <typename F, typename T> using is_bin_op = is_same_as_invoke_result<T, F, T, T>; template <typename Comparator, typename T> using is_comparator = std::is_same<std::invoke_result_t<Comparator, T, T>, bool>; // ! integral template <typename T, typename = constraints_t<std::is_integral<T>>> constexpr int bit_num = std::numeric_limits<std::make_unsigned_t<T>>::digits; template <typename T, unsigned int n> struct is_nbit { static constexpr bool value = bit_num<T> == n; }; template <typename T, unsigned int n> static constexpr bool is_nbit_v = is_nbit<T, n>::value; // ? template <typename T> struct safely_multipliable {}; template <> struct safely_multipliable<int> { using type = long long; }; template <> struct safely_multipliable<long long> { using type = __int128_t; }; template <> struct safely_multipliable<unsigned int> { using type = unsigned long long; }; template <> struct safely_multipliable<unsigned long int> { using type = __uint128_t; }; template <> struct safely_multipliable<unsigned long long> { using type = __uint128_t; }; template <> struct safely_multipliable<float> { using type = float; }; template <> struct safely_multipliable<double> { using type = double; }; template <> struct safely_multipliable<long double> { using type = long double; }; template <typename T> using safely_multipliable_t = typename safely_multipliable<T>::type; template <typename T, typename = void> struct rec_value_type { using type = T; }; template <typename T> struct rec_value_type<T, std::void_t<typename T::value_type>> { using type = typename rec_value_type<typename T::value_type>::type; }; template <typename T> using rec_value_type_t = typename rec_value_type<T>::type; } // namespace suisen // ! type aliases using i128 = __int128_t; using u128 = __uint128_t; template <typename T> using pq_greater = std::priority_queue<T, std::vector<T>, std::greater<T>>; // ! macros (internal) #define DETAIL_OVERLOAD2(_1,_2,name,...) name #define DETAIL_OVERLOAD3(_1,_2,_3,name,...) name #define DETAIL_OVERLOAD4(_1,_2,_3,_4,name,...) name #define DETAIL_REP4(i,l,r,s) for(std::remove_reference_t<std::remove_const_t<decltype(r)>>i=(l);i<(r);i+=(s)) #define DETAIL_REP3(i,l,r) DETAIL_REP4(i,l,r,1) #define DETAIL_REP2(i,n) DETAIL_REP3(i,0,n) #define DETAIL_REPINF3(i,l,s) for(std::remove_reference_t<std::remove_const_t<decltype(l)>>i=(l);;i+=(s)) #define DETAIL_REPINF2(i,l) DETAIL_REPINF3(i,l,1) #define DETAIL_REPINF1(i) DETAIL_REPINF2(i,0) #define DETAIL_RREP4(i,l,r,s) for(std::remove_reference_t<std::remove_const_t<decltype(r)>>i=(l)+fld((r)-(l)-1,s)*(s);i>=(l);i-=(s)) #define DETAIL_RREP3(i,l,r) DETAIL_RREP4(i,l,r,1) #define DETAIL_RREP2(i,n) DETAIL_RREP3(i,0,n) #define DETAIL_CAT_I(a, b) a##b #define DETAIL_CAT(a, b) DETAIL_CAT_I(a, b) #define DETAIL_UNIQVAR(tag) DETAIL_CAT(tag, __LINE__) // ! macros #define REP(...) DETAIL_OVERLOAD4(__VA_ARGS__, DETAIL_REP4 , DETAIL_REP3 , DETAIL_REP2 )(__VA_ARGS__) #define RREP(...) DETAIL_OVERLOAD4(__VA_ARGS__, DETAIL_RREP4 , DETAIL_RREP3 , DETAIL_RREP2 )(__VA_ARGS__) #define REPINF(...) DETAIL_OVERLOAD3(__VA_ARGS__, DETAIL_REPINF3, DETAIL_REPINF2, DETAIL_REPINF1)(__VA_ARGS__) #define LOOP(n) for (std::remove_reference_t<std::remove_const_t<decltype(n)>> DETAIL_UNIQVAR(loop_variable) = n; DETAIL_UNIQVAR(loop_variable) --> 0;) #define ALL(iterable) std::begin(iterable), std::end(iterable) #define INPUT(type, ...) type __VA_ARGS__; read(__VA_ARGS__) // ! debug #ifdef LOCAL # define debug(...) debug_internal(#__VA_ARGS__, __VA_ARGS__) template <class T, class... Args> void debug_internal(const char* s, T&& first, Args&&... args) { constexpr const char* prefix = "[\033[32mDEBUG\033[m] "; constexpr const char* open_brakets = sizeof...(args) == 0 ? "" : "("; constexpr const char* close_brakets = sizeof...(args) == 0 ? "" : ")"; std::cerr << prefix << open_brakets << s << close_brakets << ": " << open_brakets << std::forward<T>(first); ((std::cerr << ", " << std::forward<Args>(args)), ...); std::cerr << close_brakets << "\n"; } #else # define debug(...) void(0) #endif // ! I/O utilities // __int128_t std::ostream& operator<<(std::ostream& dest, __int128_t value) { std::ostream::sentry s(dest); if (s) { __uint128_t tmp = value < 0 ? -value : value; char buffer[128]; char* d = std::end(buffer); do { --d; *d = "0123456789"[tmp % 10]; tmp /= 10; } while (tmp != 0); if (value < 0) { --d; *d = '-'; } int len = std::end(buffer) - d; if (dest.rdbuf()->sputn(d, len) != len) { dest.setstate(std::ios_base::badbit); } } return dest; } // __uint128_t std::ostream& operator<<(std::ostream& dest, __uint128_t value) { std::ostream::sentry s(dest); if (s) { char buffer[128]; char* d = std::end(buffer); do { --d; *d = "0123456789"[value % 10]; value /= 10; } while (value != 0); int len = std::end(buffer) - d; if (dest.rdbuf()->sputn(d, len) != len) { dest.setstate(std::ios_base::badbit); } } return dest; } // pair template <typename T, typename U> std::ostream& operator<<(std::ostream& out, const std::pair<T, U>& a) { return out << a.first << ' ' << a.second; } // tuple template <unsigned int N = 0, typename ...Args> std::ostream& operator<<(std::ostream& out, const std::tuple<Args...>& a) { if constexpr (N >= std::tuple_size_v<std::tuple<Args...>>) return out; else { out << std::get<N>(a); if constexpr (N + 1 < std::tuple_size_v<std::tuple<Args...>>) out << ' '; return operator<<<N + 1>(out, a); } } // vector template <typename T> std::ostream& operator<<(std::ostream& out, const std::vector<T>& a) { for (auto it = a.begin(); it != a.end();) { out << *it; if (++it != a.end()) out << ' '; } return out; } // array template <typename T, size_t N> std::ostream& operator<<(std::ostream& out, const std::array<T, N>& a) { for (auto it = a.begin(); it != a.end();) { out << *it; if (++it != a.end()) out << ' '; } return out; } inline void print() { std::cout << '\n'; } template <typename Head, typename... Tail> inline void print(const Head& head, const Tail &...tails) { std::cout << head; if (sizeof...(tails)) std::cout << ' '; print(tails...); } template <typename Iterable> auto print_all(const Iterable& v, std::string sep = " ", std::string end = "\n") -> decltype(std::cout << *v.begin(), void()) { for (auto it = v.begin(); it != v.end();) { std::cout << *it; if (++it != v.end()) std::cout << sep; } std::cout << end; } __int128_t stoi128(const std::string& s) { __int128_t ret = 0; for (int i = 0; i < int(s.size()); i++) if ('0' <= s[i] and s[i] <= '9') ret = 10 * ret + s[i] - '0'; if (s[0] == '-') ret = -ret; return ret; } __uint128_t stou128(const std::string& s) { __uint128_t ret = 0; for (int i = 0; i < int(s.size()); i++) if ('0' <= s[i] and s[i] <= '9') ret = 10 * ret + s[i] - '0'; return ret; } // __int128_t std::istream& operator>>(std::istream& in, __int128_t& v) { std::string s; in >> s; v = stoi128(s); return in; } // __uint128_t std::istream& operator>>(std::istream& in, __uint128_t& v) { std::string s; in >> s; v = stou128(s); return in; } // pair template <typename T, typename U> std::istream& operator>>(std::istream& in, std::pair<T, U>& a) { return in >> a.first >> a.second; } // tuple template <unsigned int N = 0, typename ...Args> std::istream& operator>>(std::istream& in, std::tuple<Args...>& a) { if constexpr (N >= std::tuple_size_v<std::tuple<Args...>>) return in; else return operator>><N + 1>(in >> std::get<N>(a), a); } // vector template <typename T> std::istream& operator>>(std::istream& in, std::vector<T>& a) { for (auto it = a.begin(); it != a.end(); ++it) in >> *it; return in; } // array template <typename T, size_t N> std::istream& operator>>(std::istream& in, std::array<T, N>& a) { for (auto it = a.begin(); it != a.end(); ++it) in >> *it; return in; } template <typename ...Args> void read(Args &...args) { (std::cin >> ... >> args); } // ! integral utilities // Returns pow(-1, n) template <typename T> constexpr inline int pow_m1(T n) { return -(n & 1) | 1; } // Returns pow(-1, n) template <> constexpr inline int pow_m1<bool>(bool n) { return -int(n) | 1; } // Returns floor(x / y) template <typename T> constexpr inline T fld(const T x, const T y) { return (x ^ y) >= 0 ? x / y : (x - (y + pow_m1(y >= 0))) / y; } template <typename T> constexpr inline T cld(const T x, const T y) { return (x ^ y) <= 0 ? x / y : (x + (y + pow_m1(y >= 0))) / y; } template <typename T, std::enable_if_t<std::negation_v<suisen::is_nbit<T, 64>>, std::nullptr_t> = nullptr> __attribute__((target("popcnt"))) constexpr inline int popcount(const T x) { return _mm_popcnt_u32(x); } template <typename T, std::enable_if_t<suisen::is_nbit_v<T, 64>, std::nullptr_t> = nullptr> __attribute__((target("popcnt"))) constexpr inline int popcount(const T x) { return _mm_popcnt_u64(x); } template <typename T, std::enable_if_t<std::negation_v<suisen::is_nbit<T, 64>>, std::nullptr_t> = nullptr> constexpr inline int count_lz(const T x) { return x ? __builtin_clz(x) : suisen::bit_num<T>; } template <typename T, std::enable_if_t<suisen::is_nbit_v<T, 64>, std::nullptr_t> = nullptr> constexpr inline int count_lz(const T x) { return x ? __builtin_clzll(x) : suisen::bit_num<T>; } template <typename T, std::enable_if_t<std::negation_v<suisen::is_nbit<T, 64>>, std::nullptr_t> = nullptr> constexpr inline int count_tz(const T x) { return x ? __builtin_ctz(x) : suisen::bit_num<T>; } template <typename T, std::enable_if_t<suisen::is_nbit_v<T, 64>, std::nullptr_t> = nullptr> constexpr inline int count_tz(const T x) { return x ? __builtin_ctzll(x) : suisen::bit_num<T>; } template <typename T> constexpr inline int floor_log2(const T x) { return suisen::bit_num<T> - 1 - count_lz(x); } template <typename T> constexpr inline int ceil_log2(const T x) { return floor_log2(x) + ((x & -x) != x); } template <typename T> constexpr inline int kth_bit(const T x, const unsigned int k) { return (x >> k) & 1; } template <typename T> constexpr inline int parity(const T x) { return popcount(x) & 1; } // ! container template <typename T, typename Comparator> auto priqueue_comp(const Comparator comparator) { return std::priority_queue<T, std::vector<T>, Comparator>(comparator); } template <typename Container> void sort_unique_erase(Container& a) { std::sort(a.begin(), a.end()); a.erase(std::unique(a.begin(), a.end()), a.end()); } template <typename InputIterator, typename BiConsumer> auto foreach_adjacent_values(InputIterator first, InputIterator last, BiConsumer f) -> decltype(f(*first++, *last), void()) { if (first != last) for (auto itr = first, itl = itr++; itr != last; itl = itr++) f(*itl, *itr); } template <typename Container, typename BiConsumer> auto foreach_adjacent_values(Container &&c, BiConsumer f) -> decltype(c.begin(), c.end(), void()) { foreach_adjacent_values(c.begin(), c.end(), f); } // ! other utilities // x <- min(x, y). returns true iff `x` has chenged. template <typename T> inline bool chmin(T& x, const T& y) { return y >= x ? false : (x = y, true); } // x <- max(x, y). returns true iff `x` has chenged. template <typename T> inline bool chmax(T& x, const T& y) { return y <= x ? false : (x = y, true); } template <typename T, std::enable_if_t<std::is_integral_v<T>, std::nullptr_t> = nullptr> std::string bin(T val, int bit_num = -1) { std::string res; if (bit_num != -1) { for (int bit = bit_num; bit-- > 0;) res += '0' + ((val >> bit) & 1); } else { for (; val; val >>= 1) res += '0' + (val & 1); std::reverse(res.begin(), res.end()); } return res; } template <typename T, std::enable_if_t<std::is_integral_v<T>, std::nullptr_t> = nullptr> std::vector<T> digits_low_to_high(T val, T base = 10) { std::vector<T> res; for (; val; val /= base) res.push_back(val % base); if (res.empty()) res.push_back(T{ 0 }); return res; } template <typename T, std::enable_if_t<std::is_integral_v<T>, std::nullptr_t> = nullptr> std::vector<T> digits_high_to_low(T val, T base = 10) { auto res = digits_low_to_high(val, base); std::reverse(res.begin(), res.end()); return res; } template <typename T> std::string join(const std::vector<T>& v, const std::string& sep, const std::string& end) { std::ostringstream ss; for (auto it = v.begin(); it != v.end();) { ss << *it; if (++it != v.end()) ss << sep; } ss << end; return ss.str(); } template <typename Func, typename Seq> auto transform_to_vector(const Func &f, const Seq &s) { std::vector<std::invoke_result_t<Func, typename Seq::value_type>> v; v.reserve(std::size(s)), std::transform(std::begin(s), std::end(s), std::back_inserter(v), f); return v; } template <typename T, typename Seq> auto copy_to_vector(const Seq &s) { std::vector<T> v; v.reserve(std::size(s)), std::copy(std::begin(s), std::end(s), std::back_inserter(v)); return v; } template <typename Seq> Seq concat(Seq s, const Seq &t) { s.reserve(std::size(s) + std::size(t)); std::copy(std::begin(t), std::end(t), std::back_inserter(s)); return s; } template <typename Seq> std::vector<Seq> split(const Seq s, typename Seq::value_type delim) { std::vector<Seq> res; for (auto itl = std::begin(s), itr = itl;; itl = ++itr) { while (itr != std::end(s) and *itr != delim) ++itr; res.emplace_back(itl, itr); if (itr == std::end(s)) return res; } } int digit_to_int(char c) { return c - '0'; } int lowercase_to_int(char c) { return c - 'a'; } int uppercase_to_int(char c) { return c - 'A'; } std::vector<int> digit_str_to_ints(const std::string &s) { return transform_to_vector(digit_to_int, s); } std::vector<int> lowercase_str_to_ints(const std::string &s) { return transform_to_vector(lowercase_to_int, s); } std::vector<int> uppercase_str_to_ints(const std::string &s) { return transform_to_vector(uppercase_to_int, s); } template <typename T, typename ToKey, typename CompareValue = std::less<>, std::enable_if_t< std::conjunction_v< std::is_invocable<ToKey, T>, std::is_invocable_r<bool, CompareValue, std::invoke_result_t<ToKey, T>, std::invoke_result_t<ToKey, T> > >, std::nullptr_t> = nullptr > auto comparator(const ToKey &to_key, const CompareValue &compare_value = std::less<>()) { return [to_key, compare_value](const T& x, const T& y) { return compare_value(to_key(x), to_key(y)); }; } template <typename ToKey, std::enable_if_t<std::is_invocable_v<ToKey, int>, std::nullptr_t> = nullptr> std::vector<int> sorted_indices(int n, const ToKey &to_key) { std::vector<int> p(n); std::iota(p.begin(), p.end(), 0); std::sort(p.begin(), p.end(), comparator<int>(to_key)); return p; } template <typename Compare, std::enable_if_t<std::is_invocable_r_v<bool, Compare, int, int>, std::nullptr_t> = nullptr> std::vector<int> sorted_indices(int n, const Compare &compare) { std::vector<int> p(n); std::iota(p.begin(), p.end(), 0); std::sort(p.begin(), p.end(), compare); return p; } const std::string Yes = "Yes", No = "No", YES = "YES", NO = "NO"; namespace suisen {} using namespace suisen; using namespace std; struct io_setup { io_setup(int precision = 20) { std::ios::sync_with_stdio(false); std::cin.tie(nullptr); std::cout << std::fixed << std::setprecision(precision); } } io_setup_ {}; // ! code from here #include <atcoder/string> #include <algorithm> #include <cassert> #include <vector> namespace suisen { template <typename T, typename UpdateFunc, constraints_t<std::is_invocable<UpdateFunc>> = nullptr> struct UpdateProxyObject { public: UpdateProxyObject(T &v, UpdateFunc update) : v(v), update(update) {} operator T() const { return v; } auto& operator++() && { ++v, update(); return *this; } auto& operator--() && { --v, update(); return *this; } auto& operator+=(const T &val) && { v += val, update(); return *this; } auto& operator-=(const T &val) && { v -= val, update(); return *this; } auto& operator*=(const T &val) && { v *= val, update(); return *this; } auto& operator/=(const T &val) && { v /= val, update(); return *this; } auto& operator%=(const T &val) && { v %= val, update(); return *this; } auto& operator =(const T &val) && { v = val, update(); return *this; } auto& operator<<=(const T &val) && { v <<= val, update(); return *this; } auto& operator>>=(const T &val) && { v >>= val, update(); return *this; } template <typename F, constraints_t<is_uni_op<F, T>> = nullptr> auto& apply(F f) && { v = f(v), update(); return *this; } private: T &v; UpdateFunc update; }; } // namespace suisen namespace suisen { template <typename T, T(*op)(T, T), T(*e)(), typename F, T(*mapping)(F, T), F(*composition)(F, F), F(*id)(), bool enable_beats = false> struct LazySegmentTree { using value_type = T; using operator_type = F; LazySegmentTree() : LazySegmentTree(0) {} LazySegmentTree(int n) : LazySegmentTree(std::vector<value_type>(n, e())) {} LazySegmentTree(const std::vector<value_type>& init) : n(init.size()), m(ceil_pow2(n)), lg(__builtin_ctz(m)), data(2 * m, e()), lazy(m, id()) { std::copy(init.begin(), init.end(), data.begin() + m); for (int k = m - 1; k > 0; --k) update(k); } void apply(int l, int r, const operator_type& f) { assert(0 <= l and l <= r and r <= n); push_to(l, r); for (int l2 = l + m, r2 = r + m; l2 < r2; l2 >>= 1, r2 >>= 1) { if (l2 & 1) all_apply(l2++, f); if (r2 & 1) all_apply(--r2, f); } update_from(l, r); } void apply(int p, const operator_type& f) { (*this)[p] = mapping(f, get(p)); } value_type operator()(int l, int r) { assert(0 <= l and l <= r and r <= n); push_to(l, r); value_type res_l = e(), res_r = e(); for (l += m, r += m; l < r; l >>= 1, r >>= 1) { if (l & 1) res_l = op(res_l, data[l++]); if (r & 1) res_r = op(data[--r], res_r); } return op(res_l, res_r); } value_type prod(int l, int r) { return (*this)(l, r); } value_type prefix_prod(int r) { return (*this)(0, r); } value_type suffix_prod(int l) { return (*this)(l, m); } value_type all_prod() const { return data[1]; } auto operator[](int p) { assert(0 <= p and p < n); push_to(p); return UpdateProxyObject{ data[p + m], [this, p] { update_from(p); } }; } value_type get(int p) { return (*this)[p]; } void set(int p, value_type v) { (*this)[p] = v; } template <typename Pred, constraints_t<is_same_as_invoke_result<bool, Pred, value_type>> = nullptr> int max_right(int l, Pred g) { assert(0 <= l && l <= n); assert(g(e())); if (l == n) return n; l += m; for (int i = lg; i >= 1; --i) push(l >> i); value_type sum = e(); do { while ((l & 1) == 0) l >>= 1; if (not g(op(sum, data[l]))) { while (l < m) { push(l); l = 2 * l; if (g(op(sum, data[l]))) sum = op(sum, data[l++]); } return l - m; } sum = op(sum, data[l++]); } while ((l & -l) != l); return n; } template <bool(*f)(value_type)> int max_right(int l) { return max_right(l, f); } template <typename Pred, constraints_t<is_same_as_invoke_result<bool, Pred, value_type>> = nullptr> int min_left(int r, Pred g) { assert(0 <= r && r <= n); assert(g(e())); if (r == 0) return 0; r += m; for (int i = lg; i >= 1; --i) push(r >> i); value_type sum = e(); do { r--; while (r > 1 and (r & 1)) r >>= 1; if (not g(op(data[r], sum))) { while (r < m) { push(r); r = 2 * r + 1; if (g(op(data[r], sum))) sum = op(data[r--], sum); } return r + 1 - m; } sum = op(data[r], sum); } while ((r & -r) != r); return 0; } template <bool(*f)(value_type)> int min_left(int l) { return min_left(l, f); } private: int n, m, lg; std::vector<value_type> data; std::vector<operator_type> lazy; static constexpr int ceil_pow2(int n) { int m = 1; while (m < n) m <<= 1; return m; } void all_apply(int k, const operator_type& f) { data[k] = mapping(f, data[k]); if (k < m) { lazy[k] = composition(f, lazy[k]); if constexpr (enable_beats) if (data[k].fail) push(k), update(k); } } void push(int k) { all_apply(2 * k, lazy[k]), all_apply(2 * k + 1, lazy[k]); lazy[k] = id(); } void push_to(int p) { p += m; for (int i = lg; i >= 1; --i) push(p >> i); } void push_to(int l, int r) { l += m, r += m; int li = __builtin_ctz(l), ri = __builtin_ctz(r); for (int i = lg; i >= li + 1; --i) push(l >> i); for (int i = lg; i >= ri + 1; --i) push(r >> i); } void update(int k) { data[k] = op(data[2 * k], data[2 * k + 1]); } void update_from(int p) { p += m; for (int i = 1; i <= lg; ++i) update(p >> i); } void update_from(int l, int r) { l += m, r += m; int li = __builtin_ctz(l), ri = __builtin_ctz(r); for (int i = li + 1; i <= lg; ++i) update(l >> i); for (int i = ri + 1; i <= lg; ++i) update(r >> i); } }; } namespace suisen { template <typename T, T(*op)(T, T), T(*e)(), typename F, T(*mapping)(F, T), F(*composition)(F, F), F(*id)()> using SegmentTreeBeats = LazySegmentTree<T, op, e, F, mapping, composition, id, /* enable_beats = */ true>; } // namespace suisen namespace suisen { template <typename T> struct RangeChMinMaxAddRangeSum { friend struct DataType; struct DataType { friend struct RangeChMinMaxAddRangeSum; bool fail = false; constexpr DataType() : lo(inf), lo2(inf), hi(-inf), hi2(-inf), sum(0), siz(0), num_lo(0), num_hi(0) {} constexpr DataType(T x, int num = 1) : lo(x), lo2(inf), hi(x), hi2(-inf), sum(x * num), siz(num), num_lo(num), num_hi(num) {} T get_min() const { return lo; } T get_max() const { return hi; } T get_second_min() const { return lo2; } T get_second_max() const { return hi2; } T get_min_num() const { return num_lo; } T get_max_num() const { return num_hi; } T get_sum() const { return sum; } private: T lo, lo2, hi, hi2, sum; int siz, num_lo, num_hi; }; explicit RangeChMinMaxAddRangeSum(const int n = 0) : RangeChMinMaxAddRangeSum(std::vector<T>(n, 0)) {} RangeChMinMaxAddRangeSum(const std::vector<T> &init) { const int n = init.size(); std::vector<DataType> a(n); for (int i = 0; i < n; ++i) { a[i] = DataType{init[i]}; } seg = SegmentTreeBeats<DataType, op, e, F, mapping, composition, id>{ a }; } void chmin(int l, int r, T val) { seg.apply(l, r, F::chmin_query(val)); } void chmax(int l, int r, T val) { seg.apply(l, r, F::chmax_query(val)); } void update(int l, int r, T val) { seg.apply(l, r, F::update_query(val)); } void add(int l, int r, T val) { seg.apply(l, r, F::add_query(val)); } T max(int l, int r) { return seg.prod(l, r).get_max(); } T min(int l, int r) { return seg.prod(l, r).get_min(); } T sum(int l, int r) { return seg.prod(l, r).get_sum(); } DataType prod(int l, int r) { return seg.prod(l, r); } template <bool(*pred)(DataType)> int max_right(int l) { return seg.max_right<pred>(l); } template <typename Pred> int max_right(int l, Pred &&pred) { return seg.max_right(l, std::forward<Pred>(pred)); } template <bool(*pred)(DataType)> int min_left(int r) { return seg.min_left<pred>(r); } template <typename Pred> int min_left(int r, Pred &&pred) { return seg.min_left(r, std::forward<Pred>(pred)); } private: static constexpr T inf = std::numeric_limits<T>::max() / 2; struct F { T lb, ub, add; constexpr F(T lb = -inf, T ub = inf, T add = 0) : lb(lb), ub(ub), add(add) {} static constexpr F chmin_query(T x) { return F { -inf, x, 0 }; } static constexpr F chmax_query(T x) { return F { x, inf, 0 }; } static constexpr F update_query(T x) { return F { x, x, 0 }; } static constexpr F add_query(T x) { return F { -inf, inf, x }; } }; static constexpr T second_lo(T lo11, T lo12, T lo21, T lo22) { if (lo11 == lo21) return std::min(lo12, lo22); if (lo12 <= lo21) return lo12; if (lo22 <= lo11) return lo22; return std::max(lo11, lo21); } static constexpr T second_hi(T hi11, T hi12, T hi21, T hi22) { if (hi11 == hi21) return std::max(hi12, hi22); if (hi12 >= hi21) return hi12; if (hi22 >= hi11) return hi22; return std::min(hi11, hi21); } static constexpr DataType op(DataType x, DataType y) { DataType z{}; z.lo = std::min(x.lo, y.lo); z.hi = std::max(x.hi, y.hi); z.lo2 = second_lo(x.lo, x.lo2, y.lo, y.lo2); z.hi2 = second_hi(x.hi, x.hi2, y.hi, y.hi2); z.sum = x.sum + y.sum; z.siz = x.siz + y.siz; z.num_lo = (z.lo == x.lo) * x.num_lo + (z.lo == y.lo) * y.num_lo; z.num_hi = (z.hi == x.hi) * x.num_hi + (z.hi == y.hi) * y.num_hi; return z; } static constexpr DataType e() { return DataType{}; } static constexpr DataType mapping(F f, DataType x) { if (x.siz == 0) { return e(); } else if (x.lo == x.hi or f.lb == f.ub or f.lb >= x.hi or f.ub <= x.lo) { return DataType { std::clamp(x.lo, f.lb, f.ub) + f.add, x.siz }; } else if (x.lo2 == x.hi) { // 2 x.lo = x.hi2 = std::max(x.lo, f.lb) + f.add; x.hi = x.lo2 = std::min(x.hi, f.ub) + f.add; x.sum = x.lo * x.num_lo + x.hi * x.num_hi; return x; } else if (f.lb < x.lo2 and f.ub > x.hi2) { // >= 3 T nlo = std::max(x.lo, f.lb); T nhi = std::min(x.hi, f.ub); x.sum += (nlo - x.lo) * x.num_lo + (nhi - x.hi) * x.num_hi + f.add * x.siz; x.lo = nlo + f.add; x.hi = nhi + f.add; x.lo2 += f.add; x.hi2 += f.add; return x; } x.fail = true; return x; } static constexpr F composition(F f, F g) { F h; h.lb = std::clamp(g.lb + g.add, f.lb, f.ub) - g.add; h.ub = std::clamp(g.ub + g.add, f.lb, f.ub) - g.add; h.add = f.add + g.add; return h; } static constexpr F id() { return F{}; } SegmentTreeBeats<DataType, op, e, F, mapping, composition, id> seg; }; } // namespace suisen #include <atcoder/segtree> using S = int; S op(S x, S y) { return min(x, y); } S e() { return 1000000000; } int main() { int n, q; read(n, q); string s; read(s); vector<int> sa = atcoder::suffix_array(s); vector<int> lcp = atcoder::lcp_array(s, sa); vector<pair<int, int>> lr(q); for (auto &[l, r] : lr) { read(l, r); --l; } vector<int> sa_inv(n); REP(i, n) { sa_inv[sa[i]] = i; } vector<long long> ans(q); atcoder::segtree<S, op, e> seg(lcp); RangeChMinMaxAddRangeSum<long long> seg_sum(vector<long long>(ALL(lcp))); vector<long long> acc(n + 1); REP(i, n) { acc[i + 1] = acc[i] + (n - sa[i]); } int prev_pos = 0; for (int qid : sorted_indices(q, [&](int i) { return sa_inv[lr[i].first]; })) { int pos = sa_inv[lr[qid].first]; int len = lr[qid].second - lr[qid].first; REP(p, prev_pos, pos) { seg_sum.chmin(0, p, lcp[p]); } int to = seg.min_left(pos, [&](S v) { return v >= len; }); debug(qid, to); ans[qid] = acc[to] - seg_sum.sum(0, to) + (len - 1); prev_pos = pos; } print_all(ans, "\n"); return 0; }