結果
問題 | No.1299 Random Array Score |
ユーザー |
|
提出日時 | 2020-11-28 20:12:39 |
言語 | Rust (1.83.0 + proconio) |
結果 |
AC
|
実行時間 | 8 ms / 2,000 ms |
コード長 | 12,127 bytes |
コンパイル時間 | 13,017 ms |
コンパイル使用メモリ | 406,728 KB |
実行使用メモリ | 6,944 KB |
最終ジャッジ日時 | 2024-09-12 23:37:04 |
合計ジャッジ時間 | 14,886 ms |
ジャッジサーバーID (参考情報) |
judge4 / judge5 |
(要ログイン)
ファイルパターン | 結果 |
---|---|
sample | AC * 3 |
other | AC * 34 |
ソースコード
fn main() {type Fp = F998244353;let mut io = IO::new();let (n, k) = io.scan();let a: Vec<Fp> = io.scan_vec(n);io.println::<Fp>(a.into_iter().sum::<Fp>() * Fp::new(2).pow(k));}// ------------ traits start ------------impl<T: Mod> Scan for Fp<T> {fn scan(s: &mut IO) -> Self {Self::new(i64::scan(s))}}impl<T: Mod> Print for Fp<T> {fn print(w: &mut IO, x: Self) {w.print(x.into_inner());}}// ------------ traits end ------------// ------------ libraries start ------------// ------------ libraries end ------------// ------------ traits start ------------use std::{fmt::{Debug, Display},hash::Hash,iter,marker::PhantomData,ops,};crate::define_fp!(pub F998244353, Mod998244353, 998244353);crate::define_fp!(pub F1000000007, Mod1000000007, 1000000007);#[derive(Clone, PartialEq, Copy, Eq, Hash)]pub struct Fp<T>(i64, PhantomData<T>);pub trait Mod: Debug + Clone + PartialEq + Copy + Eq + Hash {const MOD: i64;}impl<T: Mod> Fp<T> {pub fn new(mut x: i64) -> Self {x %= T::MOD;Self::unchecked(if x < 0 { x + T::MOD } else { x })}pub fn into_inner(self) -> i64 {self.0}pub fn r#mod() -> i64 {T::MOD}pub fn inv(self) -> Self {assert_ne!(self.0, 0, "Zero division");let (sign, x) = if self.0 * 2 < T::MOD {(1, self.0)} else {(-1, T::MOD - self.0)};let (g, _a, b) = ext_gcd(T::MOD, x);let ans = sign * b;assert_eq!(g, 1);Self::unchecked(if ans < 0 { ans + T::MOD } else { ans })}pub fn frac(x: i64, y: i64) -> Self {Fp::new(x) / Fp::new(y)}pub fn pow(mut self, mut p: u64) -> Self {let mut ans = Fp::new(1);while p != 0 {if p & 1 == 1 {ans *= self;}self *= self;p >>= 1;}ans}fn unchecked(x: i64) -> Self {Self(x, PhantomData)}}impl<T: Mod> iter::Sum<Fp<T>> for Fp<T> {fn sum<I>(iter: I) -> SelfwhereI: iter::Iterator<Item = Fp<T>>,{iter.fold(Fp::new(0), ops::Add::add)}}impl<'a, T: 'a + Mod> iter::Sum<&'a Fp<T>> for Fp<T> {fn sum<I>(iter: I) -> SelfwhereI: iter::Iterator<Item = &'a Fp<T>>,{iter.fold(Fp::new(0), ops::Add::add)}}impl<T: Mod> iter::Product<Fp<T>> for Fp<T> {fn product<I>(iter: I) -> SelfwhereI: iter::Iterator<Item = Fp<T>>,{iter.fold(Self::new(1), ops::Mul::mul)}}impl<'a, T: 'a + Mod> iter::Product<&'a Fp<T>> for Fp<T> {fn product<I>(iter: I) -> SelfwhereI: iter::Iterator<Item = &'a Fp<T>>,{iter.fold(Self::new(1), ops::Mul::mul)}}impl<T: Mod> Debug for Fp<T> {fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {write!(f, "{}", self.0)}}impl<T: Mod> Display for Fp<T> {fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {write!(f, "{}", self.0)}}// ax + by = gcd(x, y) なる、互いに素な (a, b) を一組探して、(g, a, b) を返します。//// | 0 -x | | y -x | | x 0 |// | 1 b | = | a b | | y 1 |fn ext_gcd(x: i64, y: i64) -> (i64, i64, i64) {let (b, g) = {let mut x = x;let mut y = y;let mut u = 0;let mut v = 1;while x != 0 {let q = y / x;y -= q * x;v -= q * u;std::mem::swap(&mut x, &mut y);std::mem::swap(&mut u, &mut v);}(v, y)};assert_eq!((g - b * y) % x, 0);let a = (g - b * y) / x;(g, a, b)}#[macro_export]macro_rules! define_fp {($vis:vis $fp:ident, $t:ident, $mod:expr) => {#[derive(Debug, Clone, PartialEq, Copy, Eq, Hash)]$vis struct $t;// NOTE: `$crate::` があるとうまく展開できません。impl Mod for $t {const MOD: i64 = $mod;}// NOTE: `$crate::` があるとうまく展開できません。$vis type $fp = Fp<$t>;}}use std::ops::*;impl<T: Mod> Associative for Fp<T> {}impl<T: Mod> Zero for Fp<T> {fn zero() -> Self { Self::unchecked(0) }fn is_zero(&self) -> bool { self.0 == 0 }}impl<T: Mod> One for Fp<T> {fn one() -> Self { Self::unchecked(1) }fn is_one(&self) -> bool { self.0 == 1 }}impl<T: Mod> Add for Fp<T> {type Output = Self;fn add(self, rhs: Self) -> Self {let res = self.0 + rhs.0;Self::unchecked(if T::MOD <= res { res - T::MOD } else { res })}}impl<T: Mod> Sub for Fp<T> {type Output = Self;fn sub(self, rhs: Self) -> Self {let res = self.0 - rhs.0;Self::unchecked(if res < 0 { res + T::MOD } else { res })}}impl<T: Mod> Mul for Fp<T> {type Output = Self;fn mul(self, rhs: Self) -> Self {Self::new(self.0 * rhs.0)}}#[allow(clippy::suspicious_arithmetic_impl)]impl<T: Mod> Div for Fp<T> {type Output = Self;fn div(self, rhs: Self) -> Self {self * rhs.inv()}}impl<M: Mod> Neg for Fp<M> {type Output = Self;fn neg(self) -> Self {if self.0 == 0 {Self::unchecked(0)} else {Self::unchecked(M::MOD - self.0)}}}impl<M: Mod> Neg for &Fp<M> {type Output = Fp<M>;fn neg(self) -> Self::Output {if self.0 == 0 {Fp::unchecked(0)} else {Fp::unchecked(M::MOD - self.0)}}}macro_rules! forward_assign_biop {($(impl $trait:ident, $fn_assign:ident, $fn:ident)*) => {$(impl<M: Mod> $trait for Fp<M> {fn $fn_assign(&mut self, rhs: Self) {*self = self.$fn(rhs);}})*};}forward_assign_biop! {impl AddAssign, add_assign, addimpl SubAssign, sub_assign, subimpl MulAssign, mul_assign, mulimpl DivAssign, div_assign, div}macro_rules! forward_ref_binop {($(impl $imp:ident, $method:ident)*) => {$(impl<'a, T: Mod> $imp<Fp<T>> for &'a Fp<T> {type Output = Fp<T>;fn $method(self, other: Fp<T>) -> Self::Output {$imp::$method(*self, other)}}impl<'a, T: Mod> $imp<&'a Fp<T>> for Fp<T> {type Output = Fp<T>;fn $method(self, other: &Fp<T>) -> Self::Output {$imp::$method(self, *other)}}impl<'a, T: Mod> $imp<&'a Fp<T>> for &'a Fp<T> {type Output = Fp<T>;fn $method(self, other: &Fp<T>) -> Self::Output {$imp::$method(*self, *other)}})*};}forward_ref_binop! {impl Add, addimpl Sub, subimpl Mul, mulimpl Div, div}use std::marker::Sized;/// 元pub trait Element: Sized + Clone + PartialEq {}impl<T: Sized + Clone + PartialEq> Element for T {}/// 結合性pub trait Associative: Magma {}/// マグマpub trait Magma: Element + Add<Output=Self> {}impl<T: Element + Add<Output=Self>> Magma for T {}/// 半群pub trait SemiGroup: Magma + Associative {}impl<T: Magma + Associative> SemiGroup for T {}/// モノイドpub trait Monoid: SemiGroup + Zero {}impl<T: SemiGroup + Zero> Monoid for T {}pub trait ComMonoid: Monoid + AddAssign {}impl<T: Monoid + AddAssign> ComMonoid for T {}/// 群pub trait Group: Monoid + Neg<Output=Self> {}impl<T: Monoid + Neg<Output=Self>> Group for T {}pub trait ComGroup: Group + ComMonoid {}impl<T: Group + ComMonoid> ComGroup for T {}/// 半環pub trait SemiRing: ComMonoid + Mul<Output=Self> + One {}impl<T: ComMonoid + Mul<Output=Self> + One> SemiRing for T {}/// 環pub trait Ring: ComGroup + SemiRing {}impl<T: ComGroup + SemiRing> Ring for T {}pub trait ComRing: Ring + MulAssign {}impl<T: Ring + MulAssign> ComRing for T {}/// 体pub trait Field: ComRing + Div<Output=Self> + DivAssign {}impl<T: ComRing + Div<Output=Self> + DivAssign> Field for T {}/// 加法単元pub trait Zero: Element {fn zero() -> Self;fn is_zero(&self) -> bool;}/// 乗法単元pub trait One: Element {fn one() -> Self;fn is_one(&self) -> bool;}macro_rules! impl_integer {($($T:ty,)*) => {$(impl Associative for $T {}impl Zero for $T {fn zero() -> Self { 0 }fn is_zero(&self) -> bool { *self == 0 }}impl<'a> Zero for &'a $T {fn zero() -> Self { &0 }fn is_zero(&self) -> bool { *self == &0 }}impl One for $T {fn one() -> Self { 1 }fn is_one(&self) -> bool { *self == 1 }}impl<'a> One for &'a $T {fn one() -> Self { &1 }fn is_one(&self) -> bool { *self == &1 }})*};}impl_integer! {i8, i16, i32, i64, i128, isize,u8, u16, u32, u64, u128, usize,}// ------------ traits 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()}fn scan_raw(&mut self) -> &'static [u8] {self.scan_str().as_bytes()}pub fn scan<T: Scan>(&mut self) -> T {T::scan(self)}pub fn scan_vec<T: Scan>(&mut self, n: usize) -> Vec<T> {(0..n).map(|_| self.scan()).collect()}}impl IO {pub fn print<T: Print>(&mut self, x: T) {T::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();}}pub trait Scan {fn scan(io: &mut IO) -> Self;}macro_rules! impl_parse_int {($($t:tt),*) => {$(impl Scan for $t {fn scan(s: &mut IO) -> Self {let mut res = 0;for d in s.scan_raw() {res *= 10;res += (*d - b'0') as $t;}res}})*};}impl_parse_int!(i32, i64, isize, u32, u64, usize);impl<T: Scan, U: Scan> Scan for (T, U) {fn scan(s: &mut IO) -> Self {(T::scan(s), U::scan(s))}}impl<T: Scan, U: Scan, V: Scan> Scan for (T, U, V) {fn scan(s: &mut IO) -> Self {(T::scan(s), U::scan(s), V::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!(i32, i64, isize, u32, u64, usize);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<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);}}// ------------ io module end ------------