結果
問題 | No.2361 Many String Compare Queries |
ユーザー |
|
提出日時 | 2023-06-23 23:42:34 |
言語 | C++17 (gcc 13.3.0 + boost 1.87.0) |
結果 |
WA
|
実行時間 | - |
コード長 | 31,668 bytes |
コンパイル時間 | 4,423 ms |
コンパイル使用メモリ | 349,360 KB |
最終ジャッジ日時 | 2025-02-15 01:41:25 |
ジャッジサーバーID (参考情報) |
judge2 / judge3 |
(要ログイン)
ファイルパターン | 結果 |
---|---|
sample | AC * 2 |
other | AC * 4 WA * 10 |
コンパイルメッセージ
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); | ^~~~~~~~~ | template 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); | ^~~~~~~~ | template
ソースコード
#include <bits/stdc++.h>#ifdef _MSC_VER# include <intrin.h>#else# include <x86intrin.h>#endif#include <limits>#include <type_traits>namespace suisen {// ! utilitytemplate <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);}}// ! functiontemplate <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>;// ! integraltemplate <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 aliasesusing 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_tstd::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_tstd::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;}// pairtemplate <typename T, typename U>std::ostream& operator<<(std::ostream& out, const std::pair<T, U>& a) {return out << a.first << ' ' << a.second;}// tupletemplate <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);}}// vectortemplate <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;}// arraytemplate <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_tstd::istream& operator>>(std::istream& in, __int128_t& v) {std::string s;in >> s;v = stoi128(s);return in;}// __uint128_tstd::istream& operator>>(std::istream& in, __uint128_t& v) {std::string s;in >> s;v = stou128(s);return in;}// pairtemplate <typename T, typename U>std::istream& operator>>(std::istream& in, std::pair<T, U>& a) {return in >> a.first >> a.second;}// tupletemplate <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);}// vectortemplate <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;}// arraytemplate <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; }// ! containertemplate <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 suisennamespace 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 suisennamespace 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) { // 2x.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) { // >= 3T 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);{vector<long long> acc(n + 1);REP(i, n) {acc[i + 1] = acc[i] + (n - sa[i]);}RangeChMinMaxAddRangeSum<long long> seg_sum(vector<long long>(ALL(lcp)));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 l = seg.min_left(pos, [&](S v) { return v >= len; });ans[qid] += acc[l] - seg_sum.sum(0, l) + (long long) (len - 1) * (pos - l + 1);prev_pos = pos;}}{RangeChMinMaxAddRangeSum<long long> seg_sum(vector<long long>(ALL(lcp)));int prev_pos = n - 1;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, pos, prev_pos) {seg_sum.chmin(p, n - 1, lcp[p]);}int r = seg.max_right(pos, [&](S v) { return v >= len; });ans[qid] += seg_sum.sum(r, n - 1) + (long long) (len - 1) * (r - pos);prev_pos = pos;}}print_all(ans, "\n");return 0;}