結果
| 問題 | No.2747 Permutation Adjacent Sum |
| ユーザー |
 ebi_fly
|
| 提出日時 | 2024-04-20 16:22:34 |
| 言語 | C++23 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
AC
|
| 実行時間 | 114 ms / 3,000 ms |
| コード長 | 29,520 bytes |
| コンパイル時間 | 3,451 ms |
| コンパイル使用メモリ | 259,200 KB |
| 実行使用メモリ | 27,132 KB |
| 最終ジャッジ日時 | 2024-10-12 12:10:08 |
| 合計ジャッジ時間 | 6,854 ms |
|
ジャッジサーバーID （参考情報） |
judge3 / judge2 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 50 ms
12,180 KB |
| testcase_01 | AC | 10 ms
6,824 KB |
| testcase_02 | AC | 33 ms
9,088 KB |
| testcase_03 | AC | 11 ms
6,820 KB |
| testcase_04 | AC | 51 ms
12,928 KB |
| testcase_05 | AC | 114 ms
26,812 KB |
| testcase_06 | AC | 56 ms
13,952 KB |
| testcase_07 | AC | 48 ms
11,904 KB |
| testcase_08 | AC | 73 ms
17,788 KB |
| testcase_09 | AC | 100 ms
23,672 KB |
| testcase_10 | AC | 15 ms
6,816 KB |
| testcase_11 | AC | 47 ms
11,904 KB |
| testcase_12 | AC | 6 ms
6,816 KB |
| testcase_13 | AC | 24 ms
7,168 KB |
| testcase_14 | AC | 67 ms
16,264 KB |
| testcase_15 | AC | 98 ms
23,148 KB |
| testcase_16 | AC | 50 ms
12,416 KB |
| testcase_17 | AC | 89 ms
21,760 KB |
| testcase_18 | AC | 90 ms
20,864 KB |
| testcase_19 | AC | 12 ms
6,816 KB |
| testcase_20 | AC | 53 ms
13,056 KB |
| testcase_21 | AC | 73 ms
17,972 KB |
| testcase_22 | AC | 84 ms
19,092 KB |
| testcase_23 | AC | 43 ms
10,624 KB |
| testcase_24 | AC | 45 ms
11,136 KB |
| testcase_25 | AC | 30 ms
8,320 KB |
| testcase_26 | AC | 68 ms
16,640 KB |
| testcase_27 | AC | 76 ms
18,380 KB |
| testcase_28 | AC | 74 ms
17,544 KB |
| testcase_29 | AC | 53 ms
13,056 KB |
| testcase_30 | AC | 111 ms
27,064 KB |
| testcase_31 | AC | 111 ms
26,984 KB |
| testcase_32 | AC | 111 ms
27,132 KB |
| testcase_33 | AC | 109 ms
26,956 KB |
| testcase_34 | AC | 111 ms
26,968 KB |
| testcase_35 | AC | 2 ms
6,820 KB |
| testcase_36 | AC | 2 ms
6,820 KB |
| testcase_37 | AC | 2 ms
6,816 KB |
| testcase_38 | AC | 2 ms
6,816 KB |
| testcase_39 | AC | 2 ms
6,820 KB |
| testcase_40 | AC | 2 ms
6,820 KB |
| testcase_41 | AC | 2 ms
6,820 KB |
ソースコード
#line 1 "test/yuki/yuki_2747.test.cpp"
#define PROBLEM "https://yukicoder.me/problems/no/2747"
#line 1 "template/template.hpp"
#include <bits/stdc++.h>
#define rep(i, a, n) for (int i = (int)(a); i < (int)(n); i++)
#define rrep(i, a, n) for (int i = ((int)(n)-1); i >= (int)(a); i--)
#define Rep(i, a, n) for (i64 i = (i64)(a); i < (i64)(n); i++)
#define RRep(i, a, n) for (i64 i = ((i64)(n)-i64(1)); i >= (i64)(a); i--)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#line 2 "template/debug_template.hpp"
#line 4 "template/debug_template.hpp"
namespace ebi {
#ifdef LOCAL
#define debug(...) \
std::cerr << "LINE: " << __LINE__ << " [" << #__VA_ARGS__ << "]:", \
debug_out(__VA_ARGS__)
#else
#define debug(...)
#endif
void debug_out() {
std::cerr << std::endl;
}
template <typename Head, typename... Tail> void debug_out(Head h, Tail... t) {
std::cerr << " " << h;
if (sizeof...(t) > 0) std::cerr << " :";
debug_out(t...);
}
} // namespace ebi
#line 2 "template/int_alias.hpp"
#line 4 "template/int_alias.hpp"
namespace ebi {
using ld = long double;
using std::size_t;
using i8 = std::int8_t;
using u8 = std::uint8_t;
using i16 = std::int16_t;
using u16 = std::uint16_t;
using i32 = std::int32_t;
using u32 = std::uint32_t;
using i64 = std::int64_t;
using u64 = std::uint64_t;
using i128 = __int128_t;
using u128 = __uint128_t;
} // namespace ebi
#line 2 "template/io.hpp"
#line 5 "template/io.hpp"
#include <optional>
#line 7 "template/io.hpp"
namespace ebi {
template <typename T1, typename T2>
std::ostream &operator<<(std::ostream &os, const std::pair<T1, T2> &pa) {
return os << pa.first << " " << pa.second;
}
template <typename T1, typename T2>
std::istream &operator>>(std::istream &os, std::pair<T1, T2> &pa) {
return os >> pa.first >> pa.second;
}
template <typename T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &vec) {
for (std::size_t i = 0; i < vec.size(); i++)
os << vec[i] << (i + 1 == vec.size() ? "" : " ");
return os;
}
template <typename T>
std::istream &operator>>(std::istream &os, std::vector<T> &vec) {
for (T &e : vec) std::cin >> e;
return os;
}
template <typename T>
std::ostream &operator<<(std::ostream &os, const std::optional<T> &opt) {
if (opt) {
os << opt.value();
} else {
os << "invalid value";
}
return os;
}
void fast_io() {
std::cout << std::fixed << std::setprecision(15);
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
}
} // namespace ebi
#line 2 "template/utility.hpp"
#line 5 "template/utility.hpp"
#line 2 "graph/base.hpp"
#line 5 "graph/base.hpp"
#include <ranges>
#line 7 "graph/base.hpp"
#line 2 "data_structure/simple_csr.hpp"
#line 6 "data_structure/simple_csr.hpp"
namespace ebi {
template <class E> struct simple_csr {
simple_csr() = default;
simple_csr(int n, const std::vector<std::pair<int, E>>& elements)
: start(n + 1, 0), elist(elements.size()) {
for (auto e : elements) {
start[e.first + 1]++;
}
for (auto i : std::views::iota(0, n)) {
start[i + 1] += start[i];
}
auto counter = start;
for (auto [i, e] : elements) {
elist[counter[i]++] = e;
}
}
simple_csr(const std::vector<std::vector<E>>& es)
: start(es.size() + 1, 0) {
int n = es.size();
for (auto i : std::views::iota(0, n)) {
start[i + 1] = (int)es[i].size() + start[i];
}
elist.resize(start.back());
for (auto i : std::views::iota(0, n)) {
std::copy(es[i].begin(), es[i].end(), elist.begin() + start[i]);
}
}
int size() const {
return (int)start.size() - 1;
}
const auto operator[](int i) const {
return std::ranges::subrange(elist.begin() + start[i],
elist.begin() + start[i + 1]);
}
auto operator[](int i) {
return std::ranges::subrange(elist.begin() + start[i],
elist.begin() + start[i + 1]);
}
const auto operator()(int i, int l, int r) const {
return std::ranges::subrange(elist.begin() + start[i] + l,
elist.begin() + start[i + 1] + r);
}
auto operator()(int i, int l, int r) {
return std::ranges::subrange(elist.begin() + start[i] + l,
elist.begin() + start[i + 1] + r);
}
private:
std::vector<int> start;
std::vector<E> elist;
};
} // namespace ebi
#line 9 "graph/base.hpp"
namespace ebi {
template <class T> struct Edge {
int from, to;
T cost;
int id;
};
template <class E> struct Graph {
using cost_type = E;
using edge_type = Edge<cost_type>;
Graph(int n_) : n(n_) {}
Graph() = default;
void add_edge(int u, int v, cost_type c) {
buff.emplace_back(u, edge_type{u, v, c, m});
edges.emplace_back(edge_type{u, v, c, m++});
}
void add_undirected_edge(int u, int v, cost_type c) {
buff.emplace_back(u, edge_type{u, v, c, m});
buff.emplace_back(v, edge_type{v, u, c, m});
edges.emplace_back(edge_type{u, v, c, m});
m++;
}
void read_tree(int offset = 1, bool is_weighted = false) {
read_graph(n - 1, offset, false, is_weighted);
}
void read_parents(int offset = 1) {
for (auto i : std::views::iota(1, n)) {
int p;
std::cin >> p;
p -= offset;
add_undirected_edge(p, i, 1);
}
build();
}
void read_graph(int e, int offset = 1, bool is_directed = false,
bool is_weighted = false) {
for (int i = 0; i < e; i++) {
int u, v;
std::cin >> u >> v;
u -= offset;
v -= offset;
if (is_weighted) {
cost_type c;
std::cin >> c;
if (is_directed) {
add_edge(u, v, c);
} else {
add_undirected_edge(u, v, c);
}
} else {
if (is_directed) {
add_edge(u, v, 1);
} else {
add_undirected_edge(u, v, 1);
}
}
}
build();
}
void build() {
assert(!prepared);
csr = simple_csr<edge_type>(n, buff);
buff.clear();
prepared = true;
}
int size() const {
return n;
}
int node_number() const {
return n;
}
int edge_number() const {
return m;
}
edge_type get_edge(int i) const {
return edges[i];
}
std::vector<edge_type> get_edges() const {
return edges;
}
const auto operator[](int i) const {
return csr[i];
}
auto operator[](int i) {
return csr[i];
}
private:
int n, m = 0;
std::vector<std::pair<int,edge_type>> buff;
std::vector<edge_type> edges;
simple_csr<edge_type> csr;
bool prepared = false;
};
} // namespace ebi
#line 8 "template/utility.hpp"
namespace ebi {
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> T safe_ceil(T a, T b) {
if (a % b == 0)
return a / b;
else if (a >= 0)
return (a / b) + 1;
else
return -((-a) / b);
}
template <class T> T safe_floor(T a, T b) {
if (a % b == 0)
return a / b;
else if (a >= 0)
return a / b;
else
return -((-a) / b) - 1;
}
constexpr i64 LNF = std::numeric_limits<i64>::max() / 4;
constexpr int INF = std::numeric_limits<int>::max() / 2;
const std::vector<int> dy = {1, 0, -1, 0, 1, 1, -1, -1};
const std::vector<int> dx = {0, 1, 0, -1, 1, -1, 1, -1};
} // namespace ebi
#line 2 "math/lagrange_interpolation.hpp"
#line 4 "math/lagrange_interpolation.hpp"
/*
reference: https://atcoder.jp/contests/abc208/editorial/2195
verify: https://atcoder.jp/contests/abc208/tasks/abc208_f
*/
namespace ebi {
template <class mint>
mint lagrange_interpolation(const std::vector<mint> &f, long long n) {
const int d = int(f.size()) - 1; // Nのd次以下の多項式
mint fact = 1;
std::vector<mint> inv_fact(d + 1);
for (int i = 1; i < d + 1; ++i) {
fact *= i;
}
inv_fact[d] = fact.inv();
for (int i = d; i > 0; i--) {
inv_fact[i - 1] = inv_fact[i] * i;
}
std::vector<mint> l(d + 1), r(d + 1);
l[0] = 1;
for (int i = 0; i < d; ++i) {
l[i + 1] = l[i] * (n - i);
}
r[d] = 1;
for (int i = d; i > 0; --i) {
r[i - 1] = r[i] * (n - i);
}
mint res = 0;
for (int i = 0; i < d + 1; ++i) {
res += mint((d - i) % 2 == 1 ? -1 : 1) * f[i] * l[i] * r[i] *
inv_fact[i] * inv_fact[d - i];
}
return res;
}
} // namespace ebi
#line 2 "math/linear_sieve.hpp"
#line 4 "math/linear_sieve.hpp"
/*
reference: https://37zigen.com/linear-sieve/
verify: https://atcoder.jp/contests/abc162/submissions/25095562
*/
#line 12 "math/linear_sieve.hpp"
namespace ebi {
struct linear_sieve {
private:
using u64 = std::uint64_t;
int n;
std::vector<int> sieve;
std::vector<int> prime;
public:
linear_sieve(int _n) : n(_n), sieve(std::vector<int>(_n + 1, -1)) {
for (int i = 2; i <= n; i++) {
if (sieve[i] < 0) {
sieve[i] = i;
prime.emplace_back(i);
}
for (auto p : prime) {
if (u64(p) * u64(i) > u64(n) || p > sieve[i]) break;
sieve[p * i] = p;
}
}
}
std::vector<int> prime_table() const {
return prime;
}
std::vector<std::pair<int, int>> prime_power_table(int m) const {
assert(m <= n);
std::vector<std::pair<int, int>> table(m + 1, {1, 1});
for (int i = 2; i <= m; i++) {
int p = sieve[i];
table[i] = {p, p};
if (sieve[i / p] == p) {
table[i] = table[i / p];
table[i].second *= p;
}
}
return table;
}
std::vector<std::pair<int, int>> factorize(int x) {
assert(x <= n);
std::vector<std::pair<int, int>> res;
while (x > 1) {
int p = sieve[x];
int exp = 0;
if (p < 0) {
res.emplace_back(x, 1);
break;
}
while (sieve[x] == p) {
x /= p;
exp++;
}
res.emplace_back(p, exp);
}
return res;
}
std::vector<int> divisors(int x) {
assert(x <= n);
std::vector<int> res;
res.emplace_back(1);
auto pf = factorize(x);
for (auto p : pf) {
int sz = (int)res.size();
for (int i = 0; i < sz; i++) {
int ret = 1;
for (int j = 0; j < p.second; j++) {
ret *= p.first;
res.emplace_back(res[i] * ret);
}
}
}
return res;
}
template <class T> std::vector<T> fast_zeta(const std::vector<T> &f) {
std::vector<T> F = f;
int sz = f.size();
assert(sz <= n + 1);
for (int i = 2; i < sz; i++) {
if (sieve[i] != i) continue;
for (int j = (sz - 1) / i; j >= 1; j--) {
F[j] += F[j * i];
}
}
return F;
}
template <class T> std::vector<T> fast_mobius(const std::vector<T> &F) {
std::vector<T> f = F;
int sz = F.size();
assert(sz <= n + 1);
for (int i = 2; i < sz; i++) {
if (sieve[i] != i) continue;
for (int j = 1; j * i < sz; j++) {
f[j] -= f[j * i];
}
}
return f;
}
template <class modint> std::vector<modint> pow_table(int k) {
std::vector<modint> table(n + 1, 1);
table[0] = 0;
for (int i = 2; i <= n; i++) {
if (sieve[i] == i) {
table[i] = modint(i).pow(k);
continue;
}
table[i] = table[sieve[i]] * table[i / sieve[i]];
}
return table;
}
template <class modint> std::vector<modint> inv_table() {
return pow_table(modint::mod() - 2);
}
};
} // namespace ebi
#line 2 "modint/modint.hpp"
#line 5 "modint/modint.hpp"
#line 2 "modint/base.hpp"
#include <concepts>
#line 6 "modint/base.hpp"
namespace ebi {
template <class T>
concept Modint = requires(T a, T b) {
a + b;
a - b;
a * b;
a / b;
a.inv();
a.val();
a.pow(std::declval<long long>());
T::mod();
};
template <Modint mint> std::istream &operator>>(std::istream &os, mint &a) {
long long x;
os >> x;
a = x;
return os;
}
template <Modint mint>
std::ostream &operator<<(std::ostream &os, const mint &a) {
return os << a.val();
}
} // namespace ebi
#line 7 "modint/modint.hpp"
namespace ebi {
template <int m> struct static_modint {
private:
using modint = static_modint;
public:
static constexpr int mod() {
return m;
}
static constexpr modint raw(int v) {
modint x;
x._v = v;
return x;
}
constexpr static_modint() : _v(0) {}
constexpr static_modint(long long v) {
v %= (long long)umod();
if (v < 0) v += (long long)umod();
_v = (unsigned int)v;
}
constexpr unsigned int val() const {
return _v;
}
constexpr unsigned int value() const {
return val();
}
constexpr modint &operator++() {
_v++;
if (_v == umod()) _v = 0;
return *this;
}
constexpr modint &operator--() {
if (_v == 0) _v = umod();
_v--;
return *this;
}
constexpr modint operator++(int) {
modint res = *this;
++*this;
return res;
}
constexpr modint operator--(int) {
modint res = *this;
--*this;
return res;
}
constexpr modint &operator+=(const modint &rhs) {
_v += rhs._v;
if (_v >= umod()) _v -= umod();
return *this;
}
constexpr modint &operator-=(const modint &rhs) {
_v -= rhs._v;
if (_v >= umod()) _v += umod();
return *this;
}
constexpr modint &operator*=(const modint &rhs) {
unsigned long long x = _v;
x *= rhs._v;
_v = (unsigned int)(x % (unsigned long long)umod());
return *this;
}
constexpr modint &operator/=(const modint &rhs) {
return *this = *this * rhs.inv();
}
constexpr modint operator+() const {
return *this;
}
constexpr modint operator-() const {
return modint() - *this;
}
constexpr modint pow(long long n) const {
assert(0 <= n);
modint x = *this, res = 1;
while (n) {
if (n & 1) res *= x;
x *= x;
n >>= 1;
}
return res;
}
constexpr modint inv() const {
assert(_v);
return pow(umod() - 2);
}
friend modint operator+(const modint &lhs, const modint &rhs) {
return modint(lhs) += rhs;
}
friend modint operator-(const modint &lhs, const modint &rhs) {
return modint(lhs) -= rhs;
}
friend modint operator*(const modint &lhs, const modint &rhs) {
return modint(lhs) *= rhs;
}
friend modint operator/(const modint &lhs, const modint &rhs) {
return modint(lhs) /= rhs;
}
friend bool operator==(const modint &lhs, const modint &rhs) {
return lhs.val() == rhs.val();
}
friend bool operator!=(const modint &lhs, const modint &rhs) {
return !(lhs == rhs);
}
private:
unsigned int _v = 0;
static constexpr unsigned int umod() {
return m;
}
};
using modint998244353 = static_modint<998244353>;
using modint1000000007 = static_modint<1000000007>;
} // namespace ebi
#line 2 "math/factorial_mod_998.hpp"
#line 6 "math/factorial_mod_998.hpp"
#line 8 "math/factorial_mod_998.hpp"
namespace ebi {
namespace internal {
template <Modint mint>
void enumerate_factorial_per_block(const int n, const int b) {
std::cout << "{"
<< "1";
mint f = 1;
for (int i = 2; i <= n; i++) {
f *= i;
if (i % b == 0) {
std::cout << ", " << f;
}
}
std::cout << "}\n";
}
constexpr int BLOCK_SIZE = 1'000'000;
constexpr std::array<int, 999> fact_per_1e6 = {
1, 373341033, 45596018, 834980587, 623627864, 428937595, 442819817,
499710224, 833655840, 83857087, 295201906, 788488293, 671639287, 849315549,
597398273, 813259672, 732727656, 244038325, 122642896, 310517972, 160030060,
483239722, 683879839, 712910418, 384710263, 433880730, 844360005, 513089677,
101492974, 959253371, 957629942, 678615452, 34035221, 56734233, 524027922,
31729117, 102311167, 330331487, 8332991, 832392662, 545208507, 594075875,
318497156, 859275605, 300738984, 767818091, 864118508, 878131539, 316588744,
812496962, 213689172, 584871249, 980836133, 54096741, 417876813, 363266670,
335481797, 730839588, 393495668, 435793297, 760025067, 811438469, 720976283,
650770098, 586537547, 117371703, 566486504, 749562308, 708205284, 932912293,
939830261, 983699513, 206579820, 301188781, 593164676, 770845925, 247687458,
41047791, 266419267, 937835947, 506268060, 6177705, 936268003, 166873118,
443834893, 328979964, 470135404, 954410105, 117565665, 832761782, 39806322,
478922755, 394880724, 821825588, 468705875, 512554988, 232240472, 876497899,
356048018, 895187265, 808258749, 575505950, 68190615, 939065335, 552199946,
694814243, 385460530, 529769387, 640377761, 916128300, 440133909, 362216114,
826373774, 502324157, 457648395, 385510728, 904737188, 78988746, 454565719,
623828097, 686156489, 713476044, 63602402, 570334625, 681055904, 222059821,
477211096, 343363294, 833792655, 461853093, 741797144, 74731896, 930484262,
268372735, 941222802, 677432735, 474842829, 700451655, 400176109, 697644778,
390377694, 790010794, 360642718, 505712943, 946647976, 339045014, 715797300,
251680896, 70091750, 40517433, 12629586, 850635539, 110877109, 571935891,
695965747, 634938288, 69072133, 155093216, 749696762, 963086402, 544711799,
724471925, 334646013, 574791029, 722417626, 377929821, 743946412, 988034679,
405207112, 18063742, 104121967, 638607426, 607304611, 751377777, 35834555,
313632531, 18058363, 656121134, 40763559, 562910912, 495867250, 48767038,
210864657, 659137294, 715390025, 865854329, 324322857, 388911184, 286059202,
636456178, 421290700, 832276048, 726437551, 526417714, 252522639, 386147469,
674313019, 274769381, 226519400, 272047186, 117153405, 712896591, 486826649,
119444874, 338909703, 18536028, 41814114, 245606459, 140617938, 250512392,
57084755, 157807456, 261113192, 40258068, 194807105, 325341339, 884328111,
896332013, 880836012, 737358206, 202713771, 785454372, 399586250, 485457499,
640827004, 546969497, 749602473, 159788463, 159111724, 218592929, 675932866,
314795475, 811539323, 246883213, 696818315, 759880589, 4302336, 353070689,
477909706, 559289160, 79781699, 878094972, 840903973, 367416824, 973366814,
848259019, 462421750, 667227759, 897917455, 81800722, 956276337, 942686845,
420541799, 417005912, 272641764, 941778993, 217214373, 192220616, 267901132,
50530621, 652678397, 354880856, 164289049, 781023184, 105376215, 315094878,
607856504, 733905911, 457743498, 992735713, 35212756, 231822660, 276036750,
734558079, 424180850, 433186147, 308380947, 18333316, 12935086, 351491725,
655645460, 535812389, 521902115, 67016984, 48682076, 64748124, 489360447,
361275315, 786336279, 805161272, 468129309, 645091350, 887284732, 913004502,
358814684, 281295633, 328970139, 395955130, 164840186, 820902807, 761699708,
246274415, 592331769, 913846362, 866682684, 600130702, 903837674, 529462989,
90612675, 526540127, 533047427, 110008879, 674279751, 801920753, 645226926,
676886948, 752481486, 474034007, 457790341, 166813684, 287671032, 188118664,
244731384, 404032157, 269766986, 423996017, 182948540, 356801634, 737863144,
652014069, 206068022, 504569410, 919894484, 593398649, 963768176, 882517476,
702523597, 949028249, 128957299, 171997372, 50865043, 20937461, 690959202,
581356488, 369182214, 993580422, 193500140, 540665426, 365786018, 743731625,
144980423, 979536721, 773259009, 617053935, 247670131, 843705280, 30419459,
985463402, 261585206, 237885042, 111276893, 488166208, 137660292, 720784236,
244467770, 26368504, 792857103, 666885724, 670313309, 905683034, 259415897,
512017253, 826265493, 111960112, 633652060, 918048438, 516432938, 386972415,
996212724, 610073831, 444094191, 72480267, 665038087, 11584804, 301029012,
723617861, 113763819, 778259899, 937766095, 535448641, 593907889, 783573565,
673298635, 599533244, 655712590, 173350007, 868198597, 169013813, 585161712,
697502214, 573994984, 285943986, 675831407, 3134056, 965907646, 401920943,
665949756, 236277883, 612745912, 813282113, 892454686, 901222267, 624900982,
927122298, 686321335, 84924870, 927606072, 506664166, 353631992, 165913238,
566073550, 816674343, 864877926, 171259407, 908752311, 874007723, 803597299,
613676466, 880336545, 282280109, 128761001, 58852065, 474075900, 434816091,
364856903, 149123648, 388854780, 314693916, 423183826, 419733481, 888483202,
238933227, 336564048, 757103493, 100189123, 855479832, 51370348, 403061033,
496971759, 831753030, 251718753, 272779384, 683379259, 488844621, 881783783,
659478190, 445719559, 740782647, 546525906, 985524427, 548033568, 333772553,
331916427, 752533273, 730387628, 93829695, 655989476, 930661318, 334885743,
466041862, 428105027, 888238707, 232218076, 769865249, 730641039, 616996159,
231721356, 326973501, 426068899, 722403656, 742756734, 663270261, 364187931,
350431704, 671823672, 633125919, 226166717, 386814657, 237594135, 451479365,
546182474, 119366536, 465211069, 605313606, 728508871, 249619035, 663053607,
900453742, 48293872, 229958401, 62402409, 69570431, 71921532, 960467929,
537087913, 514588945, 513856225, 415497414, 286592050, 645469437, 102052166,
163298189, 873938719, 617583886, 986843080, 962390239, 580971332, 665147020,
88900164, 89866970, 826426395, 616059995, 443012312, 659160562, 229855967,
687413213, 59809521, 398599610, 325666688, 154765991, 159186619, 210830877,
386454418, 84493735, 974220646, 820097297, 2191828, 481459931, 729073424,
551556379, 926316039, 151357011, 808637654, 218058015, 786112034, 850407126,
84202800, 94214098, 30019651, 121701603, 176055335, 865461951, 553631971,
286620803, 984061713, 888573766, 302767023, 977070668, 110954576, 83922475,
51568171, 60949367, 19533020, 510592752, 615419476, 341370469, 912573425,
286207526, 206707897, 384156962, 414163604, 193301813, 749570167, 366933789,
11470970, 600191572, 391667731, 328736286, 30645366, 215162519, 604947226,
236199953, 718439098, 411423177, 803407599, 632441623, 766760224, 263006576,
757681534, 61082578, 681666415, 947466395, 12206799, 659767098, 933746852,
978860867, 59215985, 161179205, 439197472, 259779111, 511621808, 145770512,
882749888, 943124465, 872053396, 631078482, 166861622, 743415395, 772287179,
602427948, 924112080, 385643091, 794973480, 883782693, 869723371, 805963889,
313106351, 262132854, 400034567, 488248149, 265769800, 791715397, 408753255,
468381897, 415812467, 172922144, 64404368, 281500398, 512318142, 288791777,
955559118, 242484726, 536413695, 205340854, 707803527, 576699812, 218525078,
875554190, 46283078, 833841915, 763148293, 807722138, 788080170, 556901372,
150896699, 253151120, 97856807, 918256774, 771557187, 582547026, 472709375,
911615063, 743371401, 641382840, 446540967, 184639537, 157247760, 775930891,
939702814, 499082462, 19536133, 548753627, 593243221, 563850263, 185475971,
687419227, 396799323, 657976136, 864535682, 433009242, 860830935, 33107339,
517661450, 467651311, 812398757, 202133852, 431839017, 709549400, 99643620,
773282878, 290471030, 61134552, 129206504, 929147251, 837008968, 422332597,
353775281, 469563025, 62265336, 835064501, 851685235, 21197005, 264793769,
326416680, 118842991, 84257200, 763248924, 687559609, 150907932, 401832452,
242726978, 766752066, 959173604, 390269102, 992293822, 744816299, 476631694,
177284763, 702429415, 374065901, 169855231, 629007616, 719169602, 564737074,
475119050, 714502830, 40993711, 820235888, 749063595, 239329111, 612759169,
18591377, 419142436, 442202439, 941600951, 158013406, 637073231, 471564060,
447222237, 701248503, 599797734, 577221870, 69656699, 51052704, 6544303,
10958310, 554955500, 943192237, 192526269, 897983911, 961628039, 240232720,
627280533, 710239542, 70255649, 261743865, 228474833, 776408079, 304180483,
63607040, 953297493, 758058902, 395529997, 156010331, 825833840, 539880795,
234683685, 52626619, 751843490, 116909119, 62806842, 574857555, 353417551,
40061330, 822203768, 681051568, 490913702, 9322961, 766631257, 124794668,
37844313, 163524507, 729108319, 490867505, 47035168, 682765157, 53842115,
817965276, 757179922, 339238384, 909741023, 150530547, 158444563, 140949492,
993302799, 551621442, 137578883, 475122706, 443869843, 605400098, 689361523,
769596520, 801661499, 474900284, 586624857, 349960501, 134084537, 650564083,
877097974, 379857427, 887890124, 159436401, 133274277, 986182139, 729720334,
568925901, 459461496, 499309445, 493171177, 460958750, 380694152, 168836226,
840160881, 141116880, 225064950, 109618190, 842341383, 85305729, 759273275,
97369807, 669317759, 766247510, 829017039, 550323884, 261274540, 918239352,
29606025, 870793828, 293683814, 378510746, 367270918, 481292028, 813097823,
798448487, 230791733, 899305835, 504040630, 162510533, 479367951, 275282274,
806951470, 462774647, 56473153, 184659008, 905122161, 664034750, 109726629,
59372704, 325795100, 486860143, 843736533, 924723613, 880348000, 801252478,
616515290, 776142608, 284803450, 583439582, 274826676, 6018349, 377403437,
244041569, 527081707, 544763288, 708818585, 354033051, 904309832, 589922898,
673933870, 682858433, 945260111, 899893421, 515264973, 911685911, 9527148,
239480646, 524126897, 48259065, 578214879, 118677219, 786127243, 869205770,
923276513, 937928886, 802186160, 12198440, 638784295, 34200904, 758925811,
185027790, 80918046, 120604699, 610456697, 573601211, 208296321, 49743354,
653691911, 490750754, 674335312, 887877110, 875880304, 308360096, 414636410,
886100267, 8525751, 636257427, 558338775, 500159951, 696213291, 97268896,
364983542, 937928436, 641582714, 586211304, 345265657, 994704486, 443549763,
207259440, 302122082, 166055224, 623250998, 239642551, 476337075, 283167364,
211328914, 68064804, 950202136, 187552679, 18938709, 646784245, 598764068,
538505481, 610424991, 864445053, 390248689, 278395191, 686098470, 935957187,
868529577, 329970687, 804930040, 84992079, 474569269, 810762228, 573258936,
756464212, 155080225, 286966169, 283614605, 19283401, 24257676, 871831819,
612689791, 846988741, 617120754, 971716517, 979541482, 297910784, 991087897,
783825907, 214821357, 689498189, 405026419, 946731704, 609346370, 707669156,
457703127, 957341187, 980735523, 649367684, 791011898, 82098966, 234729712,
105002711, 130614285, 291032164, 193188049, 363211260, 58108651, 100756444,
954947696, 346032213, 863300806, 36876722, 622610957, 289232396, 667938985,
734886266, 395881057, 417188702, 183092975, 887586469, 83334648, 797819763,
100176902, 781587414, 841864935, 371674670, 18247584};
} // namespace internal
int factorial_mod_998(int n) {
constexpr int MOD = 998244353;
if (n >= MOD) {
return 0;
}
using internal::BLOCK_SIZE;
int res = internal::fact_per_1e6[n / BLOCK_SIZE];
for (int i = (n / BLOCK_SIZE) * BLOCK_SIZE + 1; i <= n; i++) {
res = (long long)res * i % MOD;
}
return res;
}
} // namespace ebi
#line 8 "test/yuki/yuki_2747.test.cpp"
namespace ebi {
using mint = modint998244353;
void main_() {
int n,k;
std::cin >> n >> k;
linear_sieve sieve(k + 5);
auto f = [&](int s) -> mint {
std::vector<mint> f(s+2, 0);
auto pow_table = sieve.pow_table<mint>(s);
rep(i,1,s+2) {
f[i] = f[i-1] + pow_table[i];
}
return lagrange_interpolation(f, n-1);
};
mint ans = factorial_mod_998(n-1) * 2 * (n * f(k) - f(k+1));
std::cout << ans << '\n';
}
} // namespace ebi
int main() {
ebi::fast_io();
int t = 1;
// std::cin >> t;
while (t--) {
ebi::main_();
}
return 0;
}