結果
問題 |
No.3295 Buying Bottled Water
|
ユーザー |
|
提出日時 | 2025-08-21 00:56:24 |
言語 | Rust (1.83.0 + proconio) |
結果 |
AC
|
実行時間 | 1 ms / 2,000 ms |
コード長 | 14,197 bytes |
コンパイル時間 | 11,489 ms |
コンパイル使用メモリ | 397,620 KB |
実行使用メモリ | 7,720 KB |
最終ジャッジ日時 | 2025-08-21 00:56:38 |
合計ジャッジ時間 | 12,724 ms |
ジャッジサーバーID (参考情報) |
judge4 / judge2 |
(要ログイン)
ファイルパターン | 結果 |
---|---|
sample | AC * 3 |
other | AC * 19 |
ソースコード
#![allow(unused)] #![allow(unstable_name_collisions)] extern crate proconio; use std::{ cmp::{Ordering, Reverse}, collections::{BinaryHeap, HashMap, HashSet, VecDeque, BTreeSet, BTreeMap}, iter::Copied, marker::PhantomData, mem::swap, ops::{Add, Shr}, fmt::{Display, Debug}, }; use ::{ proconio::{input, marker::{Chars, Usize1}, source::Readable}, // ac_library::{ModInt998244353 as Mint, Dsu, SccGraph}, // amplify::{map, set}, // counter::Counter, // recur_fn::{RecurFn, recur_fn}, // regex::Regex, // itertools::{Itertools, iproduct}, // superslice::Ext as _, // nalgebra::{self as na, DMatrix}, // btreemultimap::{BTreeMultiMap, btreemultimap}, // memoise::{memoise, memoise_map}, }; fn main() -> Result<(), Box<dyn std::error::Error>> { input! { n: u64, } ((n.saturating_sub(99) + 499) / 500).println(); Ok(()) } #[macro_export] macro_rules! println_exit { ($($arg:tt)*) => { { println!($($arg)*); std::process::exit(0) } }; } #[macro_export] macro_rules! all_eq { ($val:expr, $($vals:expr),*) => { $($val == $vals &&)* true }; } #[macro_export] macro_rules! multi_vec { [$val:expr; $len:expr] => { vec![$val; $len] }; [$val:expr; $len:expr, $($lens:expr),*] => { vec![multi_vec![$val; $($lens),*]; $len] }; } #[macro_export] macro_rules! vec_deque { ($elem:expr; $len:expr) => { vec![$elem; $len].into_iter().collect::<VecDeque<_>>() }; ($($elem:expr),* $(,)?) => { [$($elem),*].into_iter().collect::<VecDeque<_>>() } } #[macro_export] macro_rules! cmp { ($_:tt) => { true }; ($_0:tt, $_1:tt) => { true }; ($l1:tt, $l2:tt $op:tt $r:tt $($others:tt)*) => { $l1 $op $r && $l2 $op $r && cmp!($r $($others)*) }; ($l:tt $op:tt $r1:tt, $r2:tt $($others:tt)*) => { $l $op $r1 && $l $op $r2 && cmp!($r1, $r2 $($others)*) }; ($l:tt $op:tt $r:tt $($others:tt)*) => { $l $op $r && cmp!($r $($others)*) }; } trait OrdAsign where Self: Ord + Sized { fn chmax(&mut self, other: Self) -> bool { if other > *self { *self = other; true } else { false } } fn chmin(&mut self, other: Self) -> bool { if other < *self { *self = other; true } else { false } } } impl<T: Ord + Sized> OrdAsign for T {} trait PartialOrdAsign where Self: PartialOrd + Sized { fn pchmax(&mut self, other: Self) -> bool { if other > *self { *self = other; true } else { false } } fn pchmin(&mut self, other: Self) -> bool { if other < *self { *self = other; true } else { false } } } impl<T: PartialOrd + Sized> PartialOrdAsign for T {} trait OrdInsert<T: Ord + Sized> { fn insert_max(&mut self, x: T) -> bool; fn insert_min(&mut self, x: T) -> bool; } impl<T: Ord + Sized> OrdInsert<T> for Option<T> { fn insert_max(&mut self, x: T) -> bool { if let Some(s) = self { s.chmax(x) } else { self.insert(x); true } } fn insert_min(&mut self, x: T) -> bool { if let Some(s) = self { s.chmin(x) } else { self.insert(x); true } } } // struct LenVec<T: Readable> { t: PhantomData<T> } // impl<T: Readable> Readable for LenVec<T> { // type Output = Vec<T::Output>; // fn read<R: std::io::BufRead, S: proconio::source::Source<R>>(source: &mut S) -> Self::Output { // input! { // from source, // len: usize, // vec: [T; len], // } // vec // } // } trait YesNo { fn yesno(&self) -> &'static str; fn print_yesno(&self); } impl YesNo for bool { fn yesno(&self) -> &'static str { if *self { "Yes" } else { "No" } } fn print_yesno(&self) { println!("{}", self.yesno()); } } trait RevSort { fn rev_sort(&mut self); } impl<T: Ord> RevSort for [T] { fn rev_sort(&mut self) { self.sort_by(|l, r| r.cmp(l)); } } trait Sorted<T: Ord>: Sized + AsMut<[T]> { fn sorted(mut self) -> Self { self.as_mut().sort(); self } fn sorted_by(mut self, cmp: impl FnMut(&T, &T) -> Ordering) -> Self { self.as_mut().sort_by(cmp); self } fn sorted_by_key<K: Ord>(mut self, cmp: impl FnMut(&T) -> K) -> Self { self.as_mut().sort_by_key(cmp); self } fn rev_sorted(mut self) -> Self { self.as_mut().rev_sort(); self } } impl<T: Ord, V: AsMut<[T]>> Sorted<T> for V {} trait Flip { fn flip(&mut self); } impl Flip for bool { fn flip(&mut self) { *self = !*self; } } use bit::*; mod bit { use std::ops::{BitAnd, Shr, ShrAssign}; pub trait Bit: Sized + BitAnd<Output = Self> + Eq + Copy + Shr<u8, Output = Self> + ShrAssign<u8> { fn zero() -> Self; fn one() -> Self; fn bit<P>(self, pos: P) -> bool where Self: Shr<P, Output = Self> { (self >> pos) & Self::one() == Self::one() } fn bits(self) -> Bits<Self> { Bits::new(self) } } #[derive(Debug, Clone)] pub struct Bits<T: Bit> { n: T } impl<T: Bit> Bits<T> { fn new(n: T) -> Self { Self {n} } } impl<T: Bit> Iterator for Bits<T> { type Item = bool; fn next(&mut self) -> Option<Self::Item> { if self.n == T::zero() { return None } let ret = self.n & T::one() == T::one(); self.n >>= 1; Some(ret) } } macro_rules! impl_trait { ($($type:ty)*) => { $(impl Bit for $type { fn zero() -> Self { 0 } fn one() -> Self { 1 } })* }; } impl_trait!(u8 u16 u32 u64 u128 usize); } trait Print: Display { fn print(&self) { print!("{self}"); } fn println(&self) { println!("{self}"); } fn eprint(&self) { eprint!("{self}"); } fn eprintln(&self) { eprintln!("{self}"); } } impl<T: Display> Print for T {} trait DebugPrint: Debug { fn dprint(&self) { eprint!("{self:?}"); } fn dprintln(&self) { eprintln!("{self:?}"); } } impl<T: Debug> DebugPrint for T {} use slice_ext::*; mod slice_ext { use std::{iter::FusedIterator, ptr::slice_from_raw_parts, slice}; pub trait SliceExt<T> { fn array_windows<const N: usize>(&self) -> ArrayWindows<'_, T, N>; fn array_chunks<const N: usize>(&self) -> ArrayChunks<'_, T, N>; fn array_chunks_mut<const N: usize>(&mut self) -> ArrayChunksMut<'_, T, N>; } impl<T> SliceExt<T> for [T] { #[inline] fn array_windows<const N: usize>(&self) -> ArrayWindows<'_, T, N> { ArrayWindows::new(self) } #[inline] fn array_chunks<const N: usize>(&self) -> ArrayChunks<'_, T, N> { ArrayChunks::new(self) } #[inline] fn array_chunks_mut<const N: usize>(&mut self) -> ArrayChunksMut<'_, T, N> { ArrayChunksMut::new(self) } } struct IsNonZero<const N: usize>; impl<const N: usize> IsNonZero<N> { const OK: () = assert!(N > 0, "window size must be non-zero"); } #[derive(Debug, Clone)] pub struct ArrayWindows<'a, T, const N: usize> { slice: &'a [T], } impl<'a, T, const N: usize> ArrayWindows<'a, T, N> { fn new(slice: &'a [T]) -> Self { let _ = IsNonZero::<N>::OK; Self { slice } } } impl<'a, T, const N: usize> Iterator for ArrayWindows<'a, T, N> { type Item = &'a [T; N]; fn next(&mut self) -> Option<Self::Item> { if self.slice.len() < N { None } else { let ret = self.slice[..N].try_into().unwrap(); self.slice = &self.slice[1..]; Some(ret) } } fn count(self) -> usize where Self: Sized { self.len() } fn size_hint(&self) -> (usize, Option<usize>) { let len = self.len(); (len, Some(len)) } fn nth(&mut self, n: usize) -> Option<Self::Item> { if self.len() < n + 1 { self.slice = &[]; None } else { self.slice = &self.slice[n..]; self.next() } } } impl<'a, T, const N: usize> ExactSizeIterator for ArrayWindows<'a, T, N> { fn len(&self) -> usize { self.slice.len().saturating_sub(N - 1) } } impl<'a, T, const N: usize> DoubleEndedIterator for ArrayWindows<'a, T, N> { fn next_back(&mut self) -> Option<Self::Item> { if self.slice.len() < N { None } else { let ret = self.slice[self.slice.len() - N..].try_into().unwrap(); self.slice = &self.slice[..self.slice.len() - 1]; Some(ret) } } fn nth_back(&mut self, n: usize) -> Option<Self::Item> { if self.len() < n + 1 { self.slice = &[]; None } else { self.slice = &self.slice[..self.slice.len() - n]; self.next_back() } } } impl<'a, T, const N: usize> FusedIterator for ArrayWindows<'a, T, N> {} #[derive(Debug, Clone)] pub struct ArrayChunks<'a, T, const N: usize> { slice: &'a [T], rem: &'a [T], } impl<'a, T, const N: usize> ArrayChunks<'a, T, N> { fn new(slice: &'a [T]) -> Self { let _ = IsNonZero::<N>::OK; let slice_size = slice.len() / N * N; let (slice, rem) = slice.split_at(slice_size); Self { slice, rem } } fn remainder(&self) -> &'a [T] { self.rem } } impl<'a, T, const N: usize> Iterator for ArrayChunks<'a, T, N> { type Item = &'a [T; N]; fn next(&mut self) -> Option<Self::Item> { if self.slice.len() < N { None } else { let ret = self.slice[..N].try_into().unwrap(); self.slice = &self.slice[N..]; Some(ret) } } fn count(self) -> usize where Self: Sized { self.len() } fn nth(&mut self, n: usize) -> Option<Self::Item> { if self.len() < n + 1 { self.slice = &[]; None } else { self.slice = &self.slice[N * n..]; self.next() } } fn size_hint(&self) -> (usize, Option<usize>) { let len = self.len(); (len, Some(len)) } } impl<'a, T, const N: usize> ExactSizeIterator for ArrayChunks<'a, T, N> { fn len(&self) -> usize { self.slice.len() / N } } impl<'a, T, const N: usize> DoubleEndedIterator for ArrayChunks<'a, T, N> { fn next_back(&mut self) -> Option<Self::Item> { if self.slice.len() < N { None } else { let (head, ret) = self.slice.split_at(self.slice.len() - N); self.slice = head; Some(ret.try_into().unwrap()) } } fn nth_back(&mut self, n: usize) -> Option<Self::Item> { if self.len() < n + 1 { self.slice = &[]; None } else { self.slice = &self.slice[..self.slice.len() - N * n]; self.next_back() } } } impl<'a, T, const N: usize> FusedIterator for ArrayChunks<'a, T, N> {} #[derive(Debug)] pub struct ArrayChunksMut<'a, T, const N: usize> { slice: &'a mut [T], rem: &'a mut[T], } impl<'a, T, const N: usize> ArrayChunksMut<'a, T, N> { fn new(slice: &'a mut [T]) -> Self { let _ = IsNonZero::<N>::OK; let slice_size = slice.len() / N * N; let (slice, rem) = slice.split_at_mut(slice_size); Self { slice, rem } } fn into_remainder(self) -> &'a mut[T] { self.rem } } impl<'a, T, const N: usize> Iterator for ArrayChunksMut<'a, T, N> { type Item = &'a mut[T; N]; fn next(&mut self) -> Option<Self::Item> { if self.slice.len() < N { None } else { let slice = std::mem::take(&mut self.slice); let (ret, tail) = slice.split_at_mut(N); self.slice = tail; let ret = ret.try_into().unwrap(); Some(ret) } } fn count(self) -> usize where Self: Sized { self.len() } fn nth(&mut self, n: usize) -> Option<Self::Item> { if self.len() < n + 1 { self.slice = &mut []; None } else { let slice = std::mem::take(&mut self.slice); self.slice = slice.split_at_mut(N * n).1; self.next() } } fn size_hint(&self) -> (usize, Option<usize>) { let len = self.len(); (len, Some(len)) } } impl<'a, T, const N: usize> ExactSizeIterator for ArrayChunksMut<'a, T, N> { fn len(&self) -> usize { self.slice.len() / N } } impl<'a, T, const N: usize> DoubleEndedIterator for ArrayChunksMut<'a, T, N> { fn next_back(&mut self) -> Option<Self::Item> { if self.slice.len() < N { None } else { let slice = std::mem::take(&mut self.slice); let (head, ret) = slice.split_at_mut(slice.len() - N); self.slice = head; let ret = ret.try_into().unwrap(); Some(ret) } } fn nth_back(&mut self, n: usize) -> Option<Self::Item> { if self.len() < n + 1 { self.slice = &mut []; None } else { let slice = std::mem::take(&mut self.slice); let len = slice.len(); self.slice = &mut slice[..len - N * n]; self.next_back() } } } impl<'a, T, const N: usize> FusedIterator for ArrayChunksMut<'a, T, N> {} }