結果
| 問題 | No.1933 ABC String |
| ユーザー |
 jell
|
| 提出日時 | 2022-05-06 23:56:25 |
| 言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
TLE
|
| 実行時間 | - |
| コード長 | 55,803 bytes |
| コンパイル時間 | 2,291 ms |
| コンパイル使用メモリ | 220,396 KB |
| 実行使用メモリ | 21,808 KB |
| 最終ジャッジ日時 | 2024-07-06 03:31:50 |
| 合計ジャッジ時間 | 7,095 ms |
|
ジャッジサーバーID （参考情報） |
judge5 / judge2 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 2 ms
6,816 KB |
| testcase_01 | AC | 2 ms
5,376 KB |
| testcase_02 | AC | 2 ms
5,376 KB |
| testcase_03 | AC | 2 ms
5,376 KB |
| testcase_04 | AC | 2 ms
5,376 KB |
| testcase_05 | AC | 2 ms
5,376 KB |
| testcase_06 | AC | 2 ms
5,376 KB |
| testcase_07 | AC | 2 ms
5,376 KB |
| testcase_08 | AC | 2 ms
5,376 KB |
| testcase_09 | AC | 2 ms
5,376 KB |
| testcase_10 | AC | 2 ms
5,376 KB |
| testcase_11 | AC | 3 ms
5,376 KB |
| testcase_12 | AC | 2 ms
5,376 KB |
| testcase_13 | AC | 132 ms
21,528 KB |
| testcase_14 | AC | 92 ms
14,040 KB |
| testcase_15 | AC | 78 ms
14,192 KB |
| testcase_16 | AC | 104 ms
19,612 KB |
| testcase_17 | AC | 97 ms
17,036 KB |
| testcase_18 | AC | 65 ms
12,848 KB |
| testcase_19 | AC | 91 ms
15,944 KB |
| testcase_20 | AC | 151 ms
21,808 KB |
| testcase_21 | AC | 77 ms
13,912 KB |
| testcase_22 | AC | 68 ms
13,908 KB |
| testcase_23 | TLE | - |
| testcase_24 | -- | - |
| testcase_25 | -- | - |
| testcase_26 | -- | - |
| testcase_27 | -- | - |
| testcase_28 | -- | - |
| testcase_29 | -- | - |
| testcase_30 | -- | - |
| testcase_31 | -- | - |
| testcase_32 | -- | - |
| testcase_33 | -- | - |
| testcase_34 | -- | - |
| testcase_35 | -- | - |
| testcase_36 | -- | - |
| testcase_37 | -- | - |
| testcase_38 | -- | - |
ソースコード
#line 2 "Library\\src\\algebra\\modint.hpp"
/**
* @file modint.hpp
* @brief Modular Arithmetic
*/
#include <cassert>
#include <iostream>
#include <vector>
#line 2 "Library\\src\\number_theory\\sqrt_mod.hpp"
/**
* @file sqrt_mod.hpp
* @brief Tonelli-Shanks Algorithm
*/
#line 2 "Library\\src\\number_theory\\pow_mod.hpp"
/**
* @file mod_pow.hpp
* @brief Modular Exponentiation
*/
#line 9 "Library\\src\\number_theory\\pow_mod.hpp"
#line 2 "Library\\src\\utils\\sfinae.hpp"
/**
* @file sfinae.hpp
* @brief SFINAE
*/
#include <cstdint>
#include <iterator>
#include <type_traits>
#ifndef __INT128_DEFINED__
#ifdef __SIZEOF_INT128__
#define __INT128_DEFINED__ 1
#else
#define __INT128_DEFINED__ 0
#endif
#endif
namespace std {
#if __INT128_DEFINED__
template <> struct make_signed<__uint128_t> { using type = __int128_t; };
template <> struct make_signed<__int128_t> { using type = __int128_t; };
template <> struct make_unsigned<__uint128_t> { using type = __uint128_t; };
template <> struct make_unsigned<__int128_t> { using type = __uint128_t; };
template <> struct is_signed<__uint128_t> : std::false_type {};
template <> struct is_signed<__int128_t> : std::true_type {};
template <> struct is_unsigned<__uint128_t> : std::true_type {};
template <> struct is_unsigned<__int128_t> : std::false_type {};
#endif
} // namespace std
namespace workspace {
template <class Tp, class... Args> struct variadic_front { using type = Tp; };
template <class... Args> struct variadic_back;
template <class Tp> struct variadic_back<Tp> { using type = Tp; };
template <class Tp, class... Args> struct variadic_back<Tp, Args...> {
using type = typename variadic_back<Args...>::type;
};
template <class type, template <class> class trait>
using enable_if_trait_type = typename std::enable_if<trait<type>::value>::type;
/**
* @brief Return type of subscripting ( @c [] ) access.
*/
template <class _Tp>
using subscripted_type =
typename std::decay<decltype(std::declval<_Tp&>()[0])>::type;
template <class Container>
using element_type = typename std::decay<decltype(*std::begin(
std::declval<Container&>()))>::type;
template <class _Tp, class = void> struct has_begin : std::false_type {};
template <class _Tp>
struct has_begin<
_Tp, std::__void_t<decltype(std::begin(std::declval<const _Tp&>()))>>
: std::true_type {
using type = decltype(std::begin(std::declval<const _Tp&>()));
};
template <class _Tp, class = void> struct has_size : std::false_type {};
template <class _Tp>
struct has_size<_Tp, std::__void_t<decltype(std::size(std::declval<_Tp>()))>>
: std::true_type {};
template <class _Tp, class = void> struct has_resize : std::false_type {};
template <class _Tp>
struct has_resize<_Tp, std::__void_t<decltype(std::declval<_Tp>().resize(
std::declval<size_t>()))>> : std::true_type {};
template <class _Tp, class = void> struct has_mod : std::false_type {};
template <class _Tp>
struct has_mod<_Tp, std::__void_t<decltype(_Tp::mod)>> : std::true_type {};
template <class _Tp, class = void> struct is_integral_ext : std::false_type {};
template <class _Tp>
struct is_integral_ext<
_Tp, typename std::enable_if<std::is_integral<_Tp>::value>::type>
: std::true_type {};
#if __INT128_DEFINED__
template <> struct is_integral_ext<__int128_t> : std::true_type {};
template <> struct is_integral_ext<__uint128_t> : std::true_type {};
#endif
#if __cplusplus >= 201402
template <class _Tp>
constexpr static bool is_integral_ext_v = is_integral_ext<_Tp>::value;
#endif
template <typename _Tp, typename = void> struct multiplicable_uint {
using type = uint_least32_t;
};
template <typename _Tp>
struct multiplicable_uint<
_Tp,
typename std::enable_if<(2 < sizeof(_Tp)) &&
(!__INT128_DEFINED__ || sizeof(_Tp) <= 4)>::type> {
using type = uint_least64_t;
};
#if __INT128_DEFINED__
template <typename _Tp>
struct multiplicable_uint<_Tp,
typename std::enable_if<(4 < sizeof(_Tp))>::type> {
using type = __uint128_t;
};
#endif
template <typename _Tp> struct multiplicable_int {
using type =
typename std::make_signed<typename multiplicable_uint<_Tp>::type>::type;
};
template <typename _Tp> struct multiplicable {
using type = std::conditional_t<
is_integral_ext<_Tp>::value,
std::conditional_t<std::is_signed<_Tp>::value,
typename multiplicable_int<_Tp>::type,
typename multiplicable_uint<_Tp>::type>,
_Tp>;
};
template <class> struct first_arg { using type = void; };
template <class _R, class _Tp, class... _Args>
struct first_arg<_R(_Tp, _Args...)> {
using type = _Tp;
};
template <class _R, class _Tp, class... _Args>
struct first_arg<_R (*)(_Tp, _Args...)> {
using type = _Tp;
};
template <class _G, class _R, class _Tp, class... _Args>
struct first_arg<_R (_G::*)(_Tp, _Args...)> {
using type = _Tp;
};
template <class _G, class _R, class _Tp, class... _Args>
struct first_arg<_R (_G::*)(_Tp, _Args...) const> {
using type = _Tp;
};
template <class _Tp, class = void> struct parse_compare : first_arg<_Tp> {};
template <class _Tp>
struct parse_compare<_Tp, std::__void_t<decltype(&_Tp::operator())>>
: first_arg<decltype(&_Tp::operator())> {};
template <class _Container, class = void> struct get_dimension {
static constexpr size_t value = 0;
};
template <class _Container>
struct get_dimension<_Container,
std::enable_if_t<has_begin<_Container>::value>> {
static constexpr size_t value =
1 + get_dimension<typename std::iterator_traits<
typename has_begin<_Container>::type>::value_type>::value;
};
} // namespace workspace
#line 11 "Library\\src\\number_theory\\pow_mod.hpp"
namespace workspace {
/**
* @brief Compile time modular exponentiation.
*
* @param __x
* @param __n Exponent
* @param __mod Modulus
* @return
*/
template <class _Tp>
constexpr std::enable_if_t<(is_integral_ext<_Tp>::value), _Tp> pow_mod(
_Tp __x, _Tp __n, _Tp __mod) noexcept {
assert(__mod > 0);
using mul_type = typename multiplicable_uint<_Tp>::type;
if ((__x %= __mod) < 0) __x += __mod;
mul_type __y{1};
while (__n) {
if (__n & 1) (__y *= __x) %= __mod;
__x = (mul_type)__x * __x % __mod;
__n >>= 1;
}
return __y;
};
} // namespace workspace
#line 10 "Library\\src\\number_theory\\sqrt_mod.hpp"
namespace workspace {
/**
* @brief Compile time modular square root.
*
* @param __x
* @param __mod Modulus
* @return One if it exists. Otherwise -1.
*/
template <class _Tp>
constexpr std::enable_if_t<(is_integral_ext<_Tp>::value), _Tp> sqrt_mod(
_Tp __x, _Tp __mod) noexcept {
assert(__mod > 0);
using mul_type = typename multiplicable_uint<_Tp>::type;
if ((__x %= __mod) < 0) __x += __mod;
if (!__x) return 0;
if (__mod == 2) return __x;
if (pow_mod(__x, __mod >> 1, __mod) != 1) return -1;
_Tp __z = __builtin_ctz(__mod - 1), __q = __mod >> __z;
mul_type __a = pow_mod(__x, (__q + 1) >> 1, __mod), __b = 2;
while (pow_mod<_Tp>(__b, __mod >> 1, __mod) == 1) ++__b;
__b = pow_mod<_Tp>(__b, __q, __mod);
_Tp __shift = 0;
for (auto __r = __a * __a % __mod * pow_mod(__x, __mod - 2, __mod) % __mod;
__r != 1; (__r *= (__b *= __b) %= __mod) %= __mod) {
auto __bsf = __z;
for (auto __e = __r; __e != 1; --__bsf) (__e *= __e) %= __mod;
while (++__shift != __bsf) (__b *= __b) %= __mod;
(__a *= __b) %= __mod;
}
return __a;
};
} // namespace workspace
#line 14 "Library\\src\\algebra\\modint.hpp"
namespace workspace {
namespace _modint_impl {
template <auto _Mod, unsigned _Storage> struct modint {
static_assert(is_integral_ext<decltype(_Mod)>::value,
"_Mod must be integral type.");
using mod_type = std::make_signed_t<typename std::conditional<
0 < _Mod, std::add_const_t<decltype(_Mod)>, decltype(_Mod)>::type>;
using value_type = std::decay_t<mod_type>;
using reference = value_type &;
using const_reference = value_type const &;
using mul_type = typename multiplicable_uint<value_type>::type;
static mod_type mod; // Modulus.
static unsigned storage;
private:
template <class _Tp>
using modint_if = std::enable_if_t<is_integral_ext<_Tp>::value, modint>;
value_type value = 0; // within [0, mod).
struct direct_ctor_t {};
constexpr static direct_ctor_t direct_ctor_tag{};
// Direct constructor
template <class _Tp>
constexpr modint(_Tp __n, direct_ctor_t) noexcept : value(__n) {}
public:
constexpr modint() noexcept = default;
template <class _Tp, class = std::enable_if_t<
std::is_convertible<_Tp, value_type>::value>>
constexpr modint(_Tp __n) noexcept
: value((__n %= mod) < _Tp(0) ? static_cast<value_type>(__n) + mod
: static_cast<value_type>(__n)) {}
constexpr modint(bool __n) noexcept : value(__n) {}
constexpr operator reference() noexcept { return value; }
constexpr operator const_reference() const noexcept { return value; }
// unary operators {{
constexpr modint operator++(int) noexcept {
modint __t{*this};
operator++();
return __t;
}
constexpr modint operator--(int) noexcept {
modint __t{*this};
operator--();
return __t;
}
constexpr modint &operator++() noexcept {
if (++value == mod) value = 0;
return *this;
}
constexpr modint &operator--() noexcept {
if (!value)
value = mod - 1;
else
--value;
return *this;
}
constexpr modint operator+() const noexcept { return *this; }
constexpr modint operator-() const noexcept {
return {value ? mod - value : 0, direct_ctor_tag};
}
// }} unary operators
// operator+= {{
constexpr modint &operator+=(const modint &__x) noexcept {
if ((value += __x.value) >= mod) value -= mod;
return *this;
}
template <class _Tp> constexpr modint_if<_Tp> &operator+=(_Tp __x) noexcept {
__x %= mod, value += __x;
if (value < 0)
value += mod;
else if (value >= mod)
value -= mod;
return *this;
}
// }} operator+=
// operator+ {{
template <class _Tp>
constexpr modint_if<_Tp> operator+(_Tp const &__x) const noexcept {
return modint{*this} += __x;
}
constexpr modint operator+(modint __x) const noexcept { return __x += *this; }
template <class _Tp>
constexpr friend modint_if<_Tp> operator+(_Tp const &__x,
modint __y) noexcept {
return __y += __x;
}
// }} operator+
// operator-= {{
constexpr modint &operator-=(const modint &__x) noexcept {
if ((value -= __x.value) < 0) value += mod;
return *this;
}
template <class _Tp> constexpr modint_if<_Tp> &operator-=(_Tp __x) noexcept {
__x %= mod, value -= __x;
if (value < 0)
value += mod;
else if (value >= mod)
value -= mod;
return *this;
}
// }} operator-=
// operator- {{
template <class _Tp>
constexpr modint_if<_Tp> operator-(_Tp const &__x) const noexcept {
return modint{*this} -= __x;
}
constexpr modint operator-(const modint &__x) const noexcept {
return modint{*this} -= __x;
}
template <class _Tp>
constexpr friend modint_if<_Tp> operator-(_Tp __x,
const modint &__y) noexcept {
if (((__x -= __y.value) %= mod) < 0) __x += mod;
return {__x, direct_ctor_tag};
}
// }} operator-
// operator*= {{
constexpr modint &operator*=(const modint &__x) noexcept {
value =
static_cast<value_type>(value * static_cast<mul_type>(__x.value) % mod);
return *this;
}
template <class _Tp> constexpr modint_if<_Tp> &operator*=(_Tp __x) noexcept {
value = static_cast<value_type>(
value * ((__x %= mod) < 0 ? mul_type(__x + mod) : mul_type(__x)) % mod);
return *this;
}
// }} operator*=
// operator* {{
constexpr modint operator*(const modint &__x) const noexcept {
return {static_cast<mul_type>(value) * __x.value % mod, direct_ctor_tag};
}
template <class _Tp>
constexpr modint_if<_Tp> operator*(_Tp __x) const noexcept {
__x %= mod;
if (__x < 0) __x += mod;
return {static_cast<mul_type>(value) * __x % mod, direct_ctor_tag};
}
template <class _Tp>
constexpr friend modint_if<_Tp> operator*(_Tp __x,
const modint &__y) noexcept {
__x %= mod;
if (__x < 0) __x += mod;
return {static_cast<mul_type>(__x) * __y.value % mod, direct_ctor_tag};
}
// }} operator*
protected:
static value_type _mem(value_type __x) {
static std::vector<value_type> __m{0, 1};
static value_type __i = (__m.reserve(storage), 1);
while (__i < __x) {
++__i;
__m.emplace_back(mod - mul_type(mod / __i) * __m[mod % __i] % mod);
}
return __m[__x];
}
static value_type _div(mul_type __r, value_type __x) noexcept {
assert(__x != value_type(0));
if (!__r) return 0;
std::make_signed_t<value_type> __v{};
bool __neg = __x < 0 ? __x = -__x, true : false;
if (static_cast<decltype(storage)>(__x) < storage)
__v = _mem(__x);
else {
value_type __y{mod}, __u{1}, __t;
while (__x)
__t = __y / __x, __y ^= __x ^= (__y -= __t * __x) ^= __x,
__v ^= __u ^= (__v -= __t * __u) ^= __u;
if (__y < 0) __neg ^= 1;
}
if (__neg)
__v = 0 < __v ? mod - __v : -__v;
else if (__v < 0)
__v += mod;
return __r == mul_type(1) ? static_cast<value_type>(__v)
: static_cast<value_type>(__r * __v % mod);
}
public:
static void reserve(unsigned __n) noexcept {
if (storage < __n) storage = __n;
}
// operator/= {{
constexpr modint &operator/=(const modint &__x) noexcept {
if (value) value = _div(value, __x.value);
return *this;
}
template <class _Tp> constexpr modint_if<_Tp> &operator/=(_Tp __x) noexcept {
if (value) value = _div(value, __x %= mod);
return *this;
}
// }} operator/=
// operator/ {{
constexpr modint operator/(const modint &__x) const noexcept {
if (!value) return {};
return {_div(value, __x.value), direct_ctor_tag};
}
template <class _Tp>
constexpr modint_if<_Tp> operator/(_Tp __x) const noexcept {
if (!value) return {};
return {_div(value, __x %= mod), direct_ctor_tag};
}
template <class _Tp>
constexpr friend modint_if<_Tp> operator/(_Tp __x,
const modint &__y) noexcept {
if (!__x) return {};
if ((__x %= mod) < 0) __x += mod;
return {_div(__x, __y.value), direct_ctor_tag};
}
// }} operator/
constexpr modint inv() const noexcept { return _div(1, value); }
template <class _Tp> constexpr modint pow(_Tp __e) const noexcept {
static_assert(not std::is_floating_point<_Tp>::value);
modint __r{mod != 1, direct_ctor_tag};
for (modint __b{__e < _Tp(0) ? __e = -__e, _div(1, value) : value,
direct_ctor_tag};
__e; __e /= 2, __b *= __b)
if (__e % 2) __r *= __b;
return __r;
}
template <class _Tp>
constexpr friend modint pow(modint __b, _Tp __e) noexcept {
static_assert(not std::is_floating_point<_Tp>::value);
if (__e < _Tp(0)) {
__e = -__e;
__b.value = _div(1, __b.value);
}
modint __r{mod != 1, direct_ctor_tag};
for (; __e; __e /= 2, __b *= __b)
if (__e % 2) __r *= __b;
return __r;
}
constexpr modint sqrt() const noexcept {
return {sqrt_mod(value, mod), direct_ctor_tag};
}
friend constexpr modint sqrt(const modint &__x) noexcept {
return {sqrt_mod(__x.value, mod), direct_ctor_tag};
}
friend std::istream &operator>>(std::istream &__is, modint &__x) noexcept {
std::string __s;
__is >> __s;
bool __neg = false;
if (__s.front() == '-') {
__neg = true;
__s.erase(__s.begin());
}
__x = 0;
for (char __c : __s) __x = __x * 10 + (__c - '0');
if (__neg) __x = -__x;
return __is;
}
};
template <auto _Mod, unsigned _Storage>
typename modint<_Mod, _Storage>::mod_type modint<_Mod, _Storage>::mod =
_Mod > 0 ? _Mod : 0;
template <auto _Mod, unsigned _Storage>
unsigned modint<_Mod, _Storage>::storage = _Storage;
} // namespace _modint_impl
constexpr unsigned _modint_default_storage = 1 << 24;
template <auto _Mod, unsigned _Storage = _modint_default_storage,
typename = std::enable_if_t<(_Mod > 0)>>
using modint = _modint_impl::modint<_Mod, _Storage>;
template <unsigned _Id = 0, unsigned _Storage = _modint_default_storage>
using runtime_modint = _modint_impl::modint<-(signed)_Id, _Storage>;
template <unsigned _Id = 0, unsigned _Storage = _modint_default_storage>
using runtime_modint64 = _modint_impl::modint<-(int_least64_t)_Id, _Storage>;
} // namespace workspace
#line 2 "Library\\src\\algebra\\polynomial.hpp"
/**
* @file polynomial.hpp
* @brief Polynomial
*/
#include <algorithm>
#line 11 "Library\\src\\algebra\\polynomial.hpp"
#line 2 "Library\\src\\algebra\\fft.hpp"
/**
* @file fft.hpp
* @brief Fast Fourier Transform
*/
#line 9 "Library\\src\\algebra\\fft.hpp"
#line 2 "Library\\src\\algebra\\complex.hpp"
/**
* @file complex.hpp
* @brief Complex Number
*/
namespace workspace {
// Complex number.
template <class _Tp> class complex {
_Tp re, im;
friend constexpr complex conj(const complex &x) noexcept {
return {x.re, -x.im};
}
friend constexpr _Tp abs(const complex &x) noexcept {
return hypot(x.re, x.im);
}
friend constexpr _Tp arg(const complex &x) noexcept {
return atan2(x.re, x.im);
}
template <class _Is>
friend constexpr _Is &operator>>(_Is &__is, complex &x) noexcept {
return __is >> x.re >> x.im;
}
template <class _Os>
friend constexpr _Os &operator<<(_Os &__os, const complex &x) noexcept {
return __os << x.re << ' ' << x.im;
}
public:
constexpr complex() noexcept : re{}, im{} {}
constexpr complex(_Tp _re) noexcept : re{_re}, im{} {}
constexpr complex(_Tp _re, _Tp _im) noexcept : re{_re}, im{_im} {}
constexpr _Tp real() const noexcept { return re; }
constexpr void real(_Tp _re) noexcept { re = _re; }
constexpr _Tp imag() const noexcept { return im; }
constexpr void imag(_Tp _im) noexcept { im = _im; }
constexpr complex operator+() const noexcept { return *this; }
constexpr complex operator-() const noexcept { return {-re, -im}; }
constexpr complex &operator+=(const complex &x) noexcept {
return re += x.re, im += x.im, *this;
}
constexpr complex &operator-=(const complex &x) noexcept {
return re -= x.re, im -= x.im, *this;
}
constexpr complex &operator*=(const complex &x) noexcept {
_Tp _re{re * x.re - im * x.im};
return im = im * x.re + x.im * re, re = _re, *this;
}
constexpr complex &operator*=(_Tp x) noexcept {
return re *= x, im *= x, *this;
}
constexpr complex &operator/=(const complex &x) noexcept {
return (*this *= conj(x)) /= re * re + im * im;
}
constexpr complex &operator/=(_Tp x) noexcept {
return re /= x, im /= x, *this;
}
constexpr complex operator+(const complex &x) const noexcept {
return {re + x.re, im + x.im};
}
constexpr complex operator-(const complex &x) const noexcept {
return {re - x.re, im - x.im};
}
constexpr complex operator*(const complex &x) const noexcept {
return complex(*this) *= x;
}
constexpr complex operator*(_Tp x) const noexcept { return {re * x, im * x}; }
constexpr complex operator/(const complex &x) const noexcept {
return complex(*this) /= x;
}
constexpr complex operator/(_Tp x) const noexcept { return {re / x, im / x}; }
};
} // namespace workspace
#line 2 "Library\\lib\\cxx17"
#line 2 "Library\\lib\\cxx14"
#ifndef _CXX14_CONSTEXPR
#if __cplusplus >= 201402L
#define _CXX14_CONSTEXPR constexpr
#else
#define _CXX14_CONSTEXPR
#endif
#endif
#line 4 "Library\\lib\\cxx17"
#ifndef _CXX17_CONSTEXPR
#if __cplusplus >= 201703L
#define _CXX17_CONSTEXPR constexpr
#else
#define _CXX17_CONSTEXPR
#endif
#endif
#ifndef _CXX17_STATIC_ASSERT
#if __cplusplus >= 201703L
#define _CXX17_STATIC_ASSERT static_assert
#else
#define _CXX17_STATIC_ASSERT assert
#endif
#endif
#line 22 "Library\\lib\\cxx17"
#if __cplusplus < 201703L
namespace std {
/**
* @brief Return the size of a container.
* @param __cont Container.
*/
template <typename _Container>
constexpr auto size(const _Container& __cont) noexcept(noexcept(__cont.size()))
-> decltype(__cont.size()) {
return __cont.size();
}
/**
* @brief Return the size of an array.
*/
template <typename _Tp, size_t _Nm>
constexpr size_t size(const _Tp (&)[_Nm]) noexcept {
return _Nm;
}
/**
* @brief Return whether a container is empty.
* @param __cont Container.
*/
template <typename _Container>
[[nodiscard]] constexpr auto empty(const _Container& __cont) noexcept(
noexcept(__cont.empty())) -> decltype(__cont.empty()) {
return __cont.empty();
}
/**
* @brief Return whether an array is empty (always false).
*/
template <typename _Tp, size_t _Nm>
[[nodiscard]] constexpr bool empty(const _Tp (&)[_Nm]) noexcept {
return false;
}
/**
* @brief Return whether an initializer_list is empty.
* @param __il Initializer list.
*/
template <typename _Tp>
[[nodiscard]] constexpr bool empty(initializer_list<_Tp> __il) noexcept {
return __il.size() == 0;
}
struct monostate {};
} // namespace std
#else
#include <variant>
#endif
#line 2 "Library\\src\\number_theory\\ext_gcd.hpp"
/**
* @file ext_gcd.hpp
* @brief Extended Euclidean Algorithm
*/
#include <tuple>
#line 11 "Library\\src\\number_theory\\ext_gcd.hpp"
namespace workspace {
/**
* @param __a Integer
* @param __b Integer
* @return Pair of integers (x, y) s.t. ax + by = g = gcd(a, b) and (b = 0 or 0
* <= x < |b/g|) and (a = 0 or -|a/g| < y <= 0). Return (0, 0) if (a, b) = (0,
* 0).
*/
template <typename _T1, typename _T2>
constexpr auto ext_gcd(_T1 __a, _T2 __b) noexcept {
static_assert(is_integral_ext<_T1>::value);
static_assert(is_integral_ext<_T2>::value);
using value_type = typename std::make_signed<
typename std::common_type<_T1, _T2>::type>::type;
using result_type = std::pair<value_type, value_type>;
value_type a{__a}, b{__b}, p{1}, q{}, r{}, s{1};
while (b != value_type(0)) {
auto t = a / b;
r ^= p ^= r ^= p -= t * r;
s ^= q ^= s ^= q -= t * s;
b ^= a ^= b ^= a -= t * b;
}
if (a < 0) p = -p, q = -q, a = -a;
if (p < 0) {
__a /= a, __b /= a;
if (__b > 0)
p += __b, q -= __a;
else
p -= __b, q += __a;
}
return result_type{p, q};
}
/**
* @param __a Integer
* @param __b Integer
* @param __c Integer
* @return Pair of integers (x, y) s.t. ax + by = c and (b = 0 or 0 <= x <
* |b/g|). Return (0, 0) if there is no solution.
*/
template <typename _T1, typename _T2, typename _T3>
constexpr auto ext_gcd(_T1 __a, _T2 __b, _T3 __c) noexcept {
static_assert(is_integral_ext<_T1>::value);
static_assert(is_integral_ext<_T2>::value);
static_assert(is_integral_ext<_T3>::value);
using value_type = typename std::make_signed<
typename std::common_type<_T1, _T2, _T3>::type>::type;
using result_type = std::pair<value_type, value_type>;
value_type a{__a}, b{__b}, p{1}, q{}, r{}, s{1};
while (b != value_type(0)) {
auto t = a / b;
r ^= p ^= r ^= p -= t * r;
s ^= q ^= s ^= q -= t * s;
b ^= a ^= b ^= a -= t * b;
}
if (__c % a) return result_type{};
__a /= a, __b /= a, __c /= a;
p *= __c, q *= __c;
if (__b != value_type(0)) {
auto t = p / __b;
p -= __b * t;
q += __a * t;
if (p < 0) {
if (__b > 0)
p += __b, q -= __a;
else
p -= __b, q += __a;
}
}
return result_type{p, q};
}
} // namespace workspace
#line 2 "Library\\src\\number_theory\\primitive_root.hpp"
/**
* @file primitive_root.hpp
* @brief Primitive Root
* @date 2020-12-28
*/
#line 10 "Library\\src\\number_theory\\primitive_root.hpp"
namespace workspace {
/**
* @brief Compile time primitive root.
*
* @tparam __mod Positive integer
* @return Minimum positive one if it exists. Otherwise 0.
*/
template <class Tp>
constexpr typename std::enable_if<(is_integral_ext<Tp>::value), Tp>::type
primitive_root(const Tp __mod) noexcept {
assert(__mod > 0);
using int_type = typename multiplicable_uint<Tp>::type;
int_type __r = __mod, __p[16] = {}, *__q = __p;
for (int_type __i = 2; __i <= __r / __i; ++__i) {
if (__r % __i) continue;
*__q++ = __i;
while (!(__r % __i)) __r /= __i;
}
if (__r != 1) *__q++ = __r;
int_type __tot = __mod;
for (__q = __p; *__q; *__q++ = 0) (__tot /= *__q) *= *__q - 1;
__r = __tot, __q = __p + 1, __p[0] = 1;
for (int_type __i = 2; __i <= __r / __i; ++__i) {
if (__r % __i) continue;
*__q++ = __i;
while (!(__r % __i)) __r /= __i;
}
if (__r != 1) *__q++ = __r;
for (Tp __r = 1; __r != __mod; ++__r) {
auto __cnt = 0;
for (__q = __p; *__q; ++__q) {
int_type __w = 1;
for (int_type __e = __tot / *__q, __x = __r; __e;
__e >>= 1, (__x *= __x) %= __mod)
if (__e & 1) (__w *= __x) %= __mod;
if (__w == 1 && ++__cnt > 1) break;
}
if (__cnt == 1) return __r;
}
return 0;
};
} // namespace workspace
#line 15 "Library\\src\\algebra\\fft.hpp"
namespace workspace {
namespace _fft_impl {
template <class _Tp, bool = std::is_floating_point<_Tp>::value, class = void>
struct to_float {
using type = double;
};
template <class _Tp> struct to_float<_Tp, true> { using type = _Tp; };
// template <class _Tp>
// struct to_float<_Tp, false, std::enable_if_t<sizeof(_Tp) <= sizeof(float)>> {
// using type = float;
// };
template <class _Tp>
struct to_float<_Tp, false, std::enable_if_t<(sizeof(_Tp) > sizeof(double))>> {
using type = long double;
};
// Assume ntt-friendly mod.
template <class _Tp> struct field {
using type = std::conditional_t<has_mod<_Tp>::value, _Tp,
complex<typename to_float<_Tp>::type>>;
};
template <class _Tp> struct field<complex<_Tp>> : field<_Tp> {};
// Modular
template <class _Tp, int _Nm = 29, bool = has_mod<_Tp>::value> struct coef {
_Tp s[_Nm], is[_Nm], ip2[_Nm];
_CXX14_CONSTEXPR coef() : s{}, is{}, ip2{1, (1 + _Tp::mod) / 2} {
if (_Tp::mod < 2) return;
int cnt2 = std::min(__builtin_ctz(_Tp::mod - 1), _Nm + 1);
_Tp e = 1;
_Tp w = primitive_root(_Tp::mod);
for (auto p = (_Tp::mod - 1) >> cnt2; p; p >>= 1, w *= w)
if (p & 1) e *= w;
_Tp ie = ext_gcd(decltype(_Tp::mod)(e), _Tp::mod).first;
_Tp es[_Nm]{}, ies[_Nm]{};
for (int i = cnt2; i >= 2; i--) {
es[i - 2] = e, e *= e;
ies[i - 2] = ie, ie *= ie;
}
e = ie = 1;
for (int i = 0; i < cnt2 - 1; i++) {
s[i] = es[i] * e, e *= ies[i];
is[i] = ies[i] * ie, ie *= es[i];
}
for (int i = 1; i < _Nm - 1; ++i) ip2[i + 1] = ip2[i] * ip2[1];
}
};
// Complex
template <class _Tp, int _Nm> struct coef<_Tp, _Nm, false> {
_Tp s[_Nm], is[_Nm], ip2[_Nm];
static_assert(_Nm < 30);
_CXX14_CONSTEXPR static _Tp es[29] = {
{0, 1},
{0.70710678118654752438189403651, 0.70710678118654752443610414514},
{0.92387953251128675610142140795, 0.38268343236508977172325753068},
{0.98078528040323044911909938781, 0.19509032201612826785692544201},
{0.99518472667219688623102546998, 0.09801714032956060199569840382},
{0.99879545620517239270077028412, 0.04906767432741801425693899119},
{0.99969881869620422009748220149, 0.02454122852291228803212346128},
{0.99992470183914454093764001552, 0.01227153828571992607945510345},
{0.99998117528260114264494415325, 0.00613588464915447535972750246},
{0.99999529380957617150137498041, 0.00306795676296597627029751672},
{0.99999882345170190993313003025, 0.00153398018628476561237225788},
{0.99999970586288221914474799723, 0.00076699031874270452695124765},
{0.99999992646571785113833452651, 0.00038349518757139558906815188},
{0.99999998161642929381167504976, 0.00019174759731070330743679009},
{0.99999999540410731290905263501, 0.00009587379909597734587360460},
{0.99999999885102682753608427379, 0.00004793689960306688454884772},
{0.99999999971275670682981095982, 0.00002396844980841821872882467},
{0.99999999992818917670745273995, 0.00001198422490506970642183282},
{0.99999999998204729416331065783, 0.00000599211245264242784278378},
{0.99999999999551182356793271877, 0.00000299605622633466075058210},
{0.99999999999887795586487812538, 0.00000149802811316901122883643},
{0.99999999999971948897977205850, 0.00000074901405658471572113723},
{0.99999999999992987223139048746, 0.00000037450702829238412391495},
{0.99999999999998246807140014902, 0.00000018725351414619534486931},
{0.99999999999999561700429751010, 0.00000009362675707309808280024},
{0.99999999999999890425107437752, 0.00000004681337853654909269501},
{0.99999999999999972607632112153, 0.00000002340668926827455275977},
{0.99999999999999993153263280754, 0.00000001170334463413727718121},
{0.99999999999999998286960567472, 0.00000000585167231706863869077}};
_CXX14_CONSTEXPR coef() : s{}, is{}, ip2{1, .5} {
_Tp ies[_Nm];
for (int i = 0; i < _Nm; ++i) ies[i] = _Tp(1) / es[i];
_Tp e = 1, ie = 1;
for (int i = 0; i < _Nm; i++) {
s[i] = es[i] * e, e *= ies[i];
is[i] = ies[i] * ie, ie *= es[i];
}
for (int i = 1; i < _Nm - 1; ++i) ip2[i + 1] = ip2[i] * ip2[1];
}
};
} // namespace _fft_impl
template <bool _Inverse = false, class _Iterator>
void fft(_Iterator __first, _Iterator __last) noexcept {
using value_type = typename std::iterator_traits<_Iterator>::value_type;
using difference_type =
typename std::iterator_traits<_Iterator>::difference_type;
_CXX14_CONSTEXPR _fft_impl::coef<value_type> c;
auto __h = __builtin_ctz(std::distance(__first, __last));
if _CXX17_CONSTEXPR (_Inverse) {
for (difference_type __p = 1; __p >> __h ^ 1; __p <<= 1) {
value_type __iw = 1;
auto __l = __first;
for (auto __i = 1 << __h; __l != __last;
__iw *= c.is[__builtin_ctz(--__i)]) {
auto __r = std::next(__l, __p);
for (auto __mid = __r; __l != __mid; ++__l, ++__r) {
auto __tmp = (*__l - *__r) * __iw;
*__l += *__r;
*__r = __tmp;
}
__l = __r;
}
}
while (__first != __last) *--__last *= c.ip2[__h];
}
else {
for (difference_type __p = 1 << __h; __p >>= 1;) {
value_type __w = -1;
auto __l = __first;
for (auto __i = 1 << __h; __l != __last;
__w *= c.s[__builtin_ctz(--__i)]) {
auto __r = std::next(__l, __p);
for (auto __mid = __r; __l != __mid; ++__l, ++__r) {
auto __tmp = *__l;
*__l -= *__r *= __w;
*__r += __tmp;
}
__l = __r;
}
}
}
}
template <class _Iterator>
void fft(_Iterator __first, std::size_t __n) noexcept {
fft(__first, std::next(__first, __n));
}
template <class _Iterator>
void ifft(_Iterator __first, _Iterator __last) noexcept {
fft<true>(__first, __last);
}
template <class _Iterator>
void ifft(_Iterator __first, std::size_t __n) noexcept {
ifft(__first, std::next(__first, __n));
}
template <size_t _Nm, size_t _Dm, class _Container, class _Index>
decltype(auto) access(_Container &__a, const _Index &__i) {
if _CXX17_CONSTEXPR (_Nm != _Dm)
return access<_Nm + 1, _Dm>(__a[__i[_Nm]], __i);
else
return __a;
}
template <bool _Inverse, size_t _Dm, class _Container, class _Tp, class _Index>
void dive(_Container &__a, const _Tp &__t, _Index &__i) {
if _CXX17_CONSTEXPR (has_size<_Tp>::value) {
for (__i.emplace_back(0); __i.back() != std::size(__t); ++__i.back())
dive<_Inverse, _Dm + 1>(__a, __t[__i.back()], __i);
__i.pop_back();
}
else {
static std::vector<_Tp> __work;
// Resize to a power of 2.
size_t __len = 1 << (31 - __builtin_clz(std::size(__a)));
if (__work.size() < __len) __work.resize(__len);
for (size_t __k = 0; __k != __len; ++__k)
__work[__k] = std::move(access<0, _Dm>(__a[__k], __i));
fft<_Inverse>(__work.data(), __work.data() + __len);
for (size_t __k = 0; __k != __len; ++__k)
access<0, _Dm>(__a[__k], __i) = std::move(__work[__k]);
}
}
template <bool _Inverse, class _Container> void fft(_Container &__a) {
if _CXX17_CONSTEXPR (has_size<_Container>::value) {
if _CXX17_CONSTEXPR (has_resize<_Container>::value)
// Resize to a power of 2.
__a.resize(1 << (32 - __builtin_clz(__a.size() - 1)));
std::vector<size_t> __i;
dive<_Inverse, 0>(__a, __a[0], __i);
for (size_t __k = 0; __k != std::size(__a); ++__k) fft<_Inverse>(__a[__k]);
}
}
template <class _Container> auto conv_resize(_Container &__a, _Container &__b) {
std::array<size_t, get_dimension<_Container>::value> __s;
rec(__a, __s);
rec(__b, __s);
return __s;
}
template <size_t _Nm, class _Container, class _Size>
void rec(const _Container &__a, _Size &__s) {
if _CXX17_CONSTEXPR (_Nm != __s.size()) {
__s[_Nm] = std::max(__s[_Nm], std::size(__a));
for (auto &__x : __a) rec<_Nm + 1>(__x, __s);
}
}
} // namespace workspace
#line 15 "Library\\src\\algebra\\polynomial.hpp"
namespace workspace {
/**
* @brief Polynomial.
*
* @tparam _Tp Ring structure
* @tparam _Conv_threshold Threshold for convolution method
*/
template <class _Tp, std::size_t _Conv_threshold = 64>
class polynomial : public std::vector<_Tp> {
using vec = std::vector<_Tp>;
using poly = polynomial;
template <class _Os> friend _Os& operator<<(_Os& __os, const poly& __x) {
bool __head = true;
for (const auto& __a : __x) {
if (!__head) __os << ' ';
__head = false;
__os << __a;
}
return __os;
}
public:
using typename vec::size_type;
using typename vec::value_type;
using vec::size;
using vec::vec;
using field = typename _fft_impl::field<_Tp>::type;
protected:
constexpr static _fft_impl::coef<field> __coef{};
static std::vector<field> __work1, __work2;
void _erase_leading_zeros() noexcept {
auto __i = vec::_M_impl._M_finish;
while (__i != vec::_M_impl._M_start && *(__i - 1) == _Tp(0)) --__i;
vec::_M_erase_at_end(__i);
}
template <class _Iter> void _dft(_Iter __first, _Iter __last) const noexcept {
fft<false>(__first, __last);
}
template <class _Iter>
void _idft(_Iter __first, _Iter __last) const noexcept {
fft<true>(__first, __last);
}
void _conv_naive(const poly& __x) noexcept {
if (vec::_M_impl._M_start == vec::_M_impl._M_finish) return;
if (__x._M_impl._M_start == __x._M_impl._M_finish) {
vec::_M_erase_at_end(vec::_M_impl._M_start);
return;
}
vec::_M_default_append(__x._M_impl._M_finish - __x._M_impl._M_start - 1);
for (auto __i = vec::_M_impl._M_finish; __i-- != vec::_M_impl._M_start;) {
auto __j = __i, __k = __x._M_impl._M_start;
*__i *= *__k++;
while (__j != vec::_M_impl._M_start && __k != __x._M_impl._M_finish)
*__i += *--__j * *__k++;
}
}
template <class _Poly> void _conv_dft(_Poly&& __x) noexcept {
size_type __n = vec::_M_impl._M_finish - vec::_M_impl._M_start,
__m = __x._M_impl._M_finish - __x._M_impl._M_start,
__len = 1 << (32 - __builtin_clz(__n + __m - 1));
if (__work1.size() < __len) __work1.resize(__len);
if (__work2.size() < __len) __work2.resize(__len);
vec::_M_default_append(__m - 1);
if _CXX17_CONSTEXPR (std::is_same<_Tp, field>::value) {
std::fill(std::move(vec::_M_impl._M_start, vec::_M_impl._M_finish,
__work1.data()),
__work1.data() + __len, _Tp(0));
std::fill(std::move(__x._M_impl._M_start, __x._M_impl._M_finish,
__work2.data()),
__work2.data() + __len, _Tp(0));
fft(__work1.data(), __len);
fft(__work2.data(), __len);
for (size_type __i = 0; __i < __len; ++__i)
__work1[__i] *= std::move(__work2[__i]);
ifft(__work1.data(), __len);
std::move(__work1.data(), __work1.data() + __n + __m - 1,
vec::_M_impl._M_start);
}
else {
std::fill_n(__work1.data(), __len, _Tp(0));
std::fill_n(__work2.data(), __len, _Tp(0));
for (size_type __i = 0; __i < __n; ++__i)
__work1[__i].real(vec::_M_impl._M_start[__i]);
for (size_type __i = 0; __i < __m; ++__i)
__work1[__i].imag(__x._M_impl._M_start[__i]);
fft(__work1.data(), __len);
__work2[0].imag(__work1[0].real() * __work1[0].imag());
for (size_type __b = 1; __b != __len; __b <<= 1)
for (size_type __i = __b, __j = __b << 1; __j-- != __b; ++__i)
__work2[__i] = (__work1[__i] + conj(__work1[__j])) *
(__work1[__i] - conj(__work1[__j])) / 4;
ifft(__work2.data(), __len);
for (size_type __i = 0; __i < __n + __m - 1; ++__i)
if _CXX17_CONSTEXPR (std::is_floating_point<_Tp>::value)
vec::_M_impl._M_start[__i] = __work2[__i].imag();
else
vec::_M_impl._M_start[__i] = roundl(__work2[__i].imag());
}
}
size_type _divmod_naive(const poly& __x) {
auto __xfin = __x._M_impl._M_finish;
auto __xlen = __x.size();
while (__xfin != __x._M_impl._M_start && *(__xfin - 1) == _Tp(0))
--__xfin, --__xlen;
assert(__xlen != 0);
_erase_leading_zeros();
auto __p = vec::_M_impl._M_finish;
while (size_type(__p - vec::_M_impl._M_start) >= __xlen) {
--__p;
auto __src = __xfin;
auto __dst = __p;
*__dst /= *--__src;
while (__src != __x._M_impl._M_start) *--__dst -= *--__src * *__p;
}
return std::min<size_type>(__xlen - 1, __p - vec::_M_impl._M_start);
}
void _div_naive(const poly& __x) { operator>>=(_divmod_naive(__x)); }
void _div_doubling(poly&& __x) noexcept {
_erase_leading_zeros();
__x._erase_leading_zeros();
auto __n = vec::_M_impl._M_finish - vec::_M_impl._M_start;
auto __m = __x._M_impl._M_finish - __x._M_impl._M_start;
if (__n < __m)
vec::clear();
else {
assert(__m != 0);
std::reverse(__x._M_impl._M_start, __x._M_impl._M_finish);
__x = __x.inv(__n - __m + 1);
std::reverse(vec::_M_impl._M_start, vec::_M_impl._M_finish);
vec::_M_erase_at_end(vec::_M_impl._M_finish - (__m - 1));
operator*=(__x).resize(__n - __m + 1);
std::reverse(vec::_M_impl._M_start, vec::_M_impl._M_finish);
}
}
public:
/**
* @return Degree of %polynomial. Return -1 if it equals zero.
*/
size_type deg() const noexcept { return size() - 1; }
/**
* @param __i Not exceeding the degree.
* @return Coefficient of x^i.
*/
typename vec::reference operator[](size_type __i) noexcept {
assert(__i < size());
return *(vec::_M_impl._M_start + __i);
}
/**
* @param __i Not exceeding the degree.
* @return Coefficient of x^i.
*/
typename vec::const_reference operator[](size_type __i) const noexcept {
assert(__i < size());
return *(vec::_M_impl._M_start + __i);
}
/**
* @brief Evaluate at given point.
*/
_Tp eval(const _Tp& __a) const noexcept {
_Tp __v(0), __p(1);
for (auto __i = vec::_M_impl._M_start; __i != vec::_M_impl._M_finish;
++__i, __p *= __a)
__v += *__i * __p;
return __v;
}
/**
* @brief In-place multipoint evaluation.
*/
template <class _Iter, typename = std::_RequireInputIter<_Iter>>
_Iter eval(_Iter __first, _Iter __last) const noexcept {
return eval(__first, __last, __first);
}
/**
* @brief Multipoint evaluation.
*/
template <class _InputIter, class _OutputIter,
typename = std::_RequireInputIter<_InputIter>>
_OutputIter eval(_InputIter __first, _InputIter __last,
_OutputIter __result) const noexcept {
size_type __n = std::distance(__first, __last);
if (!__n) return __result;
auto __tree = new poly[__n << 1];
for (auto __p = __tree + __n; __first != __last; ++__p, ++__first)
*__p = {-*__first, 1};
for (size_type __i = __n; --__i;)
__tree[__i] = __tree[__i << 1] * __tree[__i << 1 | 1];
__tree[1] = operator%(std::move(__tree[1]));
for (size_type __i = 2; __i != __n << 1; __i += 2)
__tree[__i] = __tree[__i >> 1] % std::move(__tree[__i]),
__tree[__i | 1] =
std::move(__tree[__i >> 1] %= std::move(__tree[__i | 1]));
for (size_type __i = 0; __i != __n; ++__i)
*__result++ = std::move(*__tree[__n + __i]._M_impl._M_start);
delete[] __tree;
return __result;
}
/**
* @brief Multiply by x^i.
*/
poly& operator<<=(size_type __i) noexcept {
vec::insert(vec::begin(), __i, _Tp(0));
return *this;
}
/**
* @brief Divide by x^i.
*/
poly& operator>>=(size_type __i) noexcept {
vec::_M_erase_at_end(
std::move(vec::_M_impl._M_start + std::min(__i, size()),
vec::_M_impl._M_finish, vec::_M_impl._M_start));
return *this;
}
/**
* @brief Multiply by x^i.
*/
poly operator<<(size_type __i) const noexcept {
return poly(*this).operator<<=(__i);
}
/**
* @brief Divide by x^i.
*/
poly operator>>(size_type __i) const noexcept {
return poly(*this).operator>>=(__i);
}
poly operator+() const noexcept { return *this; }
poly operator-() const noexcept {
poly __x = *this;
for (auto __i = __x._M_impl._M_start; __i != __x._M_impl._M_finish; ++__i)
*__i = -*__i;
return __x;
}
poly& operator+=(const poly& __x) noexcept {
if (size() < __x.size()) vec::_M_default_append(__x.size() - size());
for (auto __i = vec::_M_impl._M_start, __j = __x._M_impl._M_start;
__j != __x._M_impl._M_finish; ++__i, ++__j)
*__i += *__j;
_erase_leading_zeros();
return *this;
}
poly& operator+=(const _Tp& __c) noexcept {
if (__c != static_cast<_Tp>(0)) {
if (vec::_M_impl._M_start == vec::_M_impl._M_finish)
vec::emplace_back(__c);
else
*vec::_M_impl._M_start += __c, _erase_leading_zeros();
}
return *this;
}
poly& operator-=(const poly& __x) noexcept {
if (size() < __x.size()) vec::_M_default_append(__x.size() - size());
for (auto __i = vec::_M_impl._M_start, __j = __x._M_impl._M_start;
__j != __x._M_impl._M_finish; ++__i, ++__j)
*__i -= *__j;
_erase_leading_zeros();
return *this;
}
poly& operator-=(const _Tp& __c) noexcept {
if (__c != static_cast<_Tp>(0)) {
if (vec::_M_impl._M_start == vec::_M_impl._M_finish)
vec::emplace_back(-__c);
else
*vec::_M_impl._M_start -= __c, _erase_leading_zeros();
}
return *this;
}
poly& operator*=(const poly& __x) noexcept {
if (this == std::addressof(__x)) // with itself
return operator*=(poly(__x));
std::min(size(), __x.size()) > _Conv_threshold ? _conv_dft(__x)
: _conv_naive(__x);
return *this;
}
poly& operator*=(poly&& __x) noexcept {
if (this == std::addressof(__x)) // with itself
return operator*=(poly(__x));
std::min(size(), __x.size()) > _Conv_threshold
? _conv_dft(std::move(__x))
: _conv_naive(std::move(__x));
return *this;
}
poly& operator*=(const _Tp& __c) noexcept {
if (__c == static_cast<_Tp>(0))
vec::_M_erase_at_end(vec::_M_impl._M_start);
else
for (auto __i = vec::_M_impl._M_start; __i != vec::_M_impl._M_finish;
++__i)
*__i *= __c;
return *this;
}
poly& operator/=(const _Tp& __c) noexcept {
assert(__c != static_cast<_Tp>(0));
for (auto __i = vec::_M_impl._M_start; __i != vec::_M_impl._M_finish; ++__i)
*__i /= __c;
return *this;
}
poly pow(size_type __e) const noexcept {
if (vec::empty()) return *this;
if (!__e) return {1};
if (size() == 1) {
_Tp __x = vec::front(), __y = 1;
for (auto __i = __e; __i; __i >>= 1, __x *= __x)
if (__i & 1) __y *= __x;
return {__y};
}
size_type __deg = (size() - 1) * __e;
assert(__deg > 0);
poly __p(1 << (32 - __builtin_clz(__deg)));
std::copy(vec::_M_impl._M_start, vec::_M_impl._M_finish,
__p._M_impl._M_start);
fft(__p._M_impl._M_start, __p._M_impl._M_finish);
for (auto&& __x : __p) {
_Tp __y = 1;
for (auto __i = __e; __i; __i >>= 1, __x *= __x)
if (__i & 1) __y *= __x;
__x = __y;
}
ifft(__p._M_impl._M_start, __p._M_impl._M_finish);
__p.resize(__deg + 1);
return __p;
}
poly rev() const noexcept { return rev(size()); }
poly rev(size_type __n) const noexcept {
poly __r(__n);
auto __src = vec::_M_impl._M_start;
auto __dst = __r._M_impl._M_finish;
for (size_type __i = std::min(__n, size()); __i; --__i) *--__dst = *__src++;
return __r;
}
poly inv() const noexcept { return inv(size()); }
/**
* @brief Multiplicative inverse modulo x^n.
*
* @param __n Degree of modulus
* @return
*/
poly inv(size_type __n) const noexcept {
if (!__n) return {};
assert(*vec::_M_impl._M_start != _Tp(0));
size_type __len = 1;
while (__len < __n) __len <<= 1;
poly __y(__len);
auto __xp = new _Tp[__len], __yp = __y._M_impl._M_start,
__zp = new _Tp[__len];
*__yp = _Tp(1) / *vec::_M_impl._M_start;
for (size_type __i = 1; __i != __len; __i <<= 1) {
std::fill(std::copy_n(__yp, __i, __zp), __zp + (__i << 1), _Tp(0));
_dft(__zp, __zp + (__i << 1));
std::fill(
std::copy_n(vec::_M_impl._M_start, std::min(__i << 1, size()), __xp),
__xp + (__i << 1), _Tp(0));
_dft(__xp, __xp + (__i << 1));
for (size_type __j = 0; __j != (__i << 1); ++__j) __xp[__j] *= -__zp[__j];
_idft(__xp, __xp + (__i << 1));
std::fill(std::move(__xp + __i, __xp + (__i << 1), __xp),
__xp + (__i << 1), _Tp(0));
_dft(__xp, __xp + (__i << 1));
for (size_type __j = 0; __j != (__i << 1); ++__j)
__xp[__j] *= static_cast<_Tp&&>(__zp[__j]);
_idft(__xp, __xp + (__i << 1));
std::move(__xp, __xp + __i, __yp + __i);
}
delete[] __xp;
delete[] __zp;
__y._M_erase_at_end(__yp + __n);
return __y;
}
poly& operator/=(const poly& __x) noexcept {
if (__x.size() > _Conv_threshold)
_div_doubling(poly(__x));
else
_div_naive(__x);
return *this;
}
poly& operator/=(poly&& __x) noexcept {
if (__x.size() > _Conv_threshold)
_div_doubling(std::move(__x));
else
_div_naive(__x);
return *this;
}
poly& operator%=(const poly& __x) noexcept {
if (__x.size() > _Conv_threshold)
return operator-=(__x.operator*(operator/(__x)));
vec::_M_erase_at_end(vec::_M_impl._M_start + _divmod_naive(__x));
return *this;
}
template <class _T> poly operator+(_T&& __x) const noexcept {
return poly(*this).operator+=(std::forward<_T>(__x));
}
template <class _T> poly operator-(_T&& __x) const noexcept {
return poly(*this).operator-=(std::forward<_T>(__x));
}
template <class _T> poly operator*(_T&& __x) const noexcept {
return poly(*this).operator*=(std::forward<_T>(__x));
}
template <class _T> poly operator/(_T&& __x) const noexcept {
return poly(*this).operator/=(std::forward<_T>(__x));
}
template <class _T> poly operator%(_T&& __x) const noexcept {
return poly(*this).operator%=(std::forward<_T>(__x));
}
std::pair<poly, poly> divmod(const poly& __x) const {
if (__x.size() > _Conv_threshold) return {operator/(__x), operator%(__x)};
poly __rem(*this);
auto __p = __rem._M_impl._M_start + __rem._divmod_naive(__x);
poly __quot(__p, __rem._M_impl._M_finish);
__rem._M_erase_at_end(__p);
return {__quot, __rem};
}
/**
* @brief Differentiate.
*
* @return Derivative.
*/
poly deriv() const noexcept {
if (auto __s = vec::_M_impl._M_start, __f = vec::_M_impl._M_finish;
__s != __f) {
poly __der(++__s, __f);
__s = __der._M_impl._M_start, __f = __der._M_impl._M_finish;
for (_Tp __i(1); __s != __f; ++__s, __i += 1) *__s *= __i;
__der._erase_leading_zeros();
return __der;
}
return {};
}
/**
* @brief Differentiate at given point.
*
* @return Derivative coefficient.
*/
_Tp deriv(const _Tp& __a) const noexcept {
_Tp __der(0);
if (auto __s = vec::_M_impl._M_start, __f = vec::_M_impl._M_finish;
__s != __f)
for (_Tp __i(1), __p(1); ++__s != __f; __i += 1, __p *= __a)
__der += *__s * __i * __p;
return __der;
}
/**
* @brief Integrate.
*
* @return Integral indefinite at the degrees divisible by the characteristic
* of `_Tp`. Coefficients are set as 0 there.
*/
poly integ() const noexcept {
if (auto __s = vec::_M_impl._M_start, __f = vec::_M_impl._M_finish;
__s != __f) {
poly __int(__f - __s + 1);
__f = std::copy(__s, __f, __int._M_impl._M_start + 1);
__s = __int._M_impl._M_start + 1;
for (_Tp __i(1); __s != __f; ++__s, __i += 1)
__i == _Tp(0) ? assert(*__s == _Tp(0)) : void(*__s /= __i);
return __int;
}
return {};
}
/**
* @brief Integrate in given range.
*
* @return Definite integral over [0, __a].
*/
_Tp integ(const _Tp& __a) const noexcept {
_Tp __int(0);
auto __s = vec::_M_impl._M_start, __f = vec::_M_impl._M_finish;
for (_Tp __p(__a), __i(1); __s != __f; ++__s, __p *= __a, __i += 1)
__int += *__s / __i * __p;
return __int;
}
/**
* @brief Integrate in given range.
*
* @return Definite integral over [__a, __b].
*/
_Tp integ(const _Tp& __a, const _Tp& __b) const noexcept {
_Tp __int(0);
auto __s = vec::_M_impl._M_start, __f = vec::_M_impl._M_finish;
for (_Tp __pa(__a), __pb(__b), __i(1); __s != __f;
++__s, __pa *= __a, __pb *= __b, __i += 1)
__int += *__s / __i * (__pb - __pa);
return __int;
}
/**
* @brief
*
* @param __a
* @return f(x + a)
*/
poly shift(const _Tp& __a) const noexcept {
size_type __n = size();
poly __s(*this), __e(__n);
_Tp __cs(1), __ce(1);
for (size_type __i{0}; __i != __n;
__cs *= _Tp(++__i), __ce *= __a / _Tp(__i))
__s[__i] *= __cs, __e[__n - 1 - __i] = __ce;
__s *= std::move(__e);
__ce = 1;
for (size_type __i{0}; __i != __n; __ce /= _Tp(++__i))
__e[__i] = __s[__n - 1 + __i] * __ce;
return __e;
}
};
template <class _Tp, size_t _C>
std::vector<typename polynomial<_Tp, _C>::field> polynomial<_Tp, _C>::__work1;
template <class _Tp, size_t _C>
std::vector<typename polynomial<_Tp, _C>::field> polynomial<_Tp, _C>::__work2;
/**
* @brief Generating function of the sum of k-th powers of the first n
* non-negative integers. O(d \\log d) time in modulo x^d.
*
* @return \\sum_{k=0}^{d-1} x^k \\sum_{i=0}^{n-1} i^k.
*/
template <class _Tp> polynomial<_Tp> power_sum(_Tp __n, std::size_t __d) {
if (!__d) return {};
polynomial<_Tp> __f(__d), __e(__d);
__f[0] = __n;
for (std::size_t __i = 1; __i != __d; ++__i) __f[__i] = __f[__i - 1] * __n;
_Tp __c{1};
for (std::size_t __i = 0; __i != __d; ++__i)
__c /= __i + 1, __f[__i] *= __c, __e[__i] = __c;
(__f *= __e.inv(__d)).resize(__d);
__c = 1;
for (std::size_t __i = 0; __i != __d; __c *= ++__i) __f[__i] *= __c;
return __f;
}
} // namespace workspace
#line 3 "other-workspace\\tmp2.cc"
namespace workspace {
using mint = modint<998244353, 1 << 20>;
using poly = polynomial<mint>;
} // namespace workspace
#line 2 "Library\\src\\combinatorics\\binomial.hpp"
/**
* @file binomial.hpp
* @brief Binomial Coefficient
*/
#line 9 "Library\\src\\combinatorics\\binomial.hpp"
#line 2 "Library\\src\\combinatorics\\factorial.hpp"
/**
* @file factorial.hpp
* @brief Factorial
*/
#line 9 "Library\\src\\combinatorics\\factorial.hpp"
namespace workspace {
// Factorial.
template <class _Tp, class _X = int_least64_t> _Tp factorial(_X __x) noexcept {
if (__x < 0) return 0;
static std::vector<_Tp> __t{1};
static size_t __i = (__t.reserve(0x1000000), 0);
while (__i < size_t(__x)) __t.emplace_back(__t.back() * _Tp(++__i));
return __t[__x];
}
// Inverse of factorial.
template <class _Tp, class _X = int_least64_t>
_Tp inverse_factorial(_X __x) noexcept {
if (__x < 0) return 0;
static std::vector<_Tp> __t{1};
static size_t __i = (__t.reserve(0x1000000), 0);
while (__i < size_t(__x)) __t.emplace_back(__t.back() / _Tp(++__i));
return __t[__x];
}
} // namespace workspace
#line 11 "Library\\src\\combinatorics\\binomial.hpp"
namespace workspace {
namespace _binom_impl {
struct _binom_table {
constexpr static int size = 132;
__uint128_t __b[size][size]{1};
constexpr _binom_table() noexcept {
for (int __i = 1; __i != size; ++__i)
for (int __j = 0; __j != __i; ++__j)
__b[__i][__j] += __b[__i - 1][__j],
__b[__i][__j + 1] += __b[__i - 1][__j];
}
constexpr auto operator()(int __x, int __y) const noexcept {
return __x < 0 || __x < __y ? 0 : (assert(__x < size), __b[__x][__y]);
}
};
constexpr _binom_table table;
} // namespace _binom_impl
/**
* @brief Binomial coefficient for integer args. Be careful with overflow.
*/
template <class _Tp, class _X = int_fast64_t, class _Y = int_fast64_t>
constexpr _Tp binomial(_X __x, _Y __y) {
if constexpr (is_integral_ext<_Tp>::value)
return _binom_impl::table(__x, __y);
if (__y < 0 || __x < __y) return 0;
return factorial<_Tp>(__x) * inverse_factorial<_Tp>(__y) *
inverse_factorial<_Tp>(__x - __y);
}
/**
* @brief Catalan number.
*/
template <class _Tp, class _X = int_fast64_t> constexpr _Tp catalan(_X __x) {
return __x < 0
? _Tp(0)
: binomial<_Tp>(__x << 1, __x) - binomial<_Tp>(__x << 1, __x + 1);
}
} // namespace workspace
#line 9 "other-workspace\\tmp2.cc"
namespace workspace {
auto fact = factorial<mint>;
auto ifact = inverse_factorial<mint>;
auto binom = binomial<mint>;
} // namespace workspace
#include <bits/stdc++.h>
int main() {
using namespace workspace;
using namespace std;
string S;
int A, B, C, D, E, F;
cin >> S >> A >> B >> C;
D = E = F = 0;
for (auto e : S) {
switch (e) {
case 'a': {
// A--;
D++;
} break;
case 'b': {
// B--;
E++;
} break;
case 'c': {
// C--;
F++;
} break;
}
}
poly e(C - F + 1), f(A + B + C);
for (auto l = 0; l <= C - F; ++l) {
e[l] = ifact(l) * ifact(C - l);
}
for (auto l = 0; l < f.size(); ++l) {
f[l] = fact(l) * fact(A + B + C - l - 1);
}
auto ef = e * f;
poly a(A - D + 1), b(B - E + 1);
for (auto i = 0; i <= A - D; ++i) {
if (E)
a[i] = binom(i + E - 1, i);
else
a[i] = i == 0;
a[i] *= ifact(A - D - i);
}
for (auto i = 0; i <= B - E; ++i) {
if (D)
b[i] = binom(i + D - 1, i);
else
b[i] = i == 0;
b[i] *= ifact(B - E - i);
}
auto ab = a * b;
for (auto i = 0; i < ab.size(); ++i) {
ab[i] *= fact(A - D + B - E - i);
}
mint ans;
for (auto i = 0; i < ab.size(); ++i) {
auto k = i + D + E;
if (k) {
ans += ef[A + B + C - k] * ifact(k - 1) * ifact(A + B - k) * ab[i];
} else {
ans += binom(C + A + B - k, C) * ab[i];
}
}
cout << ans << "\n";
}