結果

問題 No.1299 Random Array Score
ユーザー nebocco
提出日時 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
権限があれば一括ダウンロードができます

ソースコード

diff #
プレゼンテーションモードにする

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) -> Self
where
I: 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) -> Self
where
I: 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) -> Self
where
I: 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) -> Self
where
I: 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, add
impl SubAssign, sub_assign, sub
impl MulAssign, mul_assign, mul
impl 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, add
impl Sub, sub
impl Mul, mul
impl 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 ------------
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0