結果
| 問題 | No.1145 Sums of Powers |
| ユーザー |
 jell
|
| 提出日時 | 2021-03-03 03:22:00 |
| 言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
AC
|
| 実行時間 | 633 ms / 2,000 ms |
| コード長 | 39,610 bytes |
| コンパイル時間 | 3,435 ms |
| コンパイル使用メモリ | 283,736 KB |
| 実行使用メモリ | 14,720 KB |
| 最終ジャッジ日時 | 2024-10-03 03:05:55 |
| 合計ジャッジ時間 | 5,952 ms |
|
ジャッジサーバーID （参考情報） |
judge1 / judge5 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 2 ms
5,248 KB |
| testcase_01 | AC | 2 ms
5,248 KB |
| testcase_02 | AC | 5 ms
5,248 KB |
| testcase_03 | AC | 633 ms
14,592 KB |
| testcase_04 | AC | 603 ms
14,720 KB |
| testcase_05 | AC | 596 ms
14,720 KB |
ソースコード
#line 1 "other/y.cc"
// #undef _GLIBCXX_DEBUG
// #define NDEBUG
#include <bits/extc++.h>
#line 2 "Library/dev/fraction.hpp"
/**
* @file rational.hpp
* @brief Rational
*/
namespace workspace {
template <class _Tp> struct rational {
_Tp __num{0}, __den{1};
constexpr rational() = default;
constexpr rational(const _Tp &__x) : __num(__x) {}
constexpr rational(const _Tp &__x, const _Tp __y) : __num(__x), __den(__y) {}
constexpr rational operator+() const noexcept { return *this; }
constexpr rational operator-() const noexcept { return {-__num, __den}; }
constexpr rational operator+(const rational &__x) const noexcept {
return {__num * __x.__den + __x.__num * __den, __den * __x.__den};
}
constexpr rational operator-(const rational &__x) const noexcept {
return {__num * __x.__den - __x.__num * __den, __den * __x.__den};
}
constexpr rational operator+=(const rational &__x) noexcept {
(__num *= __x.__den) += __den * __x.__num;
__den *= __x.__den;
return *this;
}
constexpr rational operator-=(const rational &__x) noexcept {
(__num *= __x.__den) -= __den * __x.__num;
__den *= __x.__den;
return *this;
}
constexpr bool operator==(const rational &__x) const noexcept {
return __num == __x.__num && __den == __x.den;
}
constexpr bool operator!=(const rational &__x) const noexcept {
return __num != __x.__num || __den != __x.den;
}
constexpr bool operator<(const rational &__x) const noexcept;
private:
constexpr void normalize();
};
} // namespace workspace
#line 2 "Library/src/algebra/polynomial.hpp"
/**
* @file polynomial.hpp
* @brief Polynomial
* @date 2021-02-19
*
*
*/
#line 14 "Library/src/algebra/polynomial.hpp"
#line 2 "Library/src/algebra/ntt.hpp"
/**
* @file ntt.hpp
* @brief Number Theoretic Transform
* @date 2021-02-20
*
*
*/
#line 2 "Library/src/number_theory/ext_gcd.hpp"
/**
* @file ext_gcd.hpp
* @brief Extended Euclidean Algorithm
*/
#line 9 "Library/src/number_theory/ext_gcd.hpp"
#line 2 "Library/src/utils/sfinae.hpp"
/**
* @file sfinae.hpp
* @brief SFINAE
*/
#line 10 "Library/src/utils/sfinae.hpp"
#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; };
#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 = std::nullptr_t>
struct has_begin : std::false_type {};
template <class _Tp>
struct has_begin<_Tp, decltype(std::begin(std::declval<_Tp>()), nullptr)>
: std::true_type {};
template <class _Tp, class = std::nullptr_t>
struct has_mod : std::false_type {};
template <class _Tp>
struct has_mod<_Tp, decltype(_Tp::mod, nullptr)> : 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;
};
} // namespace workspace
#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), 0 <= x <
* |b/g|, -|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) {
static_assert(is_integral_ext<_T1>::value);
static_assert(is_integral_ext<_T2>::value);
using result_type = typename std::make_signed<
typename std::common_type<_T1, _T2>::type>::type;
result_type a{__a}, b{__b}, p{1}, q{}, r{}, s{1};
// Euclidean algorithm
while (b) {
result_type t = a / b;
r ^= p ^= r ^= p -= t * r;
s ^= q ^= s ^= q -= t * s;
b ^= a ^= b ^= a -= t * b;
}
// Normalize
if (a < 0) p = -p, q = -q;
if (p < 0) p += __b / a, q -= __a / a;
return std::make_pair(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 13 "Library/src/algebra/ntt.hpp"
namespace workspace {
namespace ntt_impl {
/**
* @see
* https://github.com/atcoder/ac-library/blob/master/atcoder/convolution.hpp
*/
template <class _Tp> struct __coef {
_Tp sum_e[30]; // sum_e[i] = ies[0] * ... * ies[i - 1] * es[i]
constexpr __coef() : sum_e{} {
if (_Tp::mod < 2) return;
int cnt2 = __builtin_ctz(_Tp::mod - 1);
_Tp e = 1;
{
auto p = (_Tp::mod - 1) >> cnt2;
_Tp w = primitive_root(_Tp::mod);
while (p) {
if (p & 1) e *= w;
p >>= 1;
w *= w;
}
}
_Tp ie = ext_gcd(decltype(_Tp::mod)(e), _Tp::mod).first;
_Tp es[30] = {}, ies[30] = {}; // es[i]^(2^(2+i)) == 1
for (int i = cnt2; i >= 2; i--) {
// e^(2^i) == 1
es[i - 2] = e;
ies[i - 2] = ie;
e *= e;
ie *= ie;
}
_Tp now = 1;
for (int i = 0; i <= cnt2 - 2; i++) {
sum_e[i] = es[i] * now;
now *= ies[i];
}
}
};
template <class _Tp> struct __icoef {
_Tp sum_ie[30]; // sum_e[i] = ies[0] * ... * ies[i - 1] * es[i]
constexpr __icoef() : sum_ie{} {
if (_Tp::mod < 2) return;
int cnt2 = __builtin_ctz(_Tp::mod - 1);
_Tp e = 1;
{
auto p = (_Tp::mod - 1) >> cnt2;
_Tp w = primitive_root(_Tp::mod);
while (p) {
if (p & 1) e *= w;
p >>= 1;
w *= w;
}
}
_Tp ie = ext_gcd(decltype(_Tp::mod)(e), _Tp::mod).first;
_Tp es[30] = {}, ies[30] = {}; // es[i]^(2^(2+i)) == 1
for (int i = cnt2; i >= 2; i--) {
// e^(2^i) == 1
es[i - 2] = e;
ies[i - 2] = ie;
e *= e;
ie *= ie;
}
_Tp now = 1;
for (int i = 0; i <= cnt2 - 2; i++) {
sum_ie[i] = ies[i] * now;
now *= es[i];
}
}
};
template <class _Tp> struct __ipow2 {
_Tp __ip2[30];
constexpr __ipow2() : __ip2{1, (1 + _Tp::mod) / 2} {
for (size_t __i = 1; __i + 1 != std::size(__ip2); ++__i)
__ip2[__i + 1] = __ip2[__i] * __ip2[1];
}
};
template <class _FIter>
constexpr void ntt(_FIter __first, _FIter __last) noexcept {
using value_type = typename std::decay<decltype(*__first)>::type;
constexpr __coef<value_type> _;
auto __h = __builtin_ctz(std::distance(__first, __last));
for (ptrdiff_t __p = 1 << __h; __p >>= 1;) {
value_type now = -1;
auto __l = __first;
for (size_t __s = 1 << __h; __l != __last;
now *= _.sum_e[__builtin_ctz(--__s)]) {
auto __r = __l + __p;
for (auto __mid = __r; __l != __mid; ++__l, ++__r) {
auto __tmp = *__l;
*__l -= *__r *= now;
*__r += __tmp;
}
__l = __r;
}
}
}
template <class _A> constexpr void ntt(_A &a) noexcept {
ntt(std::begin(a), std::end(a));
}
template <class _FIter>
constexpr void intt(_FIter __first, _FIter __last) noexcept {
using value_type = typename std::decay<decltype(*__first)>::type;
constexpr __icoef<value_type> _;
auto __h = __builtin_ctz(std::distance(__first, __last));
for (ptrdiff_t __p = 1; __p >> __h ^ 1; __p <<= 1) {
value_type inow = 1;
auto __l = __first;
for (size_t __s = 1 << __h; __l != __last;
inow *= _.sum_ie[__builtin_ctz(--__s)]) {
auto __r = __l + __p;
for (auto __mid = __r; __l != __mid; ++__l, ++__r) {
auto __tmp = (*__l - *__r) * inow;
*__l += *__r;
*__r = __tmp;
}
__l = __r;
}
}
constexpr __ipow2<value_type> __;
while (__first != __last) *--__last *= __.__ip2[__h];
} // namespace ntt_impl
template <class _A> constexpr void intt(_A &a) noexcept {
intt(std::begin(a), std::end(a));
}
} // namespace ntt_impl
using ntt_impl::intt;
using ntt_impl::ntt;
} // namespace workspace
#line 17 "Library/src/algebra/polynomial.hpp"
namespace workspace {
/**
* @brief Polynomial class.
*
* @tparam _Tp Ring structure
* @tparam _Conv_threshold Threshold for convolution method
*/
template <class _Tp, std::size_t _Conv_threshold = 60>
class polynomial : public std::vector<_Tp> {
using vector = std::vector<_Tp>;
using poly = polynomial;
public:
using vector::vector;
using size_type = typename vector::size_type;
protected:
void _erase_leading_zeros() noexcept {
auto __i = vector::_M_impl._M_finish;
while (__i != vector::_M_impl._M_start && *(__i - 1) == _Tp(0)) --__i;
vector::_M_erase_at_end(__i);
}
void _conv_naive(const poly& __x) noexcept {
if (__x._M_impl._M_start == __x._M_impl._M_finish)
vector::_M_erase_at_end(vector::_M_impl._M_start);
else {
vector::_M_default_append(__x._M_impl._M_finish - __x._M_impl._M_start -
1);
for (auto __i = vector::_M_impl._M_finish;
__i-- != vector::_M_impl._M_start;) {
auto __j = __i, __k = __x._M_impl._M_start;
*__i *= *__k++;
while (__j != vector::_M_impl._M_start && __k != __x._M_impl._M_finish)
*__i += *--__j * *__k++;
}
}
}
void _conv_fft(poly&& __x) noexcept {
if constexpr (has_mod<_Tp>::value)
_conv_ntt(std::move(__x));
else {
assert(0); // Not implemented!
}
}
void _conv_ntt(poly&& __x) noexcept {
size_type __n = vector::_M_impl._M_finish - vector::_M_impl._M_start,
__m = __x._M_impl._M_finish - __x._M_impl._M_start,
__len = 1 << (32 - __builtin_clz(__n + __m - 1));
vector::_M_default_append(__len - __n);
__x._M_default_append(__len - __m);
ntt(vector::_M_impl._M_start, vector::_M_impl._M_finish);
ntt(__x._M_impl._M_start, __x._M_impl._M_finish);
for (auto __i = vector::_M_impl._M_start, __j = __x._M_impl._M_start;
__i != vector::_M_impl._M_finish; ++__i, ++__j)
*__i *= std::move(*__j);
intt(vector::_M_impl._M_start, vector::_M_impl._M_finish);
vector::_M_erase_at_end(vector::_M_impl._M_start + __n + __m - 1);
}
/**
* @brief
*
* @param __x
* @return Degree of __x.
*/
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 = vector::_M_impl._M_finish;
while (size_type(__p - vector::_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 - vector::_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 = vector::_M_impl._M_finish - vector::_M_impl._M_start;
auto __m = __x._M_impl._M_finish - __x._M_impl._M_start;
if (__n < __m)
vector::clear();
else {
assert(__m != 0);
std::reverse(__x._M_impl._M_start, __x._M_impl._M_finish);
__x = __x.inv(__m);
if (size_type(__n - __m + 1) < __x.size()) __x.resize(__n - __m + 1);
std::reverse(vector::_M_impl._M_start, vector::_M_impl._M_finish);
vector::_M_erase_at_end(vector::_M_impl._M_finish - (__m - 1));
operator*=(__x).resize(__n - __m + 1);
std::reverse(vector::_M_impl._M_start, vector::_M_impl._M_finish);
}
}
public:
/**
* @return Degree of %polynomial. Return -1 if it equals zero.
*/
size_type deg() const noexcept { return vector::size() - 1; }
/**
* @param __i Not exceeding the degree.
* @return Coefficient of x^i.
*/
typename vector::reference operator[](size_type __i) noexcept {
assert(__i < vector::size());
return *(vector::_M_impl._M_start + __i);
}
/**
* @param __i Not exceeding the degree.
* @return Coefficient of x^i.
*/
typename vector::const_reference operator[](size_type __i) const noexcept {
assert(__i < vector::size());
return *(vector::_M_impl._M_start + __i);
}
/**
* @brief Evaluate at given point.
*/
_Tp of(const _Tp& __a) const noexcept {
_Tp __v(0), __p(1);
for (auto __i = vector::_M_impl._M_start; __i != vector::_M_impl._M_finish;
++__i, __p *= __a)
__v += *__i * __p;
return __v;
}
operator bool() const noexcept {
auto __first = vector::_M_impl._M_start, __last = vector::_M_impl._M_finish;
while (__first != __last)
if (*__first++ != _Tp(0)) return true;
return false;
}
bool operator==(const poly& __x) const noexcept {
auto __first1 = vector::_M_impl._M_start,
__last1 = vector::_M_impl._M_finish;
auto __first2 = __x._M_impl._M_start, __last2 = __x._M_impl._M_finish;
if (__last1 - __first1 < __last2 - __first2) {
while (__first1 != __last1)
if (*__first1++ != *__first2++) return false;
while (__first2 != __last2)
if (*__first2++ != _Tp(0)) return false;
}
else {
while (__first2 != __last2)
if (*__first1++ != *__first2++) return false;
while (__first1 != __last1)
if (*__first1++ != _Tp(0)) return false;
}
return true;
}
bool operator!=(const poly& __x) const noexcept { return !operator==(__x); }
/**
* @brief Multiply by x^i.
*/
poly& operator<<=(size_type __i) noexcept {
vector::insert(vector::begin(), __i, _Tp(0));
return *this;
}
/**
* @brief Divide by x^i.
*/
poly& operator>>=(size_type __i) noexcept {
vector::_M_erase_at_end(
std::move(vector::_M_impl._M_start + std::min(__i, vector::size()),
vector::_M_impl._M_finish, vector::_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 (vector::size() < __x.size())
vector::_M_default_append(__x.size() - vector::size());
for (auto __i = vector::_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 (vector::_M_impl._M_start == vector::_M_impl._M_finish)
vector::emplace_back(__c);
else
*vector::_M_impl._M_start += __c, _erase_leading_zeros();
}
return *this;
}
poly& operator-=(const poly& __x) noexcept {
if (vector::size() < __x.size())
vector::_M_default_append(__x.size() - vector::size());
for (auto __i = vector::_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 (vector::_M_impl._M_start == vector::_M_impl._M_finish)
vector::emplace_back(-__c);
else
*vector::_M_impl._M_start -= __c, _erase_leading_zeros();
}
return *this;
}
poly& operator*=(const poly& __x) noexcept {
std::min(vector::size(), __x.size()) > _Conv_threshold
? _conv_fft(poly(__x))
: _conv_naive(this == &__x ? poly(__x) : __x);
return *this;
}
poly& operator*=(poly&& __x) noexcept {
std::min(vector::size(), __x.size()) > _Conv_threshold
? _conv_fft(std::move(__x))
: _conv_naive(__x);
return *this;
}
poly& operator*=(const _Tp& __c) noexcept {
if (__c == static_cast<_Tp>(0))
vector::_M_erase_at_end(vector::_M_impl._M_start);
else
for (auto __i = vector::_M_impl._M_start;
__i != vector::_M_impl._M_finish; ++__i)
*__i *= __c;
return *this;
}
poly& operator/=(const _Tp& __c) noexcept {
assert(__c != static_cast<_Tp>(0));
for (auto __i = vector::_M_impl._M_start; __i != vector::_M_impl._M_finish;
++__i)
*__i /= __c;
return *this;
}
poly rev() const noexcept { return rev(vector::size()); }
poly rev(size_type __n) const noexcept {
poly __r(__n);
auto __src = vector::_M_impl._M_start;
auto __dst = __r._M_impl._M_finish;
for (size_type __i = std::min(__n, vector::size()); __i; --__i)
*--__dst = *__src++;
return __r;
}
poly inv() const noexcept { return inv(vector::size()); }
poly inv(size_type __n) const noexcept {
assert(__n != 0);
assert(*vector::_M_impl._M_start != _Tp(0));
poly __x{_Tp(1) / *vector::_M_impl._M_start};
if (__n == 1) return __x;
for (size_type __i = 2; __i < __n; __i <<= 1) {
poly __y(__i);
std::copy_n(vector::_M_impl._M_start, std::min(__i, vector::size()),
__y._M_impl._M_start);
__y *= __x;
auto __p = __y._M_impl._M_start;
*__p = 2 - *__p;
while (++__p != __y._M_impl._M_finish) *__p = -*__p;
(__x *= std::move(__y)).resize(__i);
}
poly __y = operator*(__x);
auto __p = __y._M_impl._M_start;
*__p = 2 - *__p;
while (++__p != __y._M_impl._M_finish) *__p = -*__p;
(__x *= std::move(__y)).resize(__n);
return __x;
}
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)));
vector::resize(_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 = vector::_M_impl._M_start, __f = vector::_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 = vector::_M_impl._M_start, __f = vector::_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 = vector::_M_impl._M_start, __f = vector::_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 = vector::_M_impl._M_start, __f = vector::_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 = vector::_M_impl._M_start, __f = vector::_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;
}
};
} // namespace workspace
#line 2 "Library/src/modular/modint.hpp"
/**
* @file modint.hpp
*
* @brief Modular Arithmetic
*/
#line 12 "Library/src/modular/modint.hpp"
#line 14 "Library/src/modular/modint.hpp"
namespace workspace {
namespace internal {
/**
* @brief Base of modular arithmetic.
*
* @tparam Mod identifier, which represents modulus if positive
* @tparam Storage Reserved size for inverse calculation
*/
template <auto Mod, unsigned Storage> struct modint_base {
static_assert(is_integral_ext<decltype(Mod)>::value,
"Mod must be integral type.");
using mod_type = typename std::make_signed<typename std::conditional<
0 < Mod, typename std::add_const<decltype(Mod)>::type,
decltype(Mod)>::type>::type;
using value_type = typename std::decay<mod_type>::type;
using mul_type = typename multiplicable_uint<value_type>::type;
static mod_type mod;
static value_type storage;
constexpr static void reserve(unsigned __n) noexcept { storage = __n; }
value_type value = 0;
public:
constexpr modint_base() noexcept = default;
template <class int_type,
typename std::enable_if<is_integral_ext<int_type>::value>::type * =
nullptr>
constexpr modint_base(int_type n) noexcept
: value((n %= mod) < 0 ? n += mod : n) {}
constexpr modint_base(bool n) noexcept : value(n) {}
constexpr operator value_type() const noexcept { return value; }
constexpr static modint_base one() noexcept { return 1; }
// unary operators {{
constexpr modint_base operator++(int) noexcept {
modint_base __t{*this};
operator++();
return __t;
}
constexpr modint_base operator--(int) noexcept {
modint_base __t{*this};
operator--();
return __t;
}
constexpr modint_base &operator++() noexcept {
if (++value == mod) value = 0;
return *this;
}
constexpr modint_base &operator--() noexcept {
if (!value) value = mod;
--value;
return *this;
}
constexpr modint_base operator-() const noexcept {
modint_base __t;
__t.value = value ? mod - value : 0;
return __t;
}
// }} unary operators
// operator+= {{
constexpr modint_base &operator+=(const modint_base &rhs) noexcept {
if ((value += rhs.value) >= mod) value -= mod;
return *this;
}
template <class int_type>
constexpr typename std::enable_if<is_integral_ext<int_type>::value,
modint_base>::type &
operator+=(int_type const &rhs) noexcept {
if (((value += rhs) %= mod) < 0) value += mod;
return *this;
}
// }} operator+=
// operator+ {{
template <class int_type>
constexpr typename std::enable_if<is_integral_ext<int_type>::value,
modint_base>::type
operator+(int_type const &rhs) const noexcept {
return modint_base{*this} += rhs;
}
constexpr modint_base operator+(modint_base rhs) const noexcept {
return rhs += *this;
}
template <class int_type>
constexpr friend typename std::enable_if<is_integral_ext<int_type>::value,
modint_base>::type
operator+(int_type const &lhs, modint_base rhs) noexcept {
return rhs += lhs;
}
// }} operator+
// operator-= {{
constexpr modint_base &operator-=(const modint_base &rhs) noexcept {
if ((value -= rhs.value) < 0) value += mod;
return *this;
}
template <class int_type>
constexpr typename std::enable_if<is_integral_ext<int_type>::value,
modint_base>::type &
operator-=(int_type rhs) noexcept {
if (((value -= rhs) %= mod) < 0) value += mod;
return *this;
}
// }} operator-=
// operator- {{
template <class int_type>
constexpr typename std::enable_if<is_integral_ext<int_type>::value,
modint_base>::type
operator-(int_type const &rhs) const noexcept {
return modint_base{*this} -= rhs;
}
constexpr modint_base operator-(const modint_base &rhs) const noexcept {
modint_base __t;
if (((__t.value = value) -= rhs.value) < 0) __t.value += mod;
return __t;
}
template <class int_type>
constexpr friend typename std::enable_if<is_integral_ext<int_type>::value,
modint_base>::type
operator-(int_type lhs, const modint_base &rhs) noexcept {
if (((lhs -= rhs.value) %= mod) < 0) lhs += mod;
modint_base __t;
__t.value = lhs;
return __t;
}
// }} operator-
// operator*= {{
constexpr modint_base &operator*=(const modint_base &rhs) noexcept {
value = static_cast<mul_type>(value) * rhs.value % mod;
return *this;
}
template <class int_type>
constexpr typename std::enable_if<is_integral_ext<int_type>::value,
modint_base>::type &
operator*=(int_type rhs) noexcept {
if (!rhs)
value = 0;
else if (value) {
if ((rhs %= mod) < 0) rhs += mod;
mul_type __r(value);
value = static_cast<value_type &&>((__r *= rhs) %= mod);
}
return *this;
}
// }} operator*=
// operator* {{
constexpr modint_base operator*(const modint_base &rhs) const noexcept {
modint_base __t;
__t.value = static_cast<mul_type>(value) * rhs.value % mod;
return __t;
}
template <class int_type>
constexpr typename std::enable_if<is_integral_ext<int_type>::value,
modint_base>::type
operator*(int_type rhs) const noexcept {
if (!value or !rhs) return {};
if ((rhs %= mod) < 0) rhs += mod;
mul_type __r(value);
modint_base __t;
__t.value = static_cast<value_type &&>((__r *= rhs) %= mod);
return __t;
}
template <class int_type>
constexpr friend typename std::enable_if<is_integral_ext<int_type>::value,
modint_base>::type
operator*(int_type lhs, const modint_base &rhs) noexcept {
if (!lhs or !rhs.value) return {};
if ((lhs %= mod) < 0) lhs += mod;
mul_type __r(lhs);
modint_base __t;
__t.value = static_cast<value_type &&>((__r *= rhs.value) %= mod);
return __t;
}
// }} 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];
}
template <class int_type>
constexpr static typename std::enable_if<is_integral_ext<int_type>::value,
value_type>::type
_div(mul_type __r, int_type __x) noexcept {
assert(__x);
if (!__r) return 0;
int_type __v{};
bool __neg = __x < 0 ? __x = -__x, true : false;
if (__x < storage)
__v = _mem(__x);
else {
int_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;
if (__r == 1) return static_cast<value_type>(__v);
return static_cast<value_type>((__r *= __v) %= mod);
}
public:
// operator/= {{
constexpr modint_base &operator/=(const modint_base &rhs) noexcept {
if (value) value = _div(value, rhs.value);
return *this;
}
template <class int_type>
constexpr typename std::enable_if<is_integral_ext<int_type>::value,
modint_base>::type &
operator/=(int_type rhs) noexcept {
if (value) value = _div(value, rhs %= mod);
return *this;
}
// }} operator/=
// operator/ {{
constexpr modint_base operator/(const modint_base &rhs) const noexcept {
if (!value) return {};
modint_base __t;
__t.value = _div(value, rhs.value);
return __t;
}
template <class int_type>
constexpr typename std::enable_if<is_integral_ext<int_type>::value,
modint_base>::type
operator/(int_type rhs) const noexcept {
if (!value) return {};
modint_base __t;
__t.value = _div(value, rhs %= mod);
return __t;
}
template <class int_type>
constexpr friend typename std::enable_if<is_integral_ext<int_type>::value,
modint_base>::type
operator/(int_type lhs, const modint_base &rhs) noexcept {
if (!lhs) return {};
if ((lhs %= mod) < 0) lhs += mod;
modint_base __t;
__t.value = _div(lhs, rhs.value);
return __t;
}
// }} operator/
constexpr modint_base inv() const noexcept { return _div(1, value); }
template <class int_type>
friend constexpr typename std::enable_if<is_integral_ext<int_type>::value,
modint_base>::type
pow(modint_base b, int_type e) noexcept {
if (e < 0) {
e = -e;
b.value = _div(1, b.value);
}
modint_base __r;
for (__r.value = 1; e; e >>= 1, b *= b)
if (e & 1) __r *= b;
return __r;
}
template <class int_type>
constexpr typename std::enable_if<is_integral_ext<int_type>::value,
modint_base>::type
pow(int_type e) const noexcept {
modint_base __r, b;
__r.value = 1;
for (b.value = e < 0 ? e = -e, _div(1, value) : value; e; e >>= 1, b *= b)
if (e & 1) __r *= b;
return __r;
}
friend std::ostream &operator<<(std::ostream &os,
const modint_base &rhs) noexcept {
return os << rhs.value;
}
friend std::istream &operator>>(std::istream &is, modint_base &rhs) noexcept {
intmax_t value;
rhs = (is >> value, value);
return is;
}
};
template <auto Mod, unsigned Storage>
typename modint_base<Mod, Storage>::mod_type modint_base<Mod, Storage>::mod =
Mod > 0 ? Mod : 0;
template <auto Mod, unsigned Storage>
typename modint_base<Mod, Storage>::value_type
modint_base<Mod, Storage>::storage = Storage;
} // namespace internal
/**
* @brief Modular arithmetic.
*
* @tparam Mod modulus
* @tparam Storage Reserved size for inverse calculation
*/
template <auto Mod, unsigned Storage = 0,
typename std::enable_if<(Mod > 0)>::type * = nullptr>
using modint = internal::modint_base<Mod, Storage>;
/**
* @brief Runtime modular arithmetic.
*
* @tparam type_id uniquely assigned
* @tparam Storage Reserved size for inverse calculation
*/
template <unsigned type_id = 0, unsigned Storage = 0>
using modint_runtime = internal::modint_base<-(signed)type_id, Storage>;
// #define modint_newtype modint_runtime<__COUNTER__>
} // namespace workspace
#line 2 "Library/src/utils/io/ostream.hpp"
/**
* @file ostream.hpp
* @brief Output Stream
*/
#line 9 "Library/src/utils/io/ostream.hpp"
namespace workspace {
template <class _Os> struct is_ostream {
template <typename... _Args>
static std::true_type __test(std::basic_ostream<_Args...> *);
static std::false_type __test(void *);
constexpr static bool value = decltype(__test(std::declval<_Os *>()))::value;
};
template <class _Os>
using ostream_ref =
typename std::enable_if<is_ostream<_Os>::value, _Os &>::type;
/**
* @brief Stream insertion operator for C-style array.
*
* @param __os Output stream
* @param __a Array
* @return Reference to __os.
*/
template <class _Os, class _Tp, size_t _Nm>
typename std::enable_if<bool(sizeof(_Tp) > 2), ostream_ref<_Os>>::type
operator<<(_Os &__os, const _Tp (&__a)[_Nm]) {
if constexpr (_Nm) {
__os << *__a;
for (auto __i = __a + 1, __e = __a + _Nm; __i != __e; ++__i)
__os << ' ' << *__i;
}
return __os;
}
/**
* @brief Stream insertion operator for std::pair.
*
* @param __os Output stream
* @param __p Pair
* @return Reference to __os.
*/
template <class _Os, class _T1, class _T2>
ostream_ref<_Os> operator<<(_Os &__os, const std::pair<_T1, _T2> &__p) {
return __os << __p.first << ' ' << __p.second;
}
/**
* @brief Stream insertion operator for std::tuple.
*
* @param __os Output stream
* @param __t Tuple
* @return Reference to __os.
*/
template <class _Os, class _Tp, size_t _Nm = 0>
typename std::enable_if<bool(std::tuple_size<_Tp>::value + 1),
ostream_ref<_Os>>::type
operator<<(_Os &__os, const _Tp &__t) {
if constexpr (_Nm != std::tuple_size<_Tp>::value) {
if constexpr (_Nm) __os << ' ';
__os << std::get<_Nm>(__t);
operator<<<_Os, _Tp, _Nm + 1>(__os, __t);
}
return __os;
}
template <class _Os, class _Container,
typename = decltype(std::begin(std::declval<_Container>()))>
typename std::enable_if<
!std::is_same<typename std::decay<_Container>::type, std::string>::value &&
!std::is_same<typename std::decay<_Container>::type, char *>::value,
ostream_ref<_Os>>::type
operator<<(_Os &__os, const _Container &__cont) {
bool __h = true;
for (auto &&__e : __cont) __h ? __h = 0 : (__os << ' ', 0), __os << __e;
return __os;
}
#ifdef __SIZEOF_INT128__
/**
* @brief Stream insertion operator for __int128_t.
*
* @param __os Output Stream
* @param __x 128-bit integer
* @return Reference to __os.
*/
template <class _Os> ostream_ref<_Os> operator<<(_Os &__os, __int128_t __x) {
if (!__x) return __os << '0';
if (__x < 0) __os << '-';
char __s[40], *__p = __s;
while (__x) {
auto __d = __x % 10;
*__p++ = '0' + (__x < 0 ? -__d : __d);
__x /= 10;
}
*__p = 0;
for (char *__t = __s; __t < --__p; ++__t) *__t ^= *__p ^= *__t ^= *__p;
return __os << __s;
}
/**
* @brief Stream insertion operator for __uint128_t.
*
* @param __os Output Stream
* @param __x 128-bit unsigned integer
* @return Reference to __os.
*/
template <class _Os> ostream_ref<_Os> operator<<(_Os &__os, __uint128_t __x) {
if (!__x) return __os << '0';
char __s[40], *__p = __s;
while (__x) *__p++ = '0' + __x % 10, __x /= 10;
*__p = 0;
for (char *__t = __s; __t < --__p; ++__t) *__t ^= *__p ^= *__t ^= *__p;
return __os << __s;
}
#endif
} // namespace workspace
#line 9 "other/y.cc"
namespace workspace {
using mint = modint<998244353>;
void main() {
// start here!
std::cin.tie(0)->sync_with_stdio(0);
size_t n, m;
std::cin >> n >> m;
std::queue<rational<polynomial<mint>>> q;
while (n--) {
int a;
std::cin >> a;
q.push({{1}, {1, -a}});
}
while (q.size() > 1) {
auto t = q.front();
q.pop();
q.emplace(t += q.front());
q.pop();
}
auto& [a, b] = q.back();
a *= b.inv(m + 1);
for (size_t i = 1; i <= m; ++i) {
if (i > 1) std::cout << ' ';
if (a.size() > i)
std::cout << a[i];
else
std::cout << '0';
}
std::cout << '\n';
}
} // namespace workspace
int main() { workspace::main(); }