#768546 (C++14) No.1964 sum = length

• 問題: No.1964 sum = length
• ユーザー: 🍮かんプリン
• 提出日時: 2022-06-05 20:24:05
• 言語: C++14 (gcc 12.3.0 + boost 1.83.0)
• 結果: AC
• 実行時間: 2 ms / 2,000 ms
• コード長: 4,670 bytes
• コンパイル時間: 1,891 ms
• コンパイル使用メモリ: 176,732 KB
• 実行使用メモリ: 6,948 KB
• 最終ジャッジ日時: 2024-09-21 04:17:03
• 合計ジャッジ時間: 2,712 ms
• ジャッジサーバーID （参考情報）: judge5 / judge3

入力	結果	実行時間; 実行使用メモリ
testcase_00	AC	2 ms; 6,816 KB
testcase_01	AC	1 ms; 6,940 KB
testcase_02	AC	2 ms; 6,944 KB
testcase_03	AC	2 ms; 6,940 KB
testcase_04	AC	1 ms; 6,944 KB
testcase_05	AC	2 ms; 6,944 KB
testcase_06	AC	1 ms; 6,940 KB
testcase_07	AC	2 ms; 6,944 KB
testcase_08	AC	1 ms; 6,940 KB
testcase_09	AC	2 ms; 6,944 KB
testcase_10	AC	2 ms; 6,940 KB
testcase_11	AC	1 ms; 6,944 KB
testcase_12	AC	1 ms; 6,940 KB
testcase_13	AC	1 ms; 6,940 KB
testcase_14	AC	2 ms; 6,940 KB
testcase_15	AC	2 ms; 6,944 KB
testcase_16	AC	2 ms; 6,940 KB
testcase_17	AC	1 ms; 6,944 KB
testcase_18	AC	1 ms; 6,940 KB
testcase_19	AC	2 ms; 6,940 KB
testcase_20	AC	2 ms; 6,940 KB
testcase_21	AC	1 ms; 6,940 KB
testcase_22	AC	1 ms; 6,940 KB
testcase_23	AC	1 ms; 6,944 KB
testcase_24	AC	1 ms; 6,944 KB
testcase_25	AC	2 ms; 6,940 KB
testcase_26	AC	2 ms; 6,948 KB
testcase_27	AC	1 ms; 6,940 KB
testcase_28	AC	1 ms; 6,940 KB
testcase_29	AC	2 ms; 6,940 KB
testcase_30	AC	2 ms; 6,940 KB
testcase_31	AC	2 ms; 6,944 KB
testcase_32	AC	2 ms; 6,944 KB
testcase_33	AC	1 ms; 6,940 KB
testcase_34	AC	1 ms; 6,940 KB
testcase_35	AC	2 ms; 6,940 KB
testcase_36	AC	2 ms; 6,944 KB
testcase_37	AC	2 ms; 6,940 KB
testcase_38	AC	2 ms; 6,940 KB
testcase_39	AC	2 ms; 6,940 KB
testcase_40	AC	2 ms; 6,944 KB
testcase_41	AC	2 ms; 6,940 KB
testcase_42	AC	2 ms; 6,940 KB

ソースコード

/**
 *   @FileName	a.cpp
 *   @Author	kanpurin
 *   @Created	2022.06.05 20:23:59
**/

#include "bits/stdc++.h" 
using namespace std; 
typedef long long ll;


