結果
問題 | No.318 学学学学学 |
ユーザー |
|
提出日時 | 2021-05-26 19:41:31 |
言語 | Rust (1.83.0 + proconio) |
結果 |
AC
|
実行時間 | 52 ms / 2,000 ms |
コード長 | 10,315 bytes |
コンパイル時間 | 13,595 ms |
コンパイル使用メモリ | 378,604 KB |
実行使用メモリ | 14,088 KB |
最終ジャッジ日時 | 2024-10-15 14:52:13 |
合計ジャッジ時間 | 17,842 ms |
ジャッジサーバーID (参考情報) |
judge4 / judge2 |
(要ログイン)
ファイルパターン | 結果 |
---|---|
sample | AC * 3 |
other | AC * 26 |
ソースコード
fn main() {let mut io = IO::new();input!{ from io,n: usize,a: [i64; n],}let mut d = std::collections::HashMap::new();let mut b = vec![Vec::new(); n+1];for i in 0..n {if !d.contains_key(&a[i]) {b[i].push(a[i]);}d.insert(a[i], i);}for (&x, &i) in d.iter() {b[i+1].push(-x);}let mut hp = DoublePriorityHeap::new();let mut ans = vec![0; n];for i in 0..n {for &x in &b[i] {hp.push(x);}while *hp.get_min().unwrap() == -*hp.get_max().unwrap() {hp.pop_min();hp.pop_max();}ans[i] = *hp.get_max().unwrap();}io.iterln(ans.into_iter(), " ");}// ------------ DoublePriorityHeap start ------------#[derive(Default)]pub struct DoublePriorityHeap<T: Element + Ord>(Vec<T>);impl<T: Element + Ord> DoublePriorityHeap<T> {pub fn new() -> Self {Self(Vec::new())}pub fn from(vec: &[T]) -> Self {let mut l = Self(vec.to_vec());l.build();l}pub fn push(&mut self, x: T) {self.0.push(x);self.up(self.0.len() - 1, 1);}pub fn pop_min(&mut self) -> Option<T> {if self.0.len() < 3 {self.0.pop()} else {let ret = self.0.swap_remove(1);let k = self.down(1);self.up(k, 1);Some(ret)}}pub fn pop_max(&mut self) -> Option<T> {if self.0.len() < 2 {self.0.pop()} else {let ret = self.0.swap_remove(0);let k = self.down(0);self.up(k, 1);Some(ret)}}pub fn get_min(&self) -> Option<&T> {if self.0.len() < 2 {self.0.get(0)} else {self.0.get(1)}}pub fn get_max(&self) -> Option<&T> {self.0.get(0)}fn build(&mut self) {let n = self.0.len();for i in (0..n).rev() {if i & 1 == 1 && self.0[i-1] < self.0[i] {self.0.swap(i-1, i);}let k = self.down(i);self.up(k, i);}}#[inline]fn parent(k: usize) -> usize {(k >> 1).wrapping_sub(1) & !1}fn down(&mut self, mut k: usize) -> usize {let n = self.0.len();let mut c: usize;if k & 1 == 1 { // min heapwhile 2 * k + 1 < n {c = 2 * k + 3;if n <= c || self.0[c-2] < self.0[c] {c -= 2;}if c < n && self.0[c] < self.0[k] {self.0.swap(k, c);k = c;} else {break}}} else { // max heapwhile 2 * k + 2 < n {c = 2 * k + 4;if n <= c || self.0[c] < self.0[c-2] {c -= 2;}if c < n && self.0[k] < self.0[c] {self.0.swap(k, c);k = c;} else {break}}}k}fn up(&mut self, mut k: usize, root: usize) {if (k | 1) < self.0.len() && self.0[k & !1] < self.0[k | 1] {self.0.swap(k & !1, k | 1);k ^= 1;}let mut p = Self::parent(k);// max heapwhile root < k && self.0[p] < self.0[k] {self.0.swap(k, p);k = p;p = Self::parent(k)}// min heapp |= 1;while root < k && self.0[k] < self.0[p] {self.0.swap(k, p);k = p;p = Self::parent(k) | 1;}}}// ------------ DoublePriorityHeap end ------------// ------------ algebraic traits start ------------use std::marker::Sized;use std::ops::*;/// 元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 {*self == Self::zero()}}/// 乗法単元pub trait One: Element {fn one() -> Self;fn is_one(&self) -> bool {*self == Self::one()}}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,}// ------------ algebraic 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()}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);impl Scan for char {type Output = char;fn scan(s: &mut IO) -> Self::Output {s.scan_str().chars().next().unwrap()}}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; $len1:expr]; $len2:expr] $($rest:tt)*) => {let $($mut)* $var = (0..$len2).map(|_| $io.scan_vec::<$kind>($len1)).collect::<Vec<Vec<$kind>>>();input!(@start $io @read @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 ------------