結果
| 問題 | No.2361 Many String Compare Queries |
| ユーザー |
 suisen
|
| 提出日時 | 2023-06-23 23:42:34 |
| 言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
WA
|
| 実行時間 | - |
| コード長 | 31,668 bytes |
| コンパイル時間 | 4,656 ms |
| コンパイル使用メモリ | 346,148 KB |
| 実行使用メモリ | 64,900 KB |
| 最終ジャッジ日時 | 2024-07-01 03:30:46 |
| 合計ジャッジ時間 | 18,086 ms |
|
ジャッジサーバーID （参考情報） |
judge1 / judge3 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 2 ms
6,816 KB |
| testcase_01 | AC | 2 ms
6,940 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 | 1,503 ms
63,940 KB |
| testcase_12 | WA | - |
| testcase_13 | WA | - |
| testcase_14 | AC | 1,029 ms
64,052 KB |
| 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);
{
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;
}