#990286 (Rust) No.2791 Beginner Contest

• 問題: No.2791 Beginner Contest
• ユーザー: Yukino DX.
• 提出日時: 2024-06-21 22:50:33
• 言語: Rust (1.77.0 + proconio)
• 結果: AC
• 実行時間: 3 ms / 2,000 ms
• コード長: 3,573 bytes
• コンパイル時間: 14,166 ms
• コンパイル使用メモリ: 403,912 KB
• 実行使用メモリ: 6,948 KB
• 最終ジャッジ日時: 2024-06-21 22:50:49
• 合計ジャッジ時間: 15,292 ms
• ジャッジサーバーID （参考情報）: judge1 / judge5

入力	結果	実行時間; 実行使用メモリ
testcase_00	AC	1 ms; 6,816 KB
testcase_01	AC	1 ms; 6,812 KB
testcase_02	AC	1 ms; 6,944 KB
testcase_03	AC	1 ms; 6,940 KB
testcase_04	AC	1 ms; 6,940 KB
testcase_05	AC	1 ms; 6,940 KB
testcase_06	AC	2 ms; 6,944 KB
testcase_07	AC	1 ms; 6,940 KB
testcase_08	AC	1 ms; 6,940 KB
testcase_09	AC	3 ms; 6,944 KB
testcase_10	AC	3 ms; 6,940 KB
testcase_11	AC	3 ms; 6,940 KB
testcase_12	AC	3 ms; 6,940 KB
testcase_13	AC	3 ms; 6,940 KB
testcase_14	AC	1 ms; 6,940 KB
testcase_15	AC	3 ms; 6,940 KB
testcase_16	AC	1 ms; 6,944 KB
testcase_17	AC	1 ms; 6,948 KB
testcase_18	AC	3 ms; 6,940 KB
testcase_19	AC	3 ms; 6,940 KB

ソースコード

use proconio::input;

fn main() {
    input! {
        n:usize,
        k:usize,
    }

    let mut dp = vec![ModInt::<MOD>::new(0); n + 1];
    dp[0] = ModInt::new(1);
    let mut dp_sum = vec![ModInt::new(0); n + 1];
    dp_sum[0] = ModInt::new(1);
    for i in 1..=n {
        if i >= k {
            dp[i] = dp_sum[i - k];
        }
        dp_sum[i] = dp_sum[i - 1] + dp[i];
    }

    let mut ans = ModInt::new(0);
    for i in 0..=n {
        ans += dp[i];
    }
    println!("{}", ans);
}

const MOD: usize = 998244353;
use modint::*;
mod modint {
    use std::fmt;
    use std::ops;

    #[derive(Copy, Clone, PartialEq, Eq)]
    pub struct ModInt<const MOD: usize> {
        pub val: usize,
    }

    impl<const MOD: usize> ModInt<MOD> {
        pub fn new(val: usize) -> Self {
            Self { val: val % MOD }
        }

        pub fn pow(mut self, mut e: usize) -> Self {
            let mut res = Self::new(1);
            while 0 < e {
                if e & 1 != 0 {
                    res *= self;
                }

                self *= self;
                e >>= 1;
            }

            res
        }
    }

    impl<const MOD: usize> From<usize> for ModInt<MOD> {
        fn from(value: usize) -> Self {
            Self { val: value % MOD }
        }
    }

    impl<const MOD: usize> fmt::Display for ModInt<MOD> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            write!(f, "{}", self.val)
        }
    }

    impl<const MOD: usize> fmt::Debug for ModInt<MOD> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            write!(f, "{}", self.val)
        }
    }

    impl<const MOD: usize> ops::Neg for ModInt<MOD> {
        type Output = Self;

        fn neg(self) -> Self::Output {
            Self {
                val: (MOD - self.val) % MOD,
            }
        }
    }

    impl<const MOD: usize> ops::Add for ModInt<MOD> {
        type Output = Self;

        fn add(self, rhs: Self) -> Self::Output {
            Self {
                val: (self.val + rhs.val) % MOD,
            }
        }
    }

    impl<const MOD: usize> ops::AddAssign for ModInt<MOD> {
        fn add_assign(&mut self, rhs: Self) {
            *self = *self + rhs;
        }
    }

    impl<const MOD: usize> ops::Mul for ModInt<MOD> {
        type Output = Self;

        fn mul(self, rhs: Self) -> Self::Output {
            Self {
                val: self.val * rhs.val % MOD,
            }
        }
    }

    impl<const MOD: usize> ops::MulAssign for ModInt<MOD> {
        fn mul_assign(&mut self, rhs: Self) {
            *self = *self * rhs;
        }
    }

    impl<const MOD: usize> ops::Sub for ModInt<MOD> {
        type Output = Self;

        fn sub(mut self, rhs: Self) -> Self::Output {
            if self.val < rhs.val {
                self.val += MOD;
            }

            Self {
                val: (self.val - rhs.val) % MOD,
            }
        }
    }

    impl<const MOD: usize> ops::SubAssign for ModInt<MOD> {
        fn sub_assign(&mut self, rhs: Self) {
            if self.val < rhs.val {
                self.val += MOD;
            }

            *self = *self - rhs;
        }
    }

    impl<const MOD: usize> ops::Div for ModInt<MOD> {
        type Output = Self;

        fn div(self, rhs: Self) -> Self {
            assert!(rhs.val != 0);
            self * rhs.pow(MOD - 2)
        }
    }

    impl<const MOD: usize> ops::DivAssign for ModInt<MOD> {
        fn div_assign(&mut self, rhs: Self) {
            *self = *self / rhs
        }
    }
}