結果

問題 No.2685 Cell Proliferation (Easy)
ユーザー downerdowner
提出日時 2024-03-21 00:35:26
言語 C++23
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 13 ms / 2,000 ms
コード長 3,865 bytes
コンパイル時間 2,763 ms
コンパイル使用メモリ 251,744 KB
実行使用メモリ 11,264 KB
最終ジャッジ日時 2024-09-30 09:49:42
合計ジャッジ時間 3,742 ms
ジャッジサーバーID
（参考情報） 		judge3 / judge1
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
5,248 KB
testcase_01 AC 13 ms
11,264 KB
testcase_02 AC 2 ms
5,248 KB
testcase_03 AC 7 ms
7,168 KB
testcase_04 AC 7 ms
8,064 KB
testcase_05 AC 3 ms
5,248 KB
testcase_06 AC 5 ms
6,272 KB
testcase_07 AC 6 ms
6,816 KB
testcase_08 AC 6 ms
7,168 KB
testcase_09 AC 9 ms
8,960 KB
testcase_10 AC 5 ms
6,820 KB
testcase_11 AC 4 ms
6,816 KB
testcase_12 AC 5 ms
6,820 KB
testcase_13 AC 6 ms
6,816 KB
testcase_14 AC 7 ms
7,808 KB
testcase_15 AC 11 ms
10,752 KB
testcase_16 AC 6 ms
7,296 KB
testcase_17 AC 2 ms
6,820 KB
testcase_18 AC 5 ms
6,820 KB
testcase_19 AC 5 ms
6,816 KB
testcase_20 AC 3 ms
6,820 KB
testcase_21 AC 3 ms
6,816 KB
testcase_22 AC 9 ms
9,728 KB
testcase_23 AC 3 ms
6,820 KB
testcase_24 AC 10 ms
11,264 KB
testcase_25 AC 7 ms
8,576 KB
testcase_26 AC 5 ms
6,912 KB
testcase_27 AC 2 ms
6,816 KB
testcase_28 AC 5 ms
7,168 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <bits/stdc++.h>
using namespace std;

// modint
// using mint = MontgomeryModInt64; と定義する
// mint::set_mod(M); でmodをMに設定する
struct MontgomeryModInt64 {
    using mint = MontgomeryModInt64;
    using u64 = uint64_t;
    using u128 = __uint128_t;

    // static変数
    // R = 2 ^ 64
    static inline u64 MOD;
    static inline u64 INV_MOD;  // INV_MOD * MOD ≡ 1 (mod 2 ^ 64)
    static inline u64 T128;     // 2 ^ 128 (mod MOD)

    u64 val;

    // コンストラクタ
    // MODを足す？
    MontgomeryModInt64(): val(0) {}
    MontgomeryModInt64(long long v): val(MR((u128(v) + MOD) * T128)) {}

    // 値を返す
    u64 get() const {
        u64 res = MR(val);
        return res >= MOD ? res - MOD : res;
    }

    // static関数
    static u64 get_mod() { return MOD; }
    static void set_mod(u64 mod) {
        MOD = mod;
        T128 = -u128(mod) % mod;
        INV_MOD = get_inv_mod();
    }
    // ニュートン法で逆元を求める
    static u64 get_inv_mod() {
        u64 res = MOD;
        for(int i = 0; i < 5; ++i) res *= 2 - MOD * res;
        return res;
    }
    // モンゴメリリダクション
    static u64 MR(const u128& v) {
        return (v + u128(u64(v) * u64(-INV_MOD)) * MOD) >> 64;
    }

    // 算術演算子
    mint operator - () const { return mint() - mint(*this); }

    mint operator + (const mint& r) const { return mint(*this) += r; }
    mint operator - (const mint& r) const { return mint(*this) -= r; }
    mint operator * (const mint& r) const { return mint(*this) *= r; }
    mint operator / (const mint& r) const { return mint(*this) /= r; }

    mint& operator += (const mint& r) {
        if((val += r.val) >= 2 * MOD) val -= 2 * MOD;
        return *this;
    }
    mint& operator -= (const mint& r) {
        if((val += 2 * MOD - r.val) >= 2 * MOD) val -= 2 * MOD;
        return *this;
    }
    mint& operator *= (const mint& r) {
        val = MR(u128(val) * r.val);
        return *this;
    }
    mint& operator /= (const mint& r) {
        *this *= r.inv();
        return *this;
    }

    mint inv() const { return pow(MOD - 2); }
    mint pow(u128 n) const {
        mint res(1), mul(*this);
        while(n > 0) {
            if(n & 1) res *= mul;
            mul *= mul;
            n >>= 1;
        }
        return res;
    }

    // その他演算子
    bool operator == (const mint& r) const {
        return (val >= MOD ? val - MOD : val) == (r.val >= MOD ? r.val - MOD : r.val);
    }
    bool operator != (const mint& r) const {
        return (val >= MOD ? val - MOD : val) != (r.val >= MOD ? r.val - MOD : r.val);
    }

    // 入力
    friend istream& operator >> (istream& is, mint& x) {
        long long t;
        is >> t;
        x = mint(t);
        return is;
    }
    // 出力
    friend ostream& operator << (ostream& os, const mint& x) {
        return os << x.get();
    }
    friend mint modpow(const mint& r, long long n) {
        return r.pow(n);
    } 
    friend mint modinv(const mint& r) {
        return r.inv();
    }
};

using mint = MontgomeryModInt64;

int main() {
    mint::set_mod(998244353);

    int P1, P2, Q1, Q2, T;
    cin >> P1 >> P2 >> Q1 >> Q2 >> T;

    mint P = mint(P1) / P2;

    vector<mint> Q(T + 1);
    Q[0] = 1;
    for(int i = 0; i < T; i++) {
        Q[i + 1] = Q[i] * Q1 / Q2;
    }

    vector<vector<mint>> dp(T + 1, vector<mint>(T + 1, 0));
    dp[0][0] = 1;

    vector<mint> sm(T + 1, 0);
    
    for(int i = 0; i < T; i++) {
        for(int j = 0; j <= T; j++) {
            sm[i] += dp[i][j]; 
        }

        dp[i + 1][0] += sm[i] * P;

        for(int j = 0; j < T; j++) {
            dp[i + 1][j + 1] = Q[j + 1] * dp[i][j];
        }
    }

    mint ans = 0;
    for(int i = 0; i <= T; i++) {
        ans += dp[T][i];
    }

    cout << ans << endl;

    return 0;
}
0