template< int MOD >
struct mint {
public:
    unsigned int x;
    mint() : x(0) {}
    mint(long long v) {
        long long w = (long long)(v % (long long)(MOD));
        if (w < 0) w += MOD;
        x = (unsigned int)(w);
    }
    mint(std::string &s) {
        unsigned int z = 0;
        for (int i = 0; i < s.size(); i++) {
            z *= 10;
            z += s[i] - '0';
            z %= MOD;
        }
        x = z;
    }
    mint operator+() const { return *this; }
    mint operator-() const { return mint() - *this; }
    mint& operator+=(const mint &a) {
        if ((x += a.x) >= MOD) x -= MOD;
        return *this;
    }
    mint& operator-=(const mint &a) {
        if ((x -= a.x) >= MOD) x += MOD;
        return *this;
    }
    mint& operator*=(const mint &a) {
        unsigned long long z = x;
        z *= a.x;
        x = (unsigned int)(z % MOD);
        return *this;
    }
    mint& operator/=(const mint &a) {return *this = *this * a.inv(); }
    friend mint operator+(const mint& lhs, const mint& rhs) {
        return mint(lhs) += rhs;
    }
    friend mint operator-(const mint& lhs, const mint& rhs) {
        return mint(lhs) -= rhs;
    }
    friend mint operator*(const mint& lhs, const mint& rhs) {
        return mint(lhs) *= rhs;
    }
    friend mint operator/(const mint& lhs, const mint& rhs) {
        return mint(lhs) /= rhs;
    }
    friend bool operator==(const mint& lhs, const mint& rhs) {
        return lhs.x == rhs.x;
    }
    friend bool operator!=(const mint& lhs, const mint& rhs) {
        return lhs.x != rhs.x;
    }
    friend std::ostream& operator<<(std::ostream &os, const mint &n) {
        return os << n.x;
    }
    friend std::istream &operator>>(std::istream &is, mint &n) {
        unsigned int x;
        is >> x;
        n = mint(x);
        return is;
    }
    mint inv() const {
        assert(x);
        return pow(MOD-2);
    }
    mint pow(long long n) const {        
        assert(0 <= n);
        mint p = *this, r = 1;
        while (n) {
            if (n & 1) r *= p;
            p *= p;
            n >>= 1;
        }
        return r;
    }
    
    mint sqrt() const {
        if (this->x < 2) return *this;
        if (this->pow((MOD-1)>>1).x != 1) return mint(0);
        mint b = 1, one = 1;
        while (b.pow((MOD-1) >> 1) == 1) b += one;
        long long m = MOD-1, e = 0;
        while (m % 2 == 0) m >>= 1, e += 1;
        mint x = this->pow((m - 1) >> 1);
        mint y = (*this) * x * x;
        x *= (*this);
        mint z = b.pow(m);
        while (y.x != 1) {
            int j = 0;
            mint t = y;
            while (t != one) j += 1, t *= t;
            z = z.pow(1LL << (e-j-1));
            x *= z; z *= z; y *= z; e = j;
        }
        return x;
    }
};

constexpr int MOD = 998244353;

vector<mint<MOD>> pow_sparse(vector<mint<MOD>> f, ll m) {
    assert(f.size() > 0 && f[0] != 0);
    vector<mint<MOD>> g(f.size());
    vector<int> fl;
    mint<MOD> invf0 = f[0].inv();
    vector<ll> inv(g.size(),1);
    g[0] = f[0].pow(m);
    for (int i = 2; i < g.size(); i++) inv[i] = MOD - (MOD / i) * inv[MOD%i] % MOD;
    for (int i = 0; i < f.size(); i++) {
        if (f[i] == 0) continue;
        fl.push_back(i);
    }
    for (int i = 1; i < g.size(); i++) {
        for (int j = 0; j < fl.size(); j++) {
            int p = fl[j];
            if (1 <= p && p <= i) g[i] += f[p]*g[i-p]*p*m;
            if (1 <= p && p <= i-1) g[i] -= f[p]*g[i-p]*(i-p);
        }
        g[i] = g[i]*f[0]*inv[i];
    }
    return g;
}

template<typename T>
struct Combination {
private:
    int N;

public:
    vector< T > FACT, IFACT;
    Combination(int n) : N(n) {
        FACT.resize(n + 1);
        IFACT.resize(n + 1);
        FACT[0] = 1;
        for (int i = 1; i <= n; i++) {
            FACT[i] = FACT[i - 1] * i;
        }
        IFACT[n] = T(1) / FACT[n];
        for (int i = n-1; i >= 0; i--) {
            IFACT[i] = IFACT[i+1] * (i+1);
        }
    }

    T comb(int n, int r) {
        if (n < 0 || r < 0 || r > n) return 0;
        if (r > n / 2) r = n - r;
        return FACT[n] * IFACT[n - r] * IFACT[r];
    }
};

int main() {
    int n;cin >> n;
    vector<mint<MOD>> f(201);
    Combination<mint<MOD>> cb(2*n);
    f[0] = 1;
    f[8] = 1;
    f[9] = -1;
    f[97] = 1;
    f[98] = -1;
    f[200] = -1;
    f = pow_sparse(f,n);
    mint<MOD> ans = 0;
    for (int i = 0; i <= n-1; i++) {
        ans += f[i]*cb.comb(2*n-i-2,n-1-i);
    }
    cout << ans << endl;
    return 0;
}