結果
問題 | No.895 MESE |
ユーザー | nebocco |
提出日時 | 2021-02-26 19:52:05 |
言語 | Rust (1.77.0 + proconio) |
結果 |
AC
|
実行時間 | 18 ms / 2,000 ms |
コード長 | 7,463 bytes |
コンパイル時間 | 26,213 ms |
コンパイル使用メモリ | 401,104 KB |
実行使用メモリ | 6,820 KB |
最終ジャッジ日時 | 2024-10-02 12:15:00 |
合計ジャッジ時間 | 14,964 ms |
ジャッジサーバーID (参考情報) |
judge1 / judge3 |
(要ログイン)
テストケース
テストケース表示入力 | 結果 | 実行時間 実行使用メモリ |
---|---|---|
testcase_00 | AC | 1 ms
6,816 KB |
testcase_01 | AC | 1 ms
6,816 KB |
testcase_02 | AC | 1 ms
6,820 KB |
testcase_03 | AC | 1 ms
6,816 KB |
testcase_04 | AC | 1 ms
6,816 KB |
testcase_05 | AC | 0 ms
6,816 KB |
testcase_06 | AC | 1 ms
6,816 KB |
testcase_07 | AC | 1 ms
6,816 KB |
testcase_08 | AC | 1 ms
6,816 KB |
testcase_09 | AC | 1 ms
6,816 KB |
testcase_10 | AC | 1 ms
6,816 KB |
testcase_11 | AC | 1 ms
6,820 KB |
testcase_12 | AC | 1 ms
6,816 KB |
testcase_13 | AC | 8 ms
6,816 KB |
testcase_14 | AC | 13 ms
6,820 KB |
testcase_15 | AC | 14 ms
6,820 KB |
testcase_16 | AC | 10 ms
6,816 KB |
testcase_17 | AC | 6 ms
6,816 KB |
testcase_18 | AC | 18 ms
6,816 KB |
testcase_19 | AC | 17 ms
6,816 KB |
testcase_20 | AC | 17 ms
6,820 KB |
testcase_21 | AC | 16 ms
6,820 KB |
testcase_22 | AC | 17 ms
6,816 KB |
testcase_23 | AC | 17 ms
6,816 KB |
testcase_24 | AC | 18 ms
6,820 KB |
testcase_25 | AC | 17 ms
6,816 KB |
testcase_26 | AC | 18 ms
6,816 KB |
testcase_27 | AC | 17 ms
6,820 KB |
testcase_28 | AC | 17 ms
6,820 KB |
ソースコード
fn main() { let mut io = IO::new(); input!{ from io, a: usize, b: usize, c: usize } const MOD: i64 = 1_000_000_007; let n = a + b + c; let fact = Fact::new(n, MOD); let mut ans = 0; for i in 1..=a { let mean = modpow(2, (n - i - 1) as i64, MOD) - 1; ans = (ans + mean * fact.multi(&vec![a - i, b - 1, c - 1])) % MOD; } io.println(ans); } pub fn modpow(mut x: i64, mut y: i64, modulo: i64) -> i64 { x %= modulo; if x == 0 { return 0; } let mut ret = 1; let mut cur = x; while y > 0 { if y & 1 > 0 { ret = ret * cur % modulo; } cur = cur * cur % modulo; y >>= 1; } ret } // ------------ struct Fact start ------------ pub struct Fact { modulo: i64, fact: Vec<i64>, inv_fact: Vec<i64> } impl Fact { pub fn new(size: usize, modulo: i64) -> Self { let mut fact = vec![1; size + 1]; let mut inv_fact = vec![1; size + 1]; for i in 1..size+1 { fact[i] = fact[i-1] * i as i64 % modulo; } inv_fact[size] = Self::modinv(fact[size], modulo); for i in (1..size+1).rev() { inv_fact[i-1] = inv_fact[i] * i as i64 % modulo; } Fact { modulo, fact, inv_fact } } pub fn extgcd(a: i64, b: i64) -> (i64, i64) { let mut x1 = 1; let mut y1 = 0; let mut m = a; let mut x2 = 0; let mut y2 = 1; let mut n = b; while m % n != 0 { let q = m / n; x1 -= q * x2; y1 -= q * y2; m -= q * n; std::mem::swap(&mut x1, &mut x2); std::mem::swap(&mut y1, &mut y2); std::mem::swap(&mut m, &mut n); } (x2, y2) } pub fn modinv(mut x: i64, modulo: i64) -> i64 { x = x.rem_euclid(modulo); Self::extgcd(x, modulo).0.rem_euclid(modulo) } pub fn permutation(&self, n:usize, r:usize) -> i64 { assert!(r > n || n < self.fact.len(), "index out of range: length is {}, but given {}", self.fact.len(), n); if n < r { return 0 }; self.fact[n] * self.inv_fact[n-r] % self.modulo } pub fn combination(&self, n:usize, r:usize) -> i64 { assert!(r > n || n < self.fact.len(), "index out of range: length is {}, but given {}", self.fact.len(), n); if n < r { return 0 }; self.fact[n] * self.inv_fact[r] % self.modulo * self.inv_fact[n-r] % self.modulo } pub fn multi(&self, l: &[usize]) -> i64 { let n = l.iter().sum::<usize>(); assert!(n < self.fact.len(), "index out of range: length is {}, but given {}", self.fact.len(), n); let mut ans = self.fact[n]; for &x in l { ans = ans * self.inv_fact[x] % self.modulo; } ans } } // ------------ struct Fact end ------------ // ------------ io module start ------------ use std::io::{stdout, BufWriter, Read, StdoutLock, Write}; pub struct IO { iter: std::str::SplitAsciiWhitespace<'static>, buf: BufWriter<StdoutLock<'static>>, } impl IO { pub fn new() -> Self { let mut input = String::new(); std::io::stdin().read_to_string(&mut input).unwrap(); let input = Box::leak(input.into_boxed_str()); let out = Box::new(stdout()); IO { iter: input.split_ascii_whitespace(), buf: BufWriter::new(Box::leak(out).lock()), } } fn scan_str(&mut self) -> &'static str { self.iter.next().unwrap() } pub fn scan<T: Scan>(&mut self) -> <T as Scan>::Output { <T as Scan>::scan(self) } pub fn scan_vec<T: Scan>(&mut self, n: usize) -> Vec<<T as Scan>::Output> { (0..n).map(|_| self.scan::<T>()).collect() } pub fn print<T: Print>(&mut self, x: T) { <T as Print>::print(self, x); } pub fn println<T: Print>(&mut self, x: T) { self.print(x); self.print("\n"); } pub fn iterln<T: Print, I: Iterator<Item = T>>(&mut self, mut iter: I, delim: &str) { if let Some(v) = iter.next() { self.print(v); for v in iter { self.print(delim); self.print(v); } } self.print("\n"); } pub fn flush(&mut self) { self.buf.flush().unwrap(); } } impl Default for IO { fn default() -> Self { Self::new() } } pub trait Scan { type Output; fn scan(io: &mut IO) -> Self::Output; } macro_rules! impl_scan { ($($t:tt),*) => { $( impl Scan for $t { type Output = Self; fn scan(s: &mut IO) -> Self::Output { s.scan_str().parse().unwrap() } } )* }; } impl_scan!(i16, i32, i64, isize, u16, u32, u64, usize, String, f32, f64); pub enum Bytes {} impl Scan for Bytes { type Output = &'static [u8]; fn scan(s: &mut IO) -> Self::Output { s.scan_str().as_bytes() } } pub enum Chars {} impl Scan for Chars { type Output = Vec<char>; fn scan(s: &mut IO) -> Self::Output { s.scan_str().chars().collect() } } pub enum Usize1 {} impl Scan for Usize1 { type Output = usize; fn scan(s: &mut IO) -> Self::Output { s.scan::<usize>().wrapping_sub(1) } } impl<T: Scan, U: Scan> Scan for (T, U) { type Output = (T::Output, U::Output); fn scan(s: &mut IO) -> Self::Output { (T::scan(s), U::scan(s)) } } impl<T: Scan, U: Scan, V: Scan> Scan for (T, U, V) { type Output = (T::Output, U::Output, V::Output); fn scan(s: &mut IO) -> Self::Output { (T::scan(s), U::scan(s), V::scan(s)) } } impl<T: Scan, U: Scan, V: Scan, W: Scan> Scan for (T, U, V, W) { type Output = (T::Output, U::Output, V::Output, W::Output); fn scan(s: &mut IO) -> Self::Output { (T::scan(s), U::scan(s), V::scan(s), W::scan(s)) } } pub trait Print { fn print(w: &mut IO, x: Self); } macro_rules! impl_print_int { ($($t:ty),*) => { $( impl Print for $t { fn print(w: &mut IO, x: Self) { w.buf.write_all(x.to_string().as_bytes()).unwrap(); } } )* }; } impl_print_int!(i16, i32, i64, isize, u16, u32, u64, usize, f32, f64); impl Print for u8 { fn print(w: &mut IO, x: Self) { w.buf.write_all(&[x]).unwrap(); } } impl Print for &[u8] { fn print(w: &mut IO, x: Self) { w.buf.write_all(x).unwrap(); } } impl Print for &str { fn print(w: &mut IO, x: Self) { w.print(x.as_bytes()); } } impl Print for String { fn print(w: &mut IO, x: Self) { w.print(x.as_bytes()); } } impl<T: Print, U: Print> Print for (T, U) { fn print(w: &mut IO, (x, y): Self) { w.print(x); w.print(" "); w.print(y); } } impl<T: Print, U: Print, V: Print> Print for (T, U, V) { fn print(w: &mut IO, (x, y, z): Self) { w.print(x); w.print(" "); w.print(y); w.print(" "); w.print(z); } } mod neboccoio_macro { #[macro_export] macro_rules! input { (@start $io:tt @read @rest) => {}; (@start $io:tt @read @rest, $($rest: tt)*) => { input!(@start $io @read @rest $($rest)*) }; (@start $io:tt @read @rest mut $($rest:tt)*) => { input!(@start $io @read @mut [mut] @rest $($rest)*) }; (@start $io:tt @read @rest $($rest:tt)*) => { input!(@start $io @read @mut [] @rest $($rest)*) }; (@start $io:tt @read @mut [$($mut:tt)?] @rest $var:tt: [$kind:tt; $len:expr] $($rest:tt)*) => { let $($mut)* $var = $io.scan_vec::<$kind>($len); input!(@start $io @read @rest $($rest)*) }; (@start $io:tt @read @mut [$($mut:tt)?] @rest $var:tt: $kind:tt $($rest:tt)*) => { let $($mut)* $var = $io.scan::<$kind>(); input!(@start $io @read @rest $($rest)*) }; (from $io:tt $($rest:tt)*) => { input!(@start $io @read @rest $($rest)*) }; } } // ------------ io module end ------------