結果
| 問題 | No.2817 Competition |
| ユーザー |
 minato
|
| 提出日時 | 2024-07-27 17:42:45 |
| 言語 | C++23 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
AC
|
| 実行時間 | 450 ms / 2,000 ms |
| コード長 | 25,973 bytes |
| コンパイル時間 | 4,381 ms |
| コンパイル使用メモリ | 238,036 KB |
| 実行使用メモリ | 29,812 KB |
| 最終ジャッジ日時 | 2024-07-27 17:42:58 |
| 合計ジャッジ時間 | 11,955 ms |
|
ジャッジサーバーID （参考情報） |
judge2 / judge5 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 2 ms
5,248 KB |
| testcase_01 | AC | 2 ms
5,248 KB |
| testcase_02 | AC | 2 ms
5,376 KB |
| testcase_03 | AC | 450 ms
28,608 KB |
| testcase_04 | AC | 442 ms
29,296 KB |
| testcase_05 | AC | 413 ms
29,812 KB |
| testcase_06 | AC | 416 ms
29,808 KB |
| testcase_07 | AC | 442 ms
29,812 KB |
| testcase_08 | AC | 48 ms
6,720 KB |
| testcase_09 | AC | 94 ms
9,876 KB |
| testcase_10 | AC | 146 ms
13,272 KB |
| testcase_11 | AC | 257 ms
19,540 KB |
| testcase_12 | AC | 2 ms
5,376 KB |
| testcase_13 | AC | 106 ms
10,736 KB |
| testcase_14 | AC | 194 ms
14,428 KB |
| testcase_15 | AC | 86 ms
9,508 KB |
| testcase_16 | AC | 179 ms
15,716 KB |
| testcase_17 | AC | 119 ms
11,400 KB |
| testcase_18 | AC | 432 ms
28,736 KB |
| testcase_19 | AC | 2 ms
5,376 KB |
| testcase_20 | AC | 2 ms
5,376 KB |
| testcase_21 | AC | 2 ms
5,376 KB |
| testcase_22 | AC | 2 ms
5,376 KB |
| testcase_23 | AC | 2 ms
5,376 KB |
ソースコード
#line 2 "library-cpp/mod/atcoder_modint_header.hpp"
#include <istream>
#include <ostream>
#include <atcoder/modint>
template <int M>
std::istream& operator>>(std::istream& is, atcoder::static_modint<M>& m) {
long long x;
is >> x;
m = x;
return is;
}
template <int M>
std::ostream& operator<<(std::ostream& os, const atcoder::static_modint<M>& m) {
return os << m.val();
}
#line 1 "library-cpp/other/template.hpp"
// clang-format off
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <deque>
#include <forward_list>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <optional>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
using i128 = __int128_t;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
template <class T> using maxheap = priority_queue<T>;
template <class T> using minheap = priority_queue<T, vector<T>, greater<T>>;
template <class T> using vec = vector<T>;
template <class T> using vvec = vector<vector<T>>;
#define OVERLOAD_REP(_1, _2, _3, name, ...) name
#define REP0(n) for (auto minato = decay_t<decltype(n)>{}; minato < (n); ++minato)
#define REP1(i, n) for (auto i = decay_t<decltype(n)>{}; (i) < (n); (i)++)
#define REP2(i, l, r) for (auto i = (l); (i) < (r); (i)++)
#define rep(...) OVERLOAD_REP(__VA_ARGS__, REP2, REP1, REP0)(__VA_ARGS__)
#define OVERLOAD_RREP(_1, _2, _3, name, ...) name
#define RREP1(i, n) for (auto i = (n) - 1; (i) >= decay_t<decltype(n)>{}; (i)--)
#define RREP2(i, l, r) for (auto i = (r) - 1; (i) >= (l); (i)--)
#define rrep(...) OVERLOAD_RREP(__VA_ARGS__, RREP2, RREP1)(__VA_ARGS__)
#define ALL(x) begin(x), end(x)
template <class Container> int SZ(const Container& v) { return int(v.size()); }
template <class T> void UNIQUE(vector<T>& v) { v.erase(unique(v.begin(), v.end()), v.end()); }
template <class T> T MAX(const vector<T>& v) { return *max_element(v.begin(), v.end()); }
template <class T> T MIN(const vector<T>& v) { return *min_element(v.begin(), v.end()); }
template <class T> T SUM(const vector<T>& v) { return accumulate(v.begin(), v.end(), T(0)); }
template <class T> T ABS(T x) { return max(x, -x); }
template <class T> constexpr T POW(T x, ull n) { T ret = 1; while (n > 0) { if (n & 1) ret *= x; x *= x; n >>= 1; } return ret; }
template <class T> constexpr T POW(T x, ull n, T mod) { T ret = 1; while (n > 0) { if (n & 1) ret = ret * x % mod; x = x * x % mod; n >>= 1; } return ret; }
constexpr long long floor_div(long long n, long long d) { return n / d - ((n ^ d) < 0 && n % d); }
template <class T1, class T2> bool chmax(T1& a, T2 b) { if (a < b) { a = b; return true; } return false; }
template <class T1, class T2> bool chmin(T1& a, T2 b) { if (a > b) { a = b; return true; } return false; }
int topbit(ull x) { return x == 0 ? -1 : 63 - __builtin_clzll(x); }
int botbit(ull x) { return x == 0 ? 64 : __builtin_ctzll(x); }
int popcount(ull x) { return __builtin_popcountll(x); }
int kthbit(ull x, int k) { return (x >> k) & 1; }
int popparity(ull x) { return __builtin_parityll(x); }
int parity_sign(ull x) { return (x & 1) ? -1 : 1; }
constexpr long long TEN(int x) { return x == 0 ? 1 : TEN(x - 1) * 10; }
template <typename S> void rearrange(const vector<S>& id) { (void)id; }
template <typename S, typename T> void rearrange_exec(const vector<S>& id, vector<T>& v) { vector<T> w(v.size()); for (size_t i = 0; i < id.size(); i++) { w[i] = v[id[i]]; } v.swap(w); }
template <typename S, typename Head, typename... Tail> void rearrange(const vector<S>& id, Head& a, Tail& ...tail) { rearrange_exec(id, a); rearrange(id, tail...); }
template <class T>
vector<vector<T>> rot90(const vector<vector<T>>& v) {
int n = v.size(), m = v[0].size();
vector<vector<T>> ret(m, vector<T>(n));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
ret[m - 1 - j][i] = v[i][j];
}
}
return ret;
}
istream& operator>>(istream& is, __int128_t& x) {
x = 0;
string s;
is >> s;
int n = int(s.size()), it = 0;
if (s[0] == '-') it++;
for (; it < n; it++) x = (x * 10 + s[it] - '0');
if (s[0] == '-') x = -x;
return is;
}
ostream& operator<<(ostream& os, __int128_t x) {
if (x == 0) return os << 0;
if (x < 0) os << '-', x = -x;
deque<int> deq;
while (x) deq.emplace_front(x % 10), x /= 10;
for (int e : deq) os << e;
return os;
}
template <class T> vector<T> &operator++(vector<T>& v) { for (auto& e : v) { e++; } return v;}
template <class T> vector<T> operator++(vector<T>& v, int) { auto res = v; for (auto& e : v) { e++; } return res; }
template <class T> vector<T> &operator--(vector<T>& v) { for (auto& e : v) { e--; } return v; }
template <class T> vector<T> operator--(vector<T>& v, int) { auto res = v; for (auto& e : v) { e--; } return res; }
template <class T1, class T2> pair<T1, T2> operator-(const pair<T1, T2>& x) { return pair<T1, T2>(-x.first, -x.second); }
template <class T1, class T2> pair<T1, T2> operator-(const pair<T1, T2>& x, const pair<T1, T2>& y) { return pair<T1, T2>(x.first - y.first, x.second - y.second); }
template <class T1, class T2> pair<T1, T2> operator+(const pair<T1, T2>& x, const pair<T1, T2>& y) { return pair<T1, T2>(x.first + y.first, x.second + y.second); }
template <class T1, class T2> pair<T1, T2> operator+=(pair<T1, T2>& l, const pair<T1, T2>& r) { return l = l + r; }
template <class T1, class T2> pair<T1, T2> operator-=(pair<T1, T2>& l, const pair<T1, T2>& r) { return l = l - r; }
constexpr char ln = '\n';
const string YESNO[2] = {"NO", "YES"};
const string YesNo[2] = {"No", "Yes"};
void YES(bool t = true) { cout << YESNO[t] << "\n"; }
void NO(bool t = 1) { YES(!t); }
void Yes(bool t = true) { cout << YesNo[t] << "\n"; }
void No(bool t = 1) { Yes(!t); }
template <class T> void drop(T x) { cout << x << "\n"; exit(0); }
#define INT(...) \
int __VA_ARGS__; \
IN(__VA_ARGS__)
#define LL(...) \
ll __VA_ARGS__; \
IN(__VA_ARGS__)
#define STR(...) \
string __VA_ARGS__; \
IN(__VA_ARGS__)
#define CHR(...) \
char __VA_ARGS__; \
IN(__VA_ARGS__)
#define LDB(...) \
long double __VA_ARGS__; \
IN(__VA_ARGS__)
#define VEC(type, name, size) \
vector<type> name(size); \
IN(name)
#define VEC2(type, name1, name2, size) \
vector<type> name1(size), name2(size); \
for (int i = 0; i < size; i++) IN(name1[i], name2[i])
#define VEC3(type, name1, name2, name3, size) \
vector<type> name1(size), name2(size), name3(size); \
for (int i = 0; i < size; i++) IN(name1[i], name2[i], name3[i])
#define VEC4(type, name1, name2, name3, name4, size) \
vector<type> name1(size), name2(size), name3(size), name4(size); \
for (int i = 0; i < size; i++) IN(name1[i], name2[i], name3[i], name4[i]);
#define VV(type, name, N, M) \
vector<vector<type>> name(N, vector<type>(M)); \
IN(name)
template <class T> void scan(T& a) { cin >> a; }
template <class T> void scan(vector<T>& a) { for (auto& i : a) scan(i); }
void IN() {}
template <class Head, class... Tail> void IN(Head& head, Tail&... tail) { scan(head); IN(tail...); }
std::vector<std::vector<int>> read_graph(int N, int M) {
std::vector<std::vector<int>> g(N);
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
a--, b--;
g[a].emplace_back(b);
g[b].emplace_back(a);
}
return g;
}
std::vector<std::vector<int>> read_tree(int N) { return read_graph(N, N - 1); }
void print() { cout << "\n"; }
template <class T> void print(const vector<T>& v) { for (auto it = v.begin(); it != v.end(); ++it) { if (it != v.begin()) { cout << " "; } cout << *it; } print(); }
template <class T, class... Args> void print(const T& x, const Args& ... args) { cout << x; if (sizeof...(Args)) cout << " "; print(args...); }
#ifdef MINATO_LOCAL
template <class T1, class T2> ostream& operator<<(ostream& os, pair<T1, T2> p);
template <class ...Args> ostream& operator<<(ostream& os, tuple<Args...> t);
template <class T> ostream& operator<<(ostream& os, vector<T> v);
template <class T, size_t N> ostream& operator<<(ostream& os, array<T, N> a);
template <class T, size_t N> enable_if_t<!is_same_v<char, remove_cv_t<T>>, ostream>& operator<<(ostream& os, T(&a)[N]);
template <class Key> ostream& operator<<(ostream& os, set<Key> s);
template <class Key, class T> ostream& operator<<(ostream& os, map<Key, T> mp);
template <class Key> ostream& operator<<(ostream& os, multiset<Key> s);
template <class T> ostream& operator<<(ostream& os, queue<T> q);
template <class T> ostream& operator<<(ostream& os, deque<T> q);
template <class T> ostream& operator<<(ostream& os, priority_queue<T> q);
template <class T> ostream& operator<<(ostream& os, priority_queue<T, vector<T>, greater<T>> q);
template <class T1, class T2> ostream& operator<<(ostream& os, pair<T1, T2> p) { return os << "(" << p.first << ", " << p.second << ")"; }
template <size_t N, class TUPLE> void debug_tuple(ostream& os, TUPLE _) { (void)os; (void)_; }
template <size_t N, class TUPLE, class T, class ...Args> void debug_tuple(ostream &os, TUPLE t) { os << (N == 0 ? "" : ", ") << get<N>(t); debug_tuple<N + 1, TUPLE, Args...>(os, t); }
template <class ...Args> ostream& operator<<(ostream& os, tuple<Args...> t) { os << "("; debug_tuple<0, tuple<Args...>, Args...>(os, t); return os << ")"; }
string debug_delim(int& i) { return i++ == 0 ? "" : ", "; }
#define debug_embrace(x) { int i = 0; os << "{"; { x } return os << "}"; }
template <class T> ostream& operator<<(ostream& os, vector<T> v) { debug_embrace( for (T e : v) { os << debug_delim(i) << e; } ) }
template <class T, size_t N> ostream& operator<<(ostream& os, array<T, N> a) { debug_embrace( for (T e : a) { os << debug_delim(i) << e; } ) }
template <class T, size_t N> enable_if_t<!is_same_v<char, remove_cv_t<T>>, ostream>& operator<<(ostream& os, T(&a)[N]) { debug_embrace( for (T e : a) { os << debug_delim(i) << e; } ) }
template <class Key> ostream& operator<<(ostream& os, set<Key> s) { debug_embrace( for (Key e : s) { os << debug_delim(i) << e; }) }
template <class Key, class T> ostream& operator<<(ostream& os, map<Key, T> mp) { debug_embrace( for (auto e : mp) { os << debug_delim(i) << e; }) }
template <class Key> ostream& operator<<(ostream& os, multiset<Key> s) { debug_embrace( for (Key e : s) { os << debug_delim(i) << e; }) }
template <class T> ostream& operator<<(ostream& os, queue<T> q) { debug_embrace( for (; !q.empty(); q.pop()) { os << debug_delim(i) << q.front(); } ) }
template <class T> ostream& operator<<(ostream& os, deque<T> q) { debug_embrace( for (T e : q) { os << debug_delim(i) << e; } ) }
template <class T> ostream& operator<<(ostream& os, priority_queue<T> q) { debug_embrace( for (; !q.empty(); q.pop()) { os << debug_delim(i) << q.top(); } ) }
template <class T> ostream& operator<<(ostream& os, priority_queue<T, vector<T>, greater<T>> q) { debug_embrace( for (; !q.empty(); q.pop()) { os << debug_delim(i) << q.top(); } ) }
void debug_out() { cerr << endl; }
template <class T, class... Args> void debug_out(const T& x, const Args& ... args) { cerr << " " << x; debug_out(args...); }
#define debug(...) cerr << __LINE__ << " : [" << #__VA_ARGS__ << "] =", debug_out(__VA_ARGS__)
void debug_table(const std::vector<std::vector<int>>& table) {
for (const auto& row : table) {
for (const auto& cell : row) {
cerr << cell << "\t";
}
cerr << endl;
}
}
#else
#define debug(...) (void(0))
void debug_table(const std::vector<std::vector<int>>& table) { (void)table; }
#endif
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// clang-format on
#line 2 "library-cpp/mod/FormalPowerSeriesNTTFriendly.hpp"
#line 8 "library-cpp/mod/FormalPowerSeriesNTTFriendly.hpp"
#include <atcoder/convolution>
template <typename M, int SPARSE = 10>
struct FormalPowerSeriesNTTFriendly : std::vector<M> {
using std::vector<M>::vector;
using FPS = FormalPowerSeriesNTTFriendly;
FPS static read(int n) {
FPS ret(n);
for (int i = 0; i < n; i++) {
long long x;
std::cin >> x;
ret[i] = x;
}
return ret;
}
M freq(int p) const {
return p < (int)this->size() ? (*this)[p] : M(0);
}
void shrink() {
while (!this->empty() and this->back().val() == 0) this->pop_back();
}
FPS pre(int le) const {
return FPS(this->begin(),
this->begin() + std::min((int)this->size(), le));
}
FPS rev() const {
FPS ret(*this);
std::reverse(ret.begin(), ret.end());
return ret;
}
int count_nonzero() const {
return std::count_if(this->begin(), this->end(),
[](M x) { return x.val() != 0; });
}
std::vector<std::pair<int, M>> get_sparse() const {
std::vector<std::pair<int, M>> ret;
for (size_t i = 0; i < this->size(); i++) {
if ((*this)[i].val() != 0) ret.emplace_back(i, (*this)[i]);
}
return ret;
}
FPS operator>>(int s) const {
if ((int)this->size() <= s) return {};
return FPS(this->begin() + s, this->end());
}
FPS operator<<(int s) const {
if (this->empty()) return {};
FPS ret(*this);
ret.insert(ret.begin(), s, M(0));
return ret;
}
FPS& operator+=(const FPS& r) {
if (r.size() > this->size()) this->resize(r.size());
for (size_t i = 0; i < r.size(); i++) (*this)[i] += r[i];
shrink();
return *this;
}
FPS& operator+=(const M& v) {
if (this->empty()) this->resize(1);
(*this)[0] += v;
shrink();
return *this;
}
FPS& operator-=(const FPS& r) {
if (r.size() > this->size()) this->resize(r.size());
for (int i = 0; i < int(r.size()); i++) (*this)[i] -= r[i];
shrink();
return *this;
}
FPS& operator-=(const M& v) {
if (this->empty()) this->resize(1);
(*this)[0] -= v;
shrink();
return *this;
}
FPS& operator*=(const FPS& r) {
const int z = r.count_nonzero();
if (z == 0) {
this->clear();
return *this;
}
if (z <= SPARSE) {
auto sparse = r.get_sparse();
return *this *= sparse;
}
auto res = atcoder::convolution(*this, r);
return *this = {res.begin(), res.end()};
}
FPS& operator*=(const M& v) {
for (auto& x : (*this)) x *= v;
shrink();
return *this;
}
FPS& operator*=(const std::vector<std::pair<int, M>>& r) {
assert(!r.empty());
const int m = r.back().first;
FPS ret(this->size() + m);
for (int i = 0; i < (int)this->size(); i++) {
for (const auto& [j, c] : r) {
ret[i + j] += (*this)[i] * c;
}
}
ret.shrink();
return *this = ret;
}
FPS& operator/=(const FPS& r) {
if (this->size() < r.size()) {
this->clear();
return *this;
}
const int z = r.count_nonzero();
assert(z != 0);
if (z <= SPARSE) {
auto sparse = r.get_sparse();
return *this /= sparse;
}
int n = this->size() - r.size() + 1;
return *this = (rev().pre(n) * r.rev().inv(n)).pre(n).rev();
}
FPS& operator/=(const M& v) {
assert(v.val() != 0);
auto vinv = v.inv();
for (auto& x : (*this)) x *= vinv;
return *this;
}
FPS& operator/=(const std::vector<std::pair<int, M>>& r) {
assert(!r.empty());
auto [j0, c0] = r.front();
assert(j0 == 0 && c0.val() != 0);
auto ic = c0.inv();
FPS ret(this->size());
for (int i = 0; i < (int)this->size(); i++) {
for (const auto& [j, c] : r) {
if (j >= 1 && j <= i) {
ret[i] -= ret[i - j] * c;
}
}
ret[i] += (*this)[i];
ret[i] *= ic;
}
ret.shrink();
return *this = ret;
}
FPS& operator%=(const FPS& r) {
*this -= *this / r * r;
shrink();
return *this;
}
FPS operator+(const FPS& r) const {
return FPS(*this) += r;
}
FPS operator+(const M& v) const {
return FPS(*this) += v;
}
FPS operator-(const FPS& r) const {
return FPS(*this) -= r;
}
FPS operator-(const M& v) const {
return FPS(*this) -= v;
}
FPS operator*(const FPS& r) const {
return FPS(*this) *= r;
}
FPS operator*(const M& v) const {
return FPS(*this) *= v;
}
FPS operator/(const FPS& r) const {
return FPS(*this) /= r;
}
FPS operator%(const FPS& r) const {
return FPS(*this) %= r;
}
FPS operator-() const {
FPS ret = *this;
for (auto& v : ret) v = -v;
return ret;
}
FPS differential() const {
const int n = (int)this->size();
FPS ret(std::max(0, n - 1));
for (int i = 1; i < n; i++) ret[i - 1] = (*this)[i] * M(i);
return ret;
}
FPS integral() const {
const int n = (int)this->size();
FPS ret(n + 1);
ret[0] = M(0);
if (n > 0) ret[1] = M(1);
auto mod = M::mod();
for (int i = 2; i <= n; i++) ret[i] = -ret[mod % i] * (mod / i);
for (int i = 0; i < n; i++) ret[i + 1] *= (*this)[i];
return ret;
}
FPS inv(int deg = -1) const {
assert((*this)[0] != M(0));
const int n = (int)this->size();
if (deg == -1) deg = n;
FPS ret{(*this)[0].inv()};
ret.reserve(deg);
for (int d = 1; d < deg; d <<= 1) {
FPS f(d << 1), g(d << 1);
std::copy(this->begin(), this->begin() + std::min(n, d << 1),
f.begin());
std::copy(ret.begin(), ret.end(), g.begin());
atcoder::internal::butterfly(f);
atcoder::internal::butterfly(g);
for (int i = 0; i < (d << 1); i++) f[i] *= g[i];
atcoder::internal::butterfly_inv(f);
std::fill(f.begin(), f.begin() + d, M(0));
atcoder::internal::butterfly(f);
for (int i = 0; i < (d << 1); i++) f[i] *= g[i];
atcoder::internal::butterfly_inv(f);
M iz = M(d << 1).inv();
iz *= -iz;
for (int i = d; i < std::min(d << 1, deg); i++)
ret.push_back(f[i] * iz);
}
return ret.pre(deg);
}
FPS log(int deg = -1) const {
assert((*this)[0] == M(1));
if (deg == -1) deg = (int)this->size();
return (differential() * inv(deg)).pre(deg - 1).integral();
}
FPS sqrt(const std::function<M(M)>& get_sqrt, int deg = -1) const {
const int n = this->size();
if (deg == -1) deg = n;
if (this->empty()) return FPS(deg, 0);
if ((*this)[0] == M(0)) {
for (int i = 1; i < n; i++) {
if ((*this)[i] != M(0)) {
if (i & 1) return {};
if (deg - i / 2 <= 0) break;
auto ret = (*this >> i).sqrt(get_sqrt, deg - i / 2);
if (ret.empty()) return {};
ret = ret << (i / 2);
if ((int)ret.size() < deg) ret.resize(deg, M(0));
return ret;
}
}
return FPS(deg, M(0));
}
auto sqrtf0 = M(get_sqrt((*this)[0]));
if (sqrtf0 * sqrtf0 != (*this)[0]) return {};
FPS ret{sqrtf0};
M inv2 = M(2).inv();
for (int i = 1; i < deg; i <<= 1)
ret = (ret + pre(i << 1) * ret.inv(i << 1)) * inv2;
return ret.pre(deg);
}
FPS exp(int deg = -1) const {
assert(this->empty() or (*this)[0] == M(0));
if (this->size() <= 1) return {M(1)};
if (deg == -1) deg = (int)this->size();
FPS inv;
inv.reserve(deg + 1);
inv.push_back(M(0));
inv.push_back(M(1));
auto inplace_integral = [&](FPS& F) -> void {
const int n = (int)F.size();
auto mod = M::mod();
while ((int)inv.size() <= n) {
int i = inv.size();
inv.push_back(-inv[mod % i] * (mod / i));
}
F.insert(F.begin(), M(0));
for (int i = 1; i <= n; i++) F[i] *= inv[i];
};
auto inplace_differential = [](FPS& F) -> void {
if (F.empty()) return;
F.erase(F.begin());
for (size_t i = 0; i < F.size(); i++) F[i] *= M(i + 1);
};
FPS f{1, (*this)[1]}, g{M(1)}, g_fft{M(1), M(1)};
for (int m = 2; m < deg; m <<= 1) {
const M iz1 = M(m).inv(), iz2 = M(m << 1).inv();
auto f_fft = f;
f_fft.resize(m << 1);
atcoder::internal::butterfly(f_fft);
{
FPS _g(m);
for (int i = 0; i < m; i++) _g[i] = f_fft[i] * g_fft[i];
atcoder::internal::butterfly_inv(_g);
std::fill(_g.begin(), _g.begin() + (m >> 1), M(0));
atcoder::internal::butterfly(_g);
for (int i = 0; i < m; i++) _g[i] *= -g_fft[i] * iz1 * iz1;
atcoder::internal::butterfly_inv(_g);
g.insert(g.end(), _g.begin() + (m >> 1), _g.end());
g_fft = g;
g_fft.resize(m << 1);
atcoder::internal::butterfly(g_fft);
}
FPS x(this->begin(),
this->begin() + std::min((int)this->size(), m));
{
x.resize(m);
inplace_differential(x);
x.push_back(M(0));
atcoder::internal::butterfly(x);
}
{
for (int i = 0; i < m; i++) x[i] *= f_fft[i] * iz1;
atcoder::internal::butterfly_inv(x);
}
{
x -= f.differential();
x.resize(m << 1);
for (int i = 0; i < m - 1; i++) x[m + i] = x[i], x[i] = M(0);
atcoder::internal::butterfly(x);
for (int i = 0; i < (m << 1); i++) x[i] *= g_fft[i] * iz2;
atcoder::internal::butterfly_inv(x);
}
{
x.pop_back();
inplace_integral(x);
for (int i = m; i < std::min((int)this->size(), m << 1); i++)
x[i] += (*this)[i];
std::fill(x.begin(), x.begin() + m, M(0));
}
{
atcoder::internal::butterfly(x);
for (int i = 0; i < (m << 1); i++) x[i] *= f_fft[i] * iz2;
atcoder::internal::butterfly_inv(x);
f.insert(f.end(), x.begin() + m, x.end());
}
}
return FPS{f.begin(), f.begin() + deg};
}
FPS pow(int64_t k, int deg = -1) const {
const int n = (int)this->size();
if (deg == -1) deg = n;
if (k == 0) {
auto res = FPS(deg, M(0));
res[0] = M(1);
return res;
}
for (int i = 0; i < n; i++) {
if ((*this)[i] != M(0)) {
if (i >= (deg + k - 1) / k) return FPS(deg, M(0));
M rev = (*this)[i].inv();
FPS ret = (((*this * rev) >> i).log(deg) * k).exp(deg) *
((*this)[i].pow(k));
ret = (ret << (i * k)).pre(deg);
if ((int)ret.size() < deg) ret.resize(deg, M(0));
return ret;
}
}
return FPS(deg, M(0));
}
M eval(M x) const {
M ret = 0, w = 1;
for (const auto& v : *this) ret += w * v, w *= x;
return ret;
}
};
template <class M, int SPARSE>
void print(const FormalPowerSeriesNTTFriendly<M, SPARSE>& v) {
for (size_t i = 0; i < v.size(); i++) {
if (i) std::cout << " ";
std::cout << v[i].val();
}
cout << "\n";
}
#line 2 "library-cpp/mod/product_FPS.hpp"
#line 5 "library-cpp/mod/product_FPS.hpp"
template <class FPS> FPS product_FPS(const std::vector<FPS>& fpss) {
if (fpss.empty()) return FPS(1);
auto comp = [&](const FPS& a, const FPS& b) { return a.size() > b.size(); };
std::priority_queue<FPS, std::vector<FPS>, decltype(comp)> pq(comp, fpss);
while (pq.size() > 1) {
FPS a = pq.top();
pq.pop();
FPS b = pq.top();
pq.pop();
pq.push(a * b);
}
return pq.top();
}
#line 5 "A.cpp"
using namespace atcoder;
using mint = modint998244353;
using FPS = FormalPowerSeriesNTTFriendly<mint>;
void solve() {
INT(N);
VEC(ll, A, N);
vec<FPS> X(N);
rep(i, N) {
X[i] = {mint(1), A[i]};
}
auto Y = product_FPS(X);
mint ans = 0;
rep(i, 1, N + 1) {
ans += Y.freq(i) * mint(i).pow(N - i);
}
print(ans);
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
cerr << fixed << setprecision(7);
int T = 1;
// cin >> T;
for (int test_case = 1; test_case <= T; test_case++) {
// debug(test_case);
solve();
}
}