結果
問題 | No.2514 Twelvefold Way Returns |
ユーザー |
![]() |
提出日時 | 2023-11-19 17:10:36 |
言語 | Rust (1.83.0 + proconio) |
結果 |
AC
|
実行時間 | 90 ms / 3,000 ms |
コード長 | 10,616 bytes |
コンパイル時間 | 12,484 ms |
コンパイル使用メモリ | 379,548 KB |
実行使用メモリ | 5,376 KB |
最終ジャッジ日時 | 2024-09-26 06:17:50 |
合計ジャッジ時間 | 15,763 ms |
ジャッジサーバーID (参考情報) |
judge5 / judge4 |
(要ログイン)
ファイルパターン | 結果 |
---|---|
sample | AC * 3 |
other | AC * 38 |
コンパイルメッセージ
warning: associated constants `PRIMITIVE_ROOT` and `ORDER` are never used --> src/main.rs:214:11 | 198 | impl<const M: u32> ModInt<{ M }> { | -------------------------------- associated constants in this implementation ... 214 | const PRIMITIVE_ROOT: u32 = primitive_root(M); | ^^^^^^^^^^^^^^ 215 | const ORDER: usize = 1 << (M - 1).trailing_zeros(); | ^^^^^ | = note: `#[warn(dead_code)]` on by default
ソースコード
// exp のmod 3 で1の項のM乗のN項目が答え// exp でmod3 で 1の項を取り出すには?// 3乗根をw と置いて//// f(x) + f(wx) + f(w^2x) で0が取り出せる// f(x) + w^2 f(wx) + wf(w^2x) でOKなはず//// N! [x^n] (e^x + w^2 e(wx) + w e^(w^2x))^m// = N! [x^n] sum_{0 <= i, j, i + j <= m} M!/i!j!(M-i-j)! * w^(2j + M-i-j) * e^(ix + jwx + (M-i-j)w^2x)// = sum_{i, j} C_{i, j} * w^(M-i+j) * (i+jw+(M-i-j)w^2)^ntype M = ModInt<998_244_353>;fn main() {input!(n: usize, m: usize);let mut ans = M::zero();let pc = Precalc::new(m);let w = P(M::zero(), M::one());for i in 0..=m {for j in 0..=(m - i) {let k = m - i - j;let mut r = P(M::from(i), M::zero())+ P(M::from(j), M::zero()) * w+ P(M::from(k), M::zero()) * w * w;let mut n = n;let mut t = P(M::one(), M::zero());while n > 0 {if n & 1 == 1 {t = t * r;}r = r * r;n >>= 1;}for _ in 0..(2 * j + k) {t = t * w;}let val = t.0 * pc.fact(m) * pc.ifact(i) * pc.ifact(j) * pc.ifact(k);ans += val;}}ans *= M::new(3).inv().pow(m as u64);println!("{}", ans);}#[derive(Clone, Copy, Debug)]struct P(M, M);impl Add for P {type Output = Self;fn add(self, rhs: Self) -> Self {Self(self.0 + rhs.0, self.1 + rhs.1)}}impl Mul for P {type Output = Self;fn mul(self, rhs: Self) -> Self {let p = self.1 * rhs.1;Self(self.0 * rhs.0 - p, self.0 * rhs.1 + self.1 * rhs.0 - p)}}// ---------- begin input macro ----------// reference: https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8#[macro_export]macro_rules! input {(source = $s:expr, $($r:tt)*) => {let mut iter = $s.split_whitespace();input_inner!{iter, $($r)*}};($($r:tt)*) => {let s = {use std::io::Read;let mut s = String::new();std::io::stdin().read_to_string(&mut s).unwrap();s};let mut iter = s.split_whitespace();input_inner!{iter, $($r)*}};}#[macro_export]macro_rules! input_inner {($iter:expr) => {};($iter:expr, ) => {};($iter:expr, $var:ident : $t:tt $($r:tt)*) => {let $var = read_value!($iter, $t);input_inner!{$iter $($r)*}};}#[macro_export]macro_rules! read_value {($iter:expr, ( $($t:tt),* )) => {( $(read_value!($iter, $t)),* )};($iter:expr, [ $t:tt ; $len:expr ]) => {(0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()};($iter:expr, chars) => {read_value!($iter, String).chars().collect::<Vec<char>>()};($iter:expr, bytes) => {read_value!($iter, String).bytes().collect::<Vec<u8>>()};($iter:expr, usize1) => {read_value!($iter, usize) - 1};($iter:expr, $t:ty) => {$iter.next().unwrap().parse::<$t>().expect("Parse error")};}// ---------- end input macro ----------use std::ops::*;// ---------- begin trait ----------pub trait Zero: Sized + Add<Self, Output = Self> {fn zero() -> Self;fn is_zero(&self) -> bool;}pub trait One: Sized + Mul<Self, Output = Self> {fn one() -> Self;fn is_one(&self) -> bool;}pub trait Ring: Zero + One + Sub<Output = Self> {}pub trait Field: Ring + Div<Output = Self> {}// ---------- end trait ----------// ---------- begin modint ----------pub const fn pow_mod(mut r: u32, mut n: u32, m: u32) -> u32 {let mut t = 1;while n > 0 {if n & 1 == 1 {t = (t as u64 * r as u64 % m as u64) as u32;}r = (r as u64 * r as u64 % m as u64) as u32;n >>= 1;}t}pub const fn primitive_root(p: u32) -> u32 {let mut m = p - 1;let mut f = [1; 30];let mut k = 0;let mut d = 2;while d * d <= m {if m % d == 0 {f[k] = d;k += 1;}while m % d == 0 {m /= d;}d += 1;}if m > 1 {f[k] = m;k += 1;}let mut g = 1;while g < p {let mut ok = true;let mut i = 0;while i < k {ok &= pow_mod(g, (p - 1) / f[i], p) > 1;i += 1;}if ok {break;}g += 1;}g}pub const fn is_prime(n: u32) -> bool {if n <= 1 {return false;}let mut d = 2;while d * d <= n {if n % d == 0 {return false;}d += 1;}true}#[derive(Clone, Copy, PartialEq, Eq)]pub struct ModInt<const M: u32>(u32);impl<const M: u32> ModInt<{ M }> {const REM: u32 = {let mut t = 1u32;let mut s = !M + 1;let mut n = !0u32 >> 2;while n > 0 {if n & 1 == 1 {t = t.wrapping_mul(s);}s = s.wrapping_mul(s);n >>= 1;}t};const INI: u64 = ((1u128 << 64) % M as u128) as u64;const IS_PRIME: () = assert!(is_prime(M));const PRIMITIVE_ROOT: u32 = primitive_root(M);const ORDER: usize = 1 << (M - 1).trailing_zeros();const fn reduce(x: u64) -> u32 {let _ = Self::IS_PRIME;let b = (x as u32 * Self::REM) as u64;let t = x + b * M as u64;let mut c = (t >> 32) as u32;if c >= M {c -= M;}c as u32}const fn multiply(a: u32, b: u32) -> u32 {Self::reduce(a as u64 * b as u64)}pub const fn new(v: u32) -> Self {assert!(v < M);Self(Self::reduce(v as u64 * Self::INI))}pub const fn const_mul(&self, rhs: Self) -> Self {Self(Self::multiply(self.0, rhs.0))}pub const fn pow(&self, mut n: u64) -> Self {let mut t = Self::new(1);let mut r = *self;while n > 0 {if n & 1 == 1 {t = t.const_mul(r);}r = r.const_mul(r);n >>= 1;}t}pub const fn inv(&self) -> Self {assert!(self.0 != 0);self.pow(M as u64 - 2)}pub const fn get(&self) -> u32 {Self::reduce(self.0 as u64)}pub const fn zero() -> Self {Self::new(0)}pub const fn one() -> Self {Self::new(1)}}impl<const M: u32> Add for ModInt<{ M }> {type Output = Self;fn add(self, rhs: Self) -> Self::Output {let mut v = self.0 + rhs.0;if v >= M {v -= M;}Self(v)}}impl<const M: u32> Sub for ModInt<{ M }> {type Output = Self;fn sub(self, rhs: Self) -> Self::Output {let mut v = self.0 - rhs.0;if self.0 < rhs.0 {v += M;}Self(v)}}impl<const M: u32> Mul for ModInt<{ M }> {type Output = Self;fn mul(self, rhs: Self) -> Self::Output {self.const_mul(rhs)}}impl<const M: u32> Div for ModInt<{ M }> {type Output = Self;fn div(self, rhs: Self) -> Self::Output {self * rhs.inv()}}impl<const M: u32> AddAssign for ModInt<{ M }> {fn add_assign(&mut self, rhs: Self) {*self = *self + rhs;}}impl<const M: u32> SubAssign for ModInt<{ M }> {fn sub_assign(&mut self, rhs: Self) {*self = *self - rhs;}}impl<const M: u32> MulAssign for ModInt<{ M }> {fn mul_assign(&mut self, rhs: Self) {*self = *self * rhs;}}impl<const M: u32> DivAssign for ModInt<{ M }> {fn div_assign(&mut self, rhs: Self) {*self = *self / rhs;}}impl<const M: u32> Neg for ModInt<{ M }> {type Output = Self;fn neg(self) -> Self::Output {if self.0 == 0 {self} else {Self(M - self.0)}}}impl<const M: u32> std::fmt::Display for ModInt<{ M }> {fn fmt<'a>(&self, f: &mut std::fmt::Formatter<'a>) -> std::fmt::Result {write!(f, "{}", self.get())}}impl<const M: u32> std::fmt::Debug for ModInt<{ M }> {fn fmt<'a>(&self, f: &mut std::fmt::Formatter<'a>) -> std::fmt::Result {write!(f, "{}", self.get())}}impl<const M: u32> std::str::FromStr for ModInt<{ M }> {type Err = std::num::ParseIntError;fn from_str(s: &str) -> Result<Self, Self::Err> {let val = s.parse::<u32>()?;Ok(ModInt::new(val))}}impl<const M: u32> From<usize> for ModInt<{ M }> {fn from(val: usize) -> ModInt<{ M }> {ModInt::new((val % M as usize) as u32)}}// ---------- end modint ----------// ---------- begin precalc ----------pub struct Precalc<const MOD: u32> {fact: Vec<ModInt<MOD>>,ifact: Vec<ModInt<MOD>>,inv: Vec<ModInt<MOD>>,}impl<const MOD: u32> Precalc<MOD> {pub fn new(size: usize) -> Self {let mut fact = vec![ModInt::one(); size + 1];let mut ifact = vec![ModInt::one(); size + 1];let mut inv = vec![ModInt::one(); size + 1];for i in 2..=size {fact[i] = fact[i - 1] * ModInt::from(i);}ifact[size] = fact[size].inv();for i in (2..=size).rev() {inv[i] = ifact[i] * fact[i - 1];ifact[i - 1] = ifact[i] * ModInt::from(i);}Self { fact, ifact, inv }}pub fn fact(&self, n: usize) -> ModInt<MOD> {self.fact[n]}pub fn ifact(&self, n: usize) -> ModInt<MOD> {self.ifact[n]}pub fn inv(&self, n: usize) -> ModInt<MOD> {assert!(0 < n);self.inv[n]}pub fn perm(&self, n: usize, k: usize) -> ModInt<MOD> {if k > n {return ModInt::zero();}self.fact[n] * self.ifact[n - k]}pub fn binom(&self, n: usize, k: usize) -> ModInt<MOD> {if n < k {return ModInt::zero();}self.fact[n] * self.ifact[k] * self.ifact[n - k]}}// ---------- end precalc ----------impl<const M: u32> Zero for ModInt<{ M }> {fn zero() -> Self {Self::zero()}fn is_zero(&self) -> bool {self.0 == 0}}impl<const M: u32> One for ModInt<{ M }> {fn one() -> Self {Self::one()}fn is_one(&self) -> bool {self.get() == 1}}impl<const M: u32> Ring for ModInt<{ M }> {}impl<const M: u32> Field for ModInt<{ M }> {}// ---------- begin array op ----------