結果
| 問題 |
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> {}
}