結果
問題 |
No.3215 Make K types-able
|
ユーザー |
|
提出日時 | 2025-07-26 03:02:59 |
言語 | C++23 (gcc 13.3.0 + boost 1.87.0) |
結果 |
AC
|
実行時間 | 138 ms / 4,000 ms |
コード長 | 11,186 bytes |
コンパイル時間 | 6,937 ms |
コンパイル使用メモリ | 360,520 KB |
実行使用メモリ | 17,428 KB |
最終ジャッジ日時 | 2025-09-03 09:16:44 |
合計ジャッジ時間 | 10,722 ms |
ジャッジサーバーID (参考情報) |
judge5 / judge3 |
(要ログイン)
ファイルパターン | 結果 |
---|---|
sample | AC * 1 |
other | AC * 10 |
ソースコード
#define USE_ACLIBRARY 0 #if __has_include("all.hpp") && 0 #include "all.hpp" #else #include <bits/extc++.h> #if __has_include(<atcoder/all>) || USE_ACLIBRARY #include <atcoder/all> #endif #endif using ll = long long int; using pll = std::pair<ll, ll>; using pil = std::pair<int, ll>; using pli = std::pair<ll, int>; using pii = std::pair<int, int>; using namespace std::literals; template <class T> bool chmin(T &x, const T &val) { if (x > val) { x = val; return true; } else { return false; } } template <class T> bool chmax(T &x, const T &val) { if (x < val) { x = val; return true; } else { return false; } } ll isqrt(ll n) { assert(n >= 0); if (n == 0) return 0; uint32_t c = (std::bit_width(uint64_t(n)) - 1) / 2; ll a = 1; ll d = 0; for (int s = std::bit_width(c) - 1; s >= 0; s--) { ll e = d; d = c >> s; a = (a << (d - e - 1)) + (n >> (2 * c - e - d + 1)) / a; } return a - (a * a > n); } #if __has_include(<atcoder/all>) || USE_ACLIBRARY template <class mint, atcoder::internal::is_static_modint_t<mint> * = nullptr> std::ostream &operator<<(std::ostream &os, const mint &v) { return os << v.val(); } template <class mint, atcoder::internal::is_static_modint_t<mint> * = nullptr> std::istream &operator>>(std::istream &is, mint &v) { int tmp; is >> tmp; v = tmp; return is; } #endif template <class T, class U> std::istream &operator>>(std::istream &is, std::pair<T, U> &p) { return is >> p.first >> p.second; } template <class... T> std::istream &operator>>(std::istream &is, std::tuple<T...> &tpl) { std::apply([&](auto &&...args) { (is >> ... >> args); }, tpl); return is; } template <class T> std::istream &operator>>(std::istream &is, std::vector<T> &v) { for (T &x : v) is >> x; return is; } template <class T> std::ostream &operator<<(std::ostream &os, const std::vector<T> &v) { for (size_t i = 0; i < v.size(); i++) os << v[i] << (i == v.size() - 1 ? "" : " "); return os; } struct Initialization { Initialization() { std::ios_base::sync_with_stdio(false); std::cin.tie(nullptr); } } initialization; constexpr std::pair<int, int> dir[] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}}; template <typename T> using infs = std::numeric_limits<T>; template <typename T> class factorials { public: static size_t n; static std::vector<T> fact, inv_fact; static inline void extend(size_t m) { if (m <= n) return; fact.resize(m + 1); inv_fact.resize(m + 1); for (size_t i = n + 1; i <= m; i++) fact[i] = fact[i - 1] * i; inv_fact[m] = fact[m].inv(); for (size_t i = m; i > n + 1; i--) inv_fact[i - 1] = inv_fact[i] * i; n = m; } static T inv(int k) { extend(k); return inv_fact[k]; } static T get(int k) { extend(k); return fact[k]; } static T perm(int n, int k) { if (n < k) return 0; if (k < 0) return 0; extend(n); return fact[n] * inv_fact[n - k]; } static T choose(int n, int k) { if (n < k) return 0; if (k < 0) return 0; extend(n); return fact[n] * inv_fact[n - k] * inv_fact[k]; } static T catalan(int n) { return get(2 * n) * inv(n + 1) * inv(n); } }; template <typename T> size_t factorials<T>::n = 0; template <typename T> std::vector<T> factorials<T>::fact = {1}; template <typename T> std::vector<T> factorials<T>::inv_fact = {1}; #if __has_include(<atcoder/all>) || USE_ACLIBRARY using mint = atcoder::modint998244353; // using mint = atcoder::modint1000000007; using fs = factorials<mint>; #endif template <typename T> using pq_rev = std::priority_queue<T, std::vector<T>, std::greater<T>>; namespace pbds = __gnu_pbds; template <typename T> using tree = pbds::tree<T, pbds::null_type, std::less<T>, pbds::rb_tree_tag, pbds::tree_order_statistics_node_update>; // ========= fps.hpp ========= {{{ template <typename T> class formal_power_series { std::vector<T> v; using fps = formal_power_series; public: using value_type = T; using reference = T &; using const_reference = const T &; using iterator = typename std::vector<T>::iterator; using const_iterator = typename std::vector<T>::const_iterator; size_t size() const { return v.size(); } const std::vector<T> &data() const { return v; } explicit formal_power_series(int n) : v(n) {} formal_power_series(int n, T val) : v(n, val) {} formal_power_series(const std::vector<T> &v) : v(v) {} formal_power_series(std::vector<T> &&v) : v(v) {} template <class InputIterator> formal_power_series(InputIterator first, InputIterator last) : v(first, last) {} formal_power_series(std::initializer_list<T> init) : v(init) {} inline void resize(int n) { v.resize(n); } inline T &operator[](int i) { return v[i]; } inline iterator begin() { return v.begin(); } inline const_iterator begin() const { return v.begin(); } inline iterator end() { return v.end(); } inline const_iterator end() const { return v.end(); } fps take(int n) const { fps res(v.begin(), v.begin() + std::min(n, (int)v.size())); res.resize(n); return res; } fps diff() const { std::vector<T> res(v.size() - 1); for (int i = 0; i < res.size(); i++) res[i] = v[i + 1] * (i + 1); return fps(res); } fps integral() const { std::vector<T> res(v.size() + 1); for (int i = 0; i < v.size(); i++) res[i + 1] = v[i] / (i + 1); return fps(res); } fps inv(int deg = -1) const { assert(v[0] != 0); if (deg == -1) deg = size(); std::vector<T> res(deg); res[0] = v[0].inv(); T inv4 = T(4).inv(), invd = inv4; for (int d = 1; d < deg; d <<= 1) { std::vector<T> f(2 * d), g(2 * d); std::copy(v.begin(), v.begin() + std::min(2 * d, (int)v.size()), f.begin()); std::copy(res.begin(), res.begin() + d, g.begin()); atcoder::internal::butterfly(f); atcoder::internal::butterfly(g); for (int i = 0; i < 2 * d; i++) f[i] *= g[i]; atcoder::internal::butterfly_inv(f); for (int i = 0; i < d; i++) f[i] = 0; atcoder::internal::butterfly(f); for (int i = 0; i < 2 * d; i++) f[i] *= g[i]; atcoder::internal::butterfly_inv(f); for (int i = d; i < std::min(2 * d, deg); i++) res[i] = -f[i] * invd; invd *= inv4; } return res; } fps log(int deg = -1) const { assert(v[0] == 1); if (deg == -1) deg = size(); return (this->diff() * this->inv(deg)).take(deg - 1).integral(); } fps exp(int deg = -1) const { assert(v[0] == 0); if (deg == -1) deg = size(); fps g = {1}; for (int d = 1; d < deg; d <<= 1) { fps tmp = -g.log(2 * d); tmp += 1; tmp.trunc_add(*this); g *= tmp; g.resize(2 * d); } g.resize(deg); return g; } fps pow(ll n, int deg = -1) const { if (deg == -1) deg = size(); if (n == 0) return fps({1}).take(deg); if (n == 1) return this->take(deg); for (int i = 0; i < v.size(); i++) { if (ll(i) * n >= deg) { break; } if (v[i] != 0) { fps res(begin() + i, end()); res /= v[i]; res = (res.log(deg) * n).exp(deg); res *= v[i].pow(n); res.v.insert(res.v.begin(), i * n, 0); res.resize(deg); return res; } } return fps(deg); } fps shift(T c) const { std::vector<T> res(size()), ifacts(size()); factorials<T>::extend(size()); T x = 1; for (int i = 0; i < size(); i++) { ifacts[i] = x * factorials<T>::inv(i); x *= c; } for (int i = 0; i < size(); i++) { res[size() - 1 - i] = v[i] * factorials<T>::get(i); } res = atcoder::convolution(res, ifacts); res.resize(size()); std::ranges::reverse(res); for (int i = 0; i < size(); i++) { res[i] *= factorials<T>::inv(i); } return res; } fps &trunc_add(const fps &rhs) { for (int i = 0; i < v.size() && i < rhs.size(); i++) v[i] += rhs.v[i]; return *this; } fps operator-() const { fps res(v.size()); for (int i = 0; i < v.size(); i++) res[i] = -v[i]; return res; } fps &operator+=(const fps &rhs) { if (v.size() < rhs.v.size()) v.resize(rhs.v.size()); for (int i = 0; i < rhs.v.size(); i++) v[i] += rhs.v[i]; return *this; } fps &operator-=(const fps &rhs) { if (v.size() < rhs.v.size()) v.resize(rhs.v.size()); for (int i = 0; i < rhs.v.size(); i++) v[i] -= rhs.v[i]; return *this; } fps &operator*=(const fps &rhs) { return *this = atcoder::convolution(v, rhs.v); } fps &operator/=(const fps &rhs) { return *this *= rhs.inv(); } fps &operator+=(const T &rhs) { if (v.size() == 0) v.resize(1); v[0] += rhs; return *this; } fps &operator-=(const T &rhs) { if (v.size() == 0) v.resize(1); v[0] -= rhs; return *this; } fps &operator*=(const T &rhs) { for (int i = 0; i < v.size(); i++) v[i] *= rhs; return *this; } fps &operator/=(const T &rhs) { T rhs_inv = rhs.inv(); for (int i = 0; i < v.size(); i++) v[i] *= rhs_inv; return *this; } friend fps operator+(const fps &lhs, const fps &rhs) { return fps(lhs) += rhs; } friend fps operator-(const fps &lhs, const fps &rhs) { return fps(lhs) -= rhs; } friend fps operator*(const fps &lhs, const fps &rhs) { return fps(lhs) *= rhs; } friend fps operator/(const fps &lhs, const fps &rhs) { return fps(lhs) /= rhs; } friend fps operator+(const fps &lhs, const T &rhs) { return fps(lhs) += rhs; } friend fps operator-(const fps &lhs, const T &rhs) { return fps(lhs) -= rhs; } friend fps operator*(const fps &lhs, const T &rhs) { return fps(lhs) *= rhs; } friend fps operator/(const fps &lhs, const T &rhs) { return fps(lhs) /= rhs; } friend fps operator+(const T &lhs, const fps &rhs) { return fps(rhs) += lhs; } friend fps operator-(const T &lhs, const fps &rhs) { return -(fps(rhs) -= lhs); } friend fps operator*(const T &lhs, const fps &rhs) { return fps(rhs) *= lhs; } }; template <typename T> T bostan_mori(int n, formal_power_series<T> P, formal_power_series<T> Q) { assert(P.size() < Q.size()); P.resize(Q.size() - 1); while (n) { formal_power_series<mint> qm = Q; for (int i = 1; i < Q.size(); i += 2) qm[i] = -qm[i]; formal_power_series<mint> U = P * qm; formal_power_series<mint> V = Q * qm; for (int i = n & 1; i < U.size(); i += 2) P[i / 2] = U[i]; for (int i = 0; i < V.size(); i += 2) Q[i / 2] = V[i]; n /= 2; } return P[0] / Q[0]; } // ========= fps.hpp ========= }}} using fps = formal_power_series<mint>; int main() { int N = 200000; int K = 10; std::vector<fps> fs(N, fps(K)); fs[0][0] = 1; fs[0][1] = 1; mint m = 4; for (int i = 1; i < N; i++) { fs[i] = (fs[i - 1] * fs[i - 1]).take(K); fs[i][0] += m; m *= 2; m *= m; } int T; std::cin >> T; while (T--) { int N, K; std::cin >> N >> K; // std::cerr << fs[N - 1].data() << '\n'; if (K == 0) { std::cout << 1 << '\n'; } else { std::cout << fs[N - 1][K - 1] << '\n'; } } }