Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- {"lang": "Rust", "source_code": "use std::{\n io::{self, BufRead},\n str::FromStr,\n};\n\nstruct LineBuf(String);\n\nimpl LineBuf {\n fn new() -> Self {\n Self(String::new())\n }\n\n #[allow(dead_code)]\n fn get(&self) -> &String {\n &self.0\n }\n\n fn offer(&mut self) -> &mut String {\n self.0.clear();\n &mut self.0\n }\n\n fn parse_item<T>(s: &str) -> JoyResult<T>\n where\n T: FromStr,\n {\n s.parse().or_else(|_| Err(JoyError::ParseError))\n }\n\n #[allow(dead_code)]\n fn parse<T>(&self) -> JoyResult<T>\n where\n T: FromStr,\n {\n Self::parse_item(self.0.trim())\n }\n\n #[allow(dead_code)]\n fn parse2<T1, T2>(&self) -> JoyResult<(T1, T2)>\n where\n T1: FromStr,\n T2: FromStr,\n {\n let mut it = self.0.split_whitespace();\n let a = Self::parse_item(it.next().ok_or(JoyError::LineItemExhausted)?)?;\n let b = Self::parse_item(it.next().ok_or(JoyError::LineItemExhausted)?)?;\n Ok((a, b))\n }\n\n #[allow(dead_code)]\n fn parse_vec<T>(&self) -> JoyResult<Vec<T>>\n where\n T: FromStr,\n {\n self.0\n .split_whitespace()\n .map(|s| s.parse().or(Err(JoyError::ParseError)))\n .collect()\n }\n}\n\n#[derive(Debug)]\nenum JoyError {\n IOError(io::Error),\n LineItemExhausted,\n ParseError,\n}\n\ntype JoyResult<T> = Result<T, JoyError>;\n\nimpl std::convert::From<io::Error> for JoyError {\n fn from(err: io::Error) -> Self {\n Self::IOError(err)\n }\n}\n\nfn main() -> JoyResult<()> {\n let mut buf = LineBuf::new();\n let stdin = io::stdin();\n let mut stdin = stdin.lock();\n\n stdin.read_line(buf.offer())?;\n let t: usize = buf.parse()?;\n\n for _ in 0..t {\n stdin.read_line(buf.offer())?;\n let (h, n): (i32, usize) = buf.parse2()?;\n\n stdin.read_line(buf.offer())?;\n\n let mut q: Vec<i32> = buf.parse_vec()?;\n q.push(0);\n\n assert_eq!(q.len(), n + 1);\n assert_eq!(q[0], h);\n\n // println!(\"{:?}\", q);\n\n let mut i = 0;\n let mut c = 0;\n while i < n - 1 {\n let now = q[i + 1] + 1;\n if q[i + 2] == now - 2 {\n i += 2;\n } else {\n // println!(\"q[i] = {}\", q[i]);\n c += 1;\n i += 1;\n }\n }\n\n println!(\"{}\", c);\n }\n\n Ok(())\n}\n", "lang_cluster": "Rust", "compilation_error": true, "code_uid": "91c173e6f252216b1c96d13ead8ba5a5", "src_uid": "d0c50562764f2008045fe57e5da5de1c", "difficulty": 1600}
- {"lang": "Rust", "source_code": "use std::{\n io::{self, BufRead},\n str::FromStr,\n};\n\nstruct LineBuf(String);\n\nimpl LineBuf {\n fn new() -> Self {\n Self(String::new())\n }\n\n #[allow(dead_code)]\n fn get(&self) -> &String {\n &self.0\n }\n\n fn offer(&mut self) -> &mut String {\n self.0.clear();\n &mut self.0\n }\n\n fn parse_item<T>(s: &str) -> JoyResult<T>\n where\n T: FromStr,\n {\n s.parse().or_else(|_| Err(JoyError::ParseError))\n }\n\n #[allow(dead_code)]\n fn parse<T>(&self) -> JoyResult<T>\n where\n T: FromStr,\n {\n Self::parse_item(self.0.trim())\n }\n\n #[allow(dead_code)]\n fn parse2<T1, T2>(&self) -> JoyResult<(T1, T2)>\n where\n T1: FromStr,\n T2: FromStr,\n {\n let mut it = self.0.split_whitespace();\n let a = Self::parse_item(it.next().ok_or(JoyError::LineItemExhausted)?)?;\n let b = Self::parse_item(it.next().ok_or(JoyError::LineItemExhausted)?)?;\n Ok((a, b))\n }\n\n #[allow(dead_code)]\n fn parse_vec<T>(&self) -> JoyResult<Vec<T>>\n where\n T: FromStr,\n {\n self.0\n .split_whitespace()\n .map(|s| s.parse().or(Err(JoyError::ParseError)))\n .collect()\n }\n}\n\n#[derive(Debug)]\nenum JoyError {\n IOError(io::Error),\n LineItemExhausted,\n ParseError,\n}\n\ntype JoyResult<T> = Result<T, JoyError>;\n\nimpl std::convert::From<io::Error> for JoyError {\n fn from(err: io::Error) -> Self {\n JoyError::IOError(err)\n }\n}\n\nfn main() -> JoyResult<()> {\n let mut buf = LineBuf::new();\n let stdin = io::stdin();\n let mut stdin = stdin.lock();\n\n stdin.read_line(buf.offer())?;\n let t: usize = buf.parse()?;\n\n for _ in 0..t {\n stdin.read_line(buf.offer())?;\n let (h, n): (i32, usize) = buf.parse2()?;\n\n stdin.read_line(buf.offer())?;\n\n let mut q: Vec<i32> = buf.parse_vec()?;\n q.push(0);\n\n assert_eq!(q.len(), n + 1);\n assert_eq!(q[0], h);\n\n // println!(\"{:?}\", q);\n\n let mut i = 0;\n let mut c = 0;\n while i < n - 1 {\n let now = q[i + 1] + 1;\n if q[i + 2] == now - 2 {\n i += 2;\n } else {\n // println!(\"q[i] = {}\", q[i]);\n c += 1;\n i += 1;\n }\n }\n\n println!(\"{}\", c);\n }\n\n Ok(())\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "70789e739b58d8e093081e204f804983", "src_uid": "d0c50562764f2008045fe57e5da5de1c", "difficulty": 1600}
- {"lang": "Rust", "source_code": "pub trait Readable {\n type Output;\n fn words_count() -> usize;\n fn read_words(words: &[&str]) -> Result<Self::Output, String>;\n}\n#[macro_export]\nmacro_rules! readable {\n ( $ t : ty , $ words_count : expr , |$ words : ident | $ read_words : expr ) => {\n impl Readable for $t {\n type Output = $t;\n fn words_count() -> usize {\n $words_count\n }\n fn read_words($words: &[&str]) -> Result<$t, String> {\n Ok($read_words)\n }\n }\n };\n}\nreadable!((), 1, |_ss| ());\nreadable!(String, 1, |ss| ss[0].to_string());\nimpl Readable for char {\n type Output = char;\n fn words_count() -> usize {\n 1\n }\n fn read_words(words: &[&str]) -> Result<char, String> {\n let chars: Vec<char> = words[0].chars().collect();\n if chars.len() == 1 {\n Ok(chars[0])\n } else {\n Err(format!(\"cannot parse `{}` as a char\", words[0]))\n }\n }\n}\npub struct Chars();\nimpl Readable for Chars {\n type Output = Vec<char>;\n fn words_count() -> usize {\n 1\n }\n fn read_words(words: &[&str]) -> Result<Vec<char>, String> {\n Ok(words[0].chars().collect())\n }\n}\nmacro_rules ! impl_readable_for_ints { ( $ ( $ t : ty ) * ) => { $ ( impl Readable for $ t { type Output = Self ; fn words_count ( ) -> usize { 1 } fn read_words ( words : & [ & str ] ) -> Result <$ t , String > { use std :: str :: FromStr ; <$ t >:: from_str ( words [ 0 ] ) . map_err ( | _ | { format ! ( \"cannot parse `{}` as {}\" , words [ 0 ] , stringify ! ( $ t ) ) } ) } } ) * } ; }\nimpl_readable_for_ints ! ( i8 u8 i16 u16 i32 u32 i64 u64 isize usize f32 f64 ) ;\nmacro_rules ! define_one_origin_int_types { ( $ new_t : ident $ int_t : ty ) => { # [ doc = \" Converts 1-origin integer into 0-origin when read from stdin.\" ] # [ doc = \"\" ] # [ doc = \" # Example\" ] # [ doc = \"\" ] # [ doc = \" ```no_run\" ] # [ doc = \" # #[macro_use] extern crate atcoder_snippets;\" ] # [ doc = \" # use atcoder_snippets::read::*;\" ] # [ doc = \" // Stdin: \\\"1\\\"\" ] # [ doc = \" read!(a = usize_);\" ] # [ doc = \" assert_eq!(a, 0);\" ] # [ doc = \" ```\" ] # [ allow ( non_camel_case_types ) ] pub struct $ new_t ; impl Readable for $ new_t { type Output = $ int_t ; fn words_count ( ) -> usize { 1 } fn read_words ( words : & [ & str ] ) -> Result < Self :: Output , String > { <$ int_t >:: read_words ( words ) . map ( | n | n - 1 ) } } } ; ( $ new_t : ident $ int_t : ty ; $ ( $ inner_new_t : ident $ inner_int_t : ty ) ;* ) => { define_one_origin_int_types ! ( $ new_t $ int_t ) ; define_one_origin_int_types ! ( $ ( $ inner_new_t $ inner_int_t ) ;* ) ; } ; }\ndefine_one_origin_int_types ! ( u8_ u8 ; u16_ u16 ; u32_ u32 ; u64_ u64 ; usize_ usize ) ;\nmacro_rules ! impl_readable_for_tuples { ( $ t : ident $ var : ident ) => ( ) ; ( $ t : ident $ var : ident ; $ ( $ inner_t : ident $ inner_var : ident ) ;* ) => { impl_readable_for_tuples ! ( $ ( $ inner_t $ inner_var ) ;* ) ; impl <$ t : Readable , $ ( $ inner_t : Readable ) ,*> Readable for ( $ t , $ ( $ inner_t ) ,* ) { type Output = ( <$ t >:: Output , $ ( <$ inner_t >:: Output ) ,* ) ; fn words_count ( ) -> usize { let mut n = <$ t >:: words_count ( ) ; $ ( n += <$ inner_t >:: words_count ( ) ; ) * n } # [ allow ( unused_assignments ) ] fn read_words ( words : & [ & str ] ) -> Result < Self :: Output , String > { let mut start = 0 ; let $ var = <$ t >:: read_words ( & words [ start .. start +<$ t >:: words_count ( ) ] ) ?; start += <$ t >:: words_count ( ) ; $ ( let $ inner_var = <$ inner_t >:: read_words ( & words [ start .. start +<$ inner_t >:: words_count ( ) ] ) ?; start += <$ inner_t >:: words_count ( ) ; ) * Ok ( ( $ var , $ ( $ inner_var ) ,* ) ) } } } ; }\nimpl_readable_for_tuples ! ( T8 x8 ; T7 x7 ; T6 x6 ; T5 x5 ; T4 x4 ; T3 x3 ; T2 x2 ; T1 x1 ) ;\npub trait ReadableFromLine {\n type Output;\n fn read_line(line: &str) -> Result<Self::Output, String>;\n}\nfn split_into_words(line: &str) -> Vec<&str> {\n #[allow(deprecated)]\n line.trim_right_matches('\\n').split_whitespace().collect()\n}\nimpl<T: Readable> ReadableFromLine for T {\n type Output = T::Output;\n fn read_line(line: &str) -> Result<T::Output, String> {\n let words = split_into_words(line);\n if words.len() != T::words_count() {\n return Err(format!(\n \"line `{}` has {} words, expected {}\",\n line,\n words.len(),\n T::words_count()\n ));\n }\n T::read_words(&words)\n }\n}\nmacro_rules ! impl_readable_from_line_for_tuples_with_from_iterator { ( $ u : ident : $ ( + $ bound : path ) * => $ seq_in : ty , $ seq_out : ty ; $ t : ident $ var : ident ) => { impl <$ u : Readable > ReadableFromLine for $ seq_in where <$ u as Readable >:: Output : Sized $ ( + $ bound ) * { type Output = $ seq_out ; fn read_line ( line : & str ) -> Result <$ seq_out , String > { let n = $ u :: words_count ( ) ; let words = split_into_words ( line ) ; if words . len ( ) % n != 0 { return Err ( format ! ( \"line `{}` has {} words, expected multiple of {}\" , line , words . len ( ) , n ) ) ; } let mut result = Vec :: new ( ) ; for chunk in words . chunks ( n ) { match $ u :: read_words ( chunk ) { Ok ( v ) => result . push ( v ) , Err ( msg ) => { let flagment_msg = if n == 1 { format ! ( \"word {}\" , result . len ( ) ) } else { let l = result . len ( ) ; format ! ( \"words {}-{}\" , n * l + 1 , ( n + 1 ) * l ) } ; return Err ( format ! ( \"{} of line `{}`: {}\" , flagment_msg , line , msg ) ) ; } } } Ok ( result . into_iter ( ) . collect ( ) ) } } impl < T : Readable , $ u : Readable > ReadableFromLine for ( T , $ seq_in ) where <$ u as Readable >:: Output : Sized $ ( + $ bound ) * { type Output = ( T :: Output , $ seq_out ) ; fn read_line ( line : & str ) -> Result < Self :: Output , String > { let n = T :: words_count ( ) ; # [ allow ( deprecated ) ] let trimmed = line . trim_right_matches ( '\\n' ) ; let words_and_rest : Vec <& str > = trimmed . splitn ( n + 1 , ' ' ) . collect ( ) ; if words_and_rest . len ( ) < n { return Err ( format ! ( \"line `{}` has {} words, expected at least {}\" , line , words_and_rest . len ( ) , n ) ) ; } let words = & words_and_rest [ .. n ] ; let empty_str = \"\" ; let rest = words_and_rest . get ( n ) . unwrap_or ( & empty_str ) ; Ok ( ( T :: read_words ( words ) ?, <$ seq_in >:: read_line ( rest ) ? ) ) } } } ; ( $ u : ident : $ ( + $ bound : path ) * => $ seq_in : ty , $ seq_out : ty ; $ t : ident $ var : ident , $ ( $ inner_t : ident $ inner_var : ident ) ,+ ) => { impl_readable_from_line_for_tuples_with_from_iterator ! ( $ u : $ ( + $ bound ) * => $ seq_in , $ seq_out ; $ ( $ inner_t $ inner_var ) ,+ ) ; impl <$ t : Readable , $ ( $ inner_t : Readable ) ,+ , $ u : Readable > ReadableFromLine for ( $ t , $ ( $ inner_t ) ,+ , $ seq_in ) where <$ u as Readable >:: Output : Sized $ ( + $ bound ) * { type Output = ( $ t :: Output , $ ( $ inner_t :: Output ) ,+ , $ seq_out ) ; fn read_line ( line : & str ) -> Result < Self :: Output , String > { let mut n = $ t :: words_count ( ) ; $ ( n += $ inner_t :: words_count ( ) ; ) + # [ allow ( deprecated ) ] let trimmed = line . trim_right_matches ( '\\n' ) ; let words_and_rest : Vec <& str > = trimmed . splitn ( n + 1 , ' ' ) . collect ( ) ; if words_and_rest . len ( ) < n { return Err ( format ! ( \"line `{}` has {} words, expected at least {}\" , line , words_and_rest . len ( ) , n ) ) ; } let words = & words_and_rest [ .. n ] ; let empty_str = \"\" ; let rest = words_and_rest . get ( n ) . unwrap_or ( & empty_str ) ; let ( $ var , $ ( $ inner_var ) ,* ) = < ( $ t , $ ( $ inner_t ) ,+ ) >:: read_words ( words ) ?; Ok ( ( $ var , $ ( $ inner_var ) ,* , <$ seq_in >:: read_line ( rest ) ? ) ) } } } ; }\n#[macro_export]\nmacro_rules ! readable_collection { ( $ u : ident => $ collection_in : ty , $ collection_out : ty ) => { impl_readable_from_line_for_tuples_with_from_iterator ! ( $ u : => $ collection_in , $ collection_out ; T8 x8 , T7 x7 , T6 x6 , T5 x5 , T4 x4 , T3 x3 , T2 x2 , T1 x1 ) ; } ; ( $ u : ident : $ ( $ bound : path ) ,* => $ collection_in : ty , $ collection_out : ty ) => { impl_readable_from_line_for_tuples_with_from_iterator ! ( $ u : $ ( + $ bound ) * => $ collection_in , $ collection_out ; T8 x8 , T7 x7 , T6 x6 , T5 x5 , T4 x4 , T3 x3 , T2 x2 , T1 x1 ) ; } }\nreadable_collection ! ( U => Vec < U >, Vec < U :: Output > ) ;\nreadable_collection ! ( U => std :: collections :: VecDeque < U >, std :: collections :: VecDeque < U :: Output > ) ;\nreadable_collection ! ( U : Eq , std :: hash :: Hash => std :: collections :: HashSet < U >, std :: collections :: HashSet < U :: Output > ) ;\nreadable_collection ! ( U : Ord => std :: collections :: BTreeSet < U >, std :: collections :: BTreeSet < U :: Output > ) ;\nreadable_collection ! ( U : Ord => std :: collections :: BinaryHeap < U >, std :: collections :: BinaryHeap < U :: Output > ) ;\npub fn read<T: ReadableFromLine>() -> T::Output {\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n T::read_line(&line).unwrap()\n}\n#[macro_export]\nmacro_rules ! read { ( ) => { let mut line = String :: new ( ) ; std :: io :: stdin ( ) . read_line ( & mut line ) . unwrap ( ) ; } ; ( $ pat : pat = $ t : ty ) => { let $ pat = read ::<$ t > ( ) ; } ; ( $ ( $ pat : pat = $ t : ty ) ,+ ) => { read ! ( ( $ ( $ pat ) ,* ) = ( $ ( $ t ) ,* ) ) ; } ; }\n#[macro_export]\nmacro_rules ! readls { ( $ ( $ pat : pat = $ t : ty ) ,+ ) => { $ ( read ! ( $ pat = $ t ) ; ) * } ; }\npub fn readx<T: ReadableFromLine>() -> Vec<T::Output> {\n use std::io::{self, BufRead};\n let stdin = io::stdin();\n let result = stdin\n .lock()\n .lines()\n .map(|line_result| {\n let line = line_result.expect(\"read from stdin failed\");\n T::read_line(&line).unwrap()\n })\n .collect();\n result\n}\n#[macro_export]\nmacro_rules ! readx_loop { ( |$ pat : pat = $ t : ty | $ body : expr ) => { { use std :: io :: BufRead ; let stdin = std :: io :: stdin ( ) ; for line in stdin . lock ( ) . lines ( ) { let line = line . expect ( \"read from stdin failed\" ) ; let $ pat = <$ t >:: read_line ( & line ) . unwrap ( ) ; $ body } } } ; ( |$ ( $ pat : pat = $ t : ty ) ,*| $ body : expr ) => { readx_loop ! ( | ( $ ( $ pat ) ,* ) = ( $ ( $ t ) ,* ) | $ body ) ; } ; }\npub fn readn<T: ReadableFromLine>(n: usize) -> Vec<T::Output> {\n use std::io::{self, BufRead};\n let stdin = io::stdin();\n let result: Vec<T::Output> = stdin\n .lock()\n .lines()\n .take(n)\n .map(|line_result| {\n let line = line_result.expect(\"read from stdin failed\");\n T::read_line(&line).unwrap()\n })\n .collect();\n if result.len() < n {\n panic!(\n \"expected reading {} lines, but only {} lines are read\",\n n,\n result.len()\n );\n }\n result\n}\n#[macro_export]\nmacro_rules ! readn_loop { ( $ n : expr , |$ pat : pat = $ t : ty | $ body : expr ) => { { use std :: io :: BufRead ; let stdin = std :: io :: stdin ( ) ; let mut lock = stdin . lock ( ) ; for _ in 0 ..$ n { let mut line = String :: new ( ) ; lock . read_line ( & mut line ) . expect ( \"read from stdin failed\" ) ; let $ pat = <$ t >:: read_line ( & line ) . unwrap ( ) ; $ body } } } ; ( $ n : expr , |$ ( $ pat : pat = $ t : ty ) ,*| $ body : expr ) => { readn_loop ! ( $ n , | ( $ ( $ pat ) ,* ) = ( $ ( $ t ) ,* ) | $ body ) ; } ; }\npub trait Words {\n fn read<T: Readable>(&self) -> T::Output;\n}\nimpl<'a> Words for [&'a str] {\n fn read<T: Readable>(&self) -> T::Output {\n T::read_words(self).unwrap()\n }\n}\nimpl<'a> Words for &'a str {\n fn read<T: Readable>(&self) -> T::Output {\n T::read_words(&[self]).unwrap()\n }\n}\n\npub struct SliceGroupBy<'a, T: 'a, K: Eq, F: Fn(&T) -> K> {\n key_fn: F,\n rest: &'a [T],\n}\nimpl<'a, T, K: Eq, F: Fn(&T) -> K> Iterator for SliceGroupBy<'a, T, K, F> {\n type Item = (K, &'a [T]);\n fn next(&mut self) -> Option<(K, &'a [T])> {\n if self.rest.is_empty() {\n return None;\n }\n let key = (self.key_fn)(&self.rest[0]);\n let mut end = 1;\n while end < self.rest.len() && (self.key_fn)(&self.rest[end]) == key {\n end += 1;\n }\n let (left, right) = self.rest.split_at(end);\n self.rest = right;\n Some((key, left))\n }\n}\npub struct SplitByGap<'a, T: 'a, F: Fn(&T, &T) -> bool> {\n gap_fn: F,\n rest: &'a [T],\n}\nimpl<'a, T, F: Fn(&T, &T) -> bool> Iterator for SplitByGap<'a, T, F> {\n type Item = &'a [T];\n fn next(&mut self) -> Option<&'a [T]> {\n if self.rest.is_empty() {\n return None;\n }\n let mut r = 1;\n while r < self.rest.len() && !(self.gap_fn)(&self.rest[r - 1], &self.rest[r]) {\n r += 1;\n }\n let (result, rest) = self.rest.split_at(r);\n self.rest = rest;\n Some(result)\n }\n}\npub struct Permutations<'a, T: 'a> {\n items: &'a [T],\n indices: Option<Vec<usize>>,\n is_first: bool,\n}\nimpl<'a, T: 'a> Iterator for Permutations<'a, T> {\n type Item = Vec<&'a T>;\n fn next(&mut self) -> Option<Vec<&'a T>> {\n if !self.is_first {\n let indices_opt = self.indices.take();\n if let Some(indices) = indices_opt {\n self.indices = next_permutation(indices);\n }\n } else {\n self.is_first = false;\n }\n self.indices\n .as_ref()\n .map(|indices| indices.into_iter().map(|&i| &self.items[i]).collect())\n }\n}\nfn next_permutation(mut indices: Vec<usize>) -> Option<Vec<usize>> {\n (0..indices.len().saturating_sub(1))\n .rev()\n .find(|&left| indices[left] < indices[left + 1])\n .map(|left| {\n let right = (0..indices.len())\n .rev()\n .find(|&right| indices[left] < indices[right])\n .unwrap();\n indices.swap(left, right);\n indices[left + 1..].reverse();\n indices\n })\n}\nfn count_inversions_sub<T: Clone + Ord>(seq: &[T]) -> (Vec<T>, usize) {\n if seq.len() <= 1 {\n (seq.to_vec(), 0)\n } else {\n let mid = seq.len() / 2;\n let (sub1, inv1) = count_inversions_sub(&seq[..mid]);\n let (sub2, inv2) = count_inversions_sub(&seq[mid..]);\n let mut sorted = Vec::new();\n let (mut i1, mut i2) = (0, 0);\n let mut inv = 0;\n loop {\n match (sub1.get(i1), sub2.get(i2)) {\n (Some(x1), Some(x2)) => {\n if x1 <= x2 {\n sorted.push(x1.clone());\n i1 += 1;\n } else {\n inv += sub1.len() - i1;\n sorted.push(x2.clone());\n i2 += 1;\n }\n }\n (Some(_), None) => {\n sorted.extend(sub1[i1..].iter().cloned());\n break;\n }\n (None, Some(_)) => {\n sorted.extend(sub2[i2..].iter().cloned());\n break;\n }\n (None, None) => break,\n }\n }\n (sorted, inv + inv1 + inv2)\n }\n}\npub trait SliceExt<T> {\n fn group_by<K: Eq, F: Fn(&T) -> K>(&self, key_fn: F) -> SliceGroupBy<T, K, F>;\n fn split_by_gap<F: Fn(&T, &T) -> bool>(&self, gap_fn: F) -> SplitByGap<T, F>;\n fn permutations(&self) -> Permutations<T>;\n fn count_inversions(&self) -> usize\n where\n T: Clone + Ord;\n}\nimpl<T> SliceExt<T> for [T] {\n fn group_by<K: Eq, F: Fn(&T) -> K>(&self, key_fn: F) -> SliceGroupBy<T, K, F> {\n SliceGroupBy {\n key_fn: key_fn,\n rest: self,\n }\n }\n fn split_by_gap<F: Fn(&T, &T) -> bool>(&self, gap_fn: F) -> SplitByGap<T, F> {\n SplitByGap {\n gap_fn: gap_fn,\n rest: self,\n }\n }\n fn permutations(&self) -> Permutations<T> {\n let indices = if self.is_empty() {\n None\n } else {\n Some((0..self.len()).collect())\n };\n Permutations {\n items: self,\n indices: indices,\n is_first: true,\n }\n }\n fn count_inversions(&self) -> usize\n where\n T: Clone + Ord,\n {\n count_inversions_sub(self).1\n }\n}\npub trait SliceOfVecsExt<T> {\n fn transpose_clone(&self) -> Option<Vec<Vec<T>>>\n where\n T: Clone;\n}\nimpl<T> SliceOfVecsExt<T> for [Vec<T>] {\n fn transpose_clone(&self) -> Option<Vec<Vec<T>>>\n where\n T: Clone,\n {\n if self.iter().any(|row| row.is_empty()) {\n return None;\n }\n if self.windows(2).any(|rows| rows[0].len() < rows[1].len()) {\n return None;\n }\n let mut result = Vec::new();\n let n = self.get(0).map_or(0, |first| first.len());\n for i in 0..n {\n let mut result_row = Vec::new();\n for j in 0..self.len() {\n if self[j].len() <= i {\n break;\n }\n result_row.push(self[j][i].clone());\n }\n result.push(result_row);\n }\n Some(result)\n }\n}\n\nfn main() {\n read!(query_count = usize);\n for _ in 0..query_count {\n read!();\n read!(mut ps = Vec<u32>);\n ps.reverse();\n ps.pop();\n let ans = ps.split_by_gap(|&a, &b| b - a > 1)\n .filter(|s| s[0] != 1 && s.len() % 2 == 1)\n .count();\n println!(\"{}\", ans);\n }\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "5f6895157f8c0c699e27ff089d147113", "src_uid": "d0c50562764f2008045fe57e5da5de1c", "difficulty": 1600}
- {"lang": "Rust", "source_code": "// ---------- begin scannner ----------\n#[allow(dead_code)]\nmod scanner {\n use std::str::FromStr;\n use std::str::SplitWhitespace;\n use std::io::Read;\n use std;\n pub struct Scanner<'a> {\n it: SplitWhitespace<'a>\n }\n impl<'a> Scanner<'a> {\n pub fn new(s: &'a String) -> Scanner<'a> {\n Scanner {\n it: s.split_whitespace()\n }\n }\n pub fn next<T: FromStr>(&mut self) -> T {\n match self.it.next().unwrap().parse::<T>() {\n Ok(v) => v,\n _ => panic!(\"Scanner error\")\n }\n }\n pub fn next_chars(&mut self) -> Vec<char> {\n self.next::<String>().chars().collect()\n }\n }\n pub fn read_string() -> String {\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n }\n}\n// ---------- end scannner ----------\n\nuse std::io::Write;\n\nfn main() {\n let sc = scanner::read_string();\n let mut sc = scanner::Scanner::new(&sc);\n let out = std::io::stdout();\n let mut out = std::io::BufWriter::new(out.lock());\n run(&mut sc, &mut out);\n}\n\nfn run(sc: &mut scanner::Scanner, out: &mut std::io::BufWriter<std::io::StdoutLock>) {\n let q: usize = sc.next();\n for _ in 0..q {\n let _h: u32 = sc.next();\n let n: usize = sc.next();\n let mut p: Vec<u32> = (0..n).map(|_| sc.next()).collect();\n p.push(0);\n p.push(0);\n let mut ans = 0;\n let mut i = 0;\n while i < n {\n p[i] = p[i + 1] + 1;\n if i + 2 < p.len() && p[i + 2] + 1 >= p[i + 1] {\n i += 2;\n } else {\n i += 1;\n ans += 1;\n }\n }\n writeln!(out, \"{}\", ans).ok();\n }\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "355e27b87e816fa74f612387d7eb121f", "src_uid": "d0c50562764f2008045fe57e5da5de1c", "difficulty": 1600}
- {"lang": "Rust", "source_code": "#[doc = \" https://github.com/hatoo/competitive-rust-snippets\"]\n#[allow(unused_imports)]\nuse std::cmp::{max, min, Ordering};\n#[allow(unused_imports)]\nuse std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};\n#[allow(unused_imports)]\nuse std::io::{stdin, stdout, BufWriter, Write};\n#[allow(unused_imports)]\nuse std::iter::FromIterator;\n#[macro_export]\nmacro_rules ! dvec { ( $ t : expr ; $ len : expr ) => { vec ! [ $ t ; $ len ] } ; ( $ t : expr ; $ len : expr , $ ( $ rest : expr ) ,* ) => { vec ! [ dvec ! ( $ t ; $ ( $ rest ) ,* ) ; $ len ] } ; }\n#[allow(unused_macros)]\nmacro_rules ! debug { ( $ ( $ a : expr ) ,* ) => { eprintln ! ( concat ! ( $ ( stringify ! ( $ a ) , \" = {:?}, \" ) ,* ) , $ ( $ a ) ,* ) ; } }\n#[macro_export]\nmacro_rules ! input { ( source = $ s : expr , $ ( $ r : tt ) * ) => { let mut parser = Parser :: from_str ( $ s ) ; input_inner ! { parser , $ ( $ r ) * } } ; ( parser = $ parser : ident , $ ( $ r : tt ) * ) => { input_inner ! { $ parser , $ ( $ r ) * } } ; ( new_stdin_parser = $ parser : ident , $ ( $ r : tt ) * ) => { let stdin = std :: io :: stdin ( ) ; let reader = std :: io :: BufReader :: new ( stdin . lock ( ) ) ; let mut $ parser = Parser :: new ( reader ) ; input_inner ! { $ parser , $ ( $ r ) * } } ; ( $ ( $ r : tt ) * ) => { input ! { new_stdin_parser = parser , $ ( $ r ) * } } ; }\n#[macro_export]\nmacro_rules ! input_inner { ( $ parser : ident ) => { } ; ( $ parser : ident , ) => { } ; ( $ parser : ident , $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let $ var = read_value ! ( $ parser , $ t ) ; input_inner ! { $ parser $ ( $ r ) * } } ; }\n#[macro_export]\nmacro_rules ! read_value { ( $ parser : ident , ( $ ( $ t : tt ) ,* ) ) => { ( $ ( read_value ! ( $ parser , $ t ) ) ,* ) } ; ( $ parser : ident , [ $ t : tt ; $ len : expr ] ) => { ( 0 ..$ len ) . map ( | _ | read_value ! ( $ parser , $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ parser : ident , chars ) => { read_value ! ( $ parser , String ) . chars ( ) . collect ::< Vec < char >> ( ) } ; ( $ parser : ident , usize1 ) => { read_value ! ( $ parser , usize ) - 1 } ; ( $ parser : ident , $ t : ty ) => { $ parser . next ::<$ t > ( ) . expect ( \"Parse error\" ) } ; }\nuse std::io;\nuse std::io::BufRead;\nuse std::str;\npub struct Parser<R> {\n reader: R,\n buf: Vec<u8>,\n pos: usize,\n}\nimpl Parser<io::Empty> {\n pub fn from_str(s: &str) -> Parser<io::Empty> {\n Parser {\n reader: io::empty(),\n buf: s.as_bytes().to_vec(),\n pos: 0,\n }\n }\n}\nimpl<R: BufRead> Parser<R> {\n pub fn new(reader: R) -> Parser<R> {\n Parser {\n reader: reader,\n buf: vec![],\n pos: 0,\n }\n }\n pub fn update_buf(&mut self) {\n self.buf.clear();\n self.pos = 0;\n loop {\n let (len, complete) = {\n let buf2 = self.reader.fill_buf().unwrap();\n self.buf.extend_from_slice(buf2);\n let len = buf2.len();\n if len == 0 {\n break;\n }\n (len, buf2[len - 1] <= 0x20)\n };\n self.reader.consume(len);\n if complete {\n break;\n }\n }\n }\n pub fn next<T: str::FromStr>(&mut self) -> Result<T, T::Err> {\n loop {\n let mut begin = self.pos;\n while begin < self.buf.len() && (self.buf[begin] <= 0x20) {\n begin += 1;\n }\n let mut end = begin;\n while end < self.buf.len() && (self.buf[end] > 0x20) {\n end += 1;\n }\n if begin != self.buf.len() {\n self.pos = end;\n return str::from_utf8(&self.buf[begin..end]).unwrap().parse::<T>();\n } else {\n self.update_buf();\n }\n }\n }\n}\n#[allow(unused_macros)]\nmacro_rules ! debug { ( $ ( $ a : expr ) ,* ) => { eprintln ! ( concat ! ( $ ( stringify ! ( $ a ) , \" = {:?}, \" ) ,* ) , $ ( $ a ) ,* ) ; } }\n#[doc = \" https://github.com/hatoo/competitive-rust-snippets\"]\nconst BIG_STACK_SIZE: bool = true;\n#[allow(dead_code)]\nfn main() {\n use std::thread;\n if BIG_STACK_SIZE {\n thread::Builder::new()\n .stack_size(32 * 1024 * 1024)\n .name(\"solve\".into())\n .spawn(solve)\n .unwrap()\n .join()\n .unwrap();\n } else {\n solve();\n }\n}\nfn solve() {\n let out = stdout();\n let mut out = BufWriter::new(out.lock());\n input!{\n new_stdin_parser = parser,\n q: usize\n }\n for _ in 0..q {\n input!{\n parser = parser,\n h: usize, n: usize,\n x: [usize; n],\n }\n let mut sl = skiplist::Skiplist::new();\n for xi in x {\n sl.insert(xi);\n }\n let mut n_magic = 0;\n let mut cur = h;\n while cur > 2 {\n let mut it = sl.le_iter(&(cur-1));\n if let Some(next1) = it.next() {\n if cur-next1==1 { // fall\n if let Some(next2) = it.next() {\n if cur-next2 > 2 {\n n_magic += 1;\n let magic = cur-2;\n sl.remove(&cur);\n sl.remove(&next1);\n sl.insert(magic);\n cur = magic;\n }\n else {\n sl.remove(&cur);\n sl.remove(&next1);\n cur = next2;\n }\n }\n else {\n n_magic += 1;\n let magic = cur-2;\n sl.remove(&cur);\n sl.remove(&next1);\n sl.insert(magic);\n cur = magic;\n }\n } \n else {\n sl.remove(&cur);\n sl.insert(cur-1);\n cur = cur-1;\n }\n }\n else {\n sl.remove(&cur);\n sl.insert(cur-1);\n cur = cur-1;\n }\n }\n println!(\"{}\", n_magic);\n }\n}\nmod skiplist {\n use std;\n use std::cell::{Cell, RefCell};\n use std::collections::{BTreeMap, BTreeSet};\n use std::fmt;\n use std::rc::Rc;\n struct RandGen {\n x: u64,\n }\n impl RandGen {\n fn new(seed: u64) -> RandGen {\n RandGen { x: seed }\n }\n fn next(&mut self) -> u64 {\n const a: u64 = 1103515245;\n const b: u64 = 12345;\n const m: u64 = 1 << 32;\n self.x = (a * self.x + b) % m;\n self.x\n }\n }\n pub struct Skiplist<T> {\n max_height: Option<usize>,\n left_sentinel: Rc<RefCell<SkipNode<T>>>,\n right_sentinel: Rc<RefCell<SkipNode<T>>>,\n rand_gen: RandGen,\n traverse_stat: Cell<usize>,\n connect_stat: Cell<usize>,\n }\n impl Skiplist<usize> {\n fn print_graph(&self) {\n for level in (0..self.height()).rev() {\n let mut line = vec![];\n let mut cur = self.left_sentinel.clone();\n loop {\n let next0 = cur.borrow().next[level].clone();\n let next = next0.unwrap().clone();\n if next.borrow().value.is_none() {\n break;\n } else {\n cur = next.clone();\n let v = cur.borrow().value.clone().unwrap();\n line.push(v);\n }\n }\n let mut ss = vec![];\n for x in line {\n while ss.len() < x {\n ss.push(\"--\".to_string());\n }\n ss.push(format!(\"{:>02}\", x));\n }\n println!(\"{}\", ss.connect(\",\"));\n }\n println!(\"\");\n }\n }\n impl<T> Skiplist<T>\n where\n T: std::cmp::Ord + fmt::Debug + Clone,\n {\n pub fn new() -> Skiplist<T> {\n let left_sentinel = Rc::new(RefCell::new(SkipNode::sentinel()));\n let right_sentinel = Rc::new(RefCell::new(SkipNode::sentinel()));\n let sentinel_height = left_sentinel.borrow().height();\n for level in 0..sentinel_height {\n left_sentinel.borrow_mut().next[level] = Some(right_sentinel.clone());\n right_sentinel.borrow_mut().prev[level] = Some(left_sentinel.clone());\n }\n Skiplist {\n max_height: None,\n left_sentinel: left_sentinel,\n right_sentinel: right_sentinel,\n rand_gen: RandGen::new(0),\n traverse_stat: Cell::new(0),\n connect_stat: Cell::new(0),\n }\n }\n fn height(&self) -> usize {\n self.max_height.unwrap_or(33)\n }\n fn pick_height(&mut self) -> usize {\n let z = self.rand_gen.next();\n let mut k = 0;\n let mut m = 1;\n while z & m != 0 {\n k += 1;\n m <<= 1;\n }\n k + 1\n }\n pub fn insert(&mut self, x: T) -> bool {\n let mut paths = self.traverse(&x);\n if !paths.is_empty() {\n let next0 = paths[0].borrow().next[0].clone();\n let next = next0.unwrap();\n let found = next.borrow().value.as_ref() == Some(&x);\n if found {\n return false;\n }\n }\n let new_height = self.pick_height();\n self.max_height = Some(std::cmp::max(self.max_height.unwrap_or(0), new_height));\n while paths.len() < new_height {\n paths.push(self.left_sentinel.clone());\n }\n let new_node = Rc::new(RefCell::new(SkipNode::new(x, new_height)));\n for level in 0..new_height {\n let prev = &paths[level];\n self.connect_stat.set(self.connect_stat.get() + 1);\n SkipNode::connect(prev, &new_node, level);\n }\n true\n }\n fn find_node(&self, x: &T) -> Option<Rc<RefCell<SkipNode<T>>>> {\n let paths = self.traverse(x);\n if paths.is_empty() {\n return None;\n }\n let next0 = paths[0].borrow().next[0].clone();\n let next = next0.unwrap();\n if next.borrow().value.as_ref() == Some(x) {\n Some(next)\n } else {\n None\n }\n }\n pub fn find(&self, x: &T) -> bool {\n self.find_node(x).is_some()\n }\n pub fn reset_stat(&self) {\n self.traverse_stat.set(0);\n self.connect_stat.set(0);\n }\n pub fn show_stat(&self) {\n println!(\"traverse: {}\", self.traverse_stat.get());\n println!(\"connect: {}\", self.connect_stat.get());\n }\n fn traverse(&self, x: &T) -> Vec<Rc<RefCell<SkipNode<T>>>> {\n if self.height() == 0 {\n return vec![];\n }\n let mut cur = self.left_sentinel.clone();\n let mut acc = vec![self.left_sentinel.clone(); self.height()];\n let mut level = self.height() - 1;\n loop {\n if level == 0 {\n loop {\n acc[level] = cur.clone();\n let next0 = cur.borrow().next[level].clone();\n let next = next0.unwrap();\n if next.borrow().value.is_none()\n || next.borrow().value.as_ref().unwrap() >= x\n {\n break;\n } else {\n cur = next.clone();\n self.traverse_stat.set(self.traverse_stat.get() + 1);\n }\n }\n break;\n }\n let next0 = cur.borrow().next[level].clone();\n let next = next0.unwrap();\n if next.borrow().value.is_none() || next.borrow().value.as_ref().unwrap() >= x {\n acc[level] = cur.clone();\n level -= 1;\n continue;\n } else {\n cur = next;\n self.traverse_stat.set(self.traverse_stat.get() + 1);\n }\n }\n acc\n }\n fn traverse_rev(&self, x: &T) -> Vec<Rc<RefCell<SkipNode<T>>>> {\n if self.height() == 0 {\n return vec![];\n }\n let mut cur = self.right_sentinel.clone();\n let mut acc = vec![self.right_sentinel.clone(); self.height()];\n let mut level = self.height() - 1;\n loop {\n if level == 0 {\n loop {\n acc[level] = cur.clone();\n let next = cur.borrow().prev[level].clone().unwrap();\n if next.borrow().value.is_none()\n || next.borrow().value.as_ref().unwrap() <= x\n {\n break;\n } else {\n cur = next.clone();\n }\n }\n break;\n }\n let next = cur.borrow().prev[level].clone().unwrap();\n if next.borrow().value.is_none() || next.borrow().value.as_ref().unwrap() <= x {\n acc[level] = cur.clone();\n level -= 1;\n continue;\n } else {\n cur = next;\n }\n }\n acc\n }\n pub fn remove(&mut self, x: &T) -> bool {\n let node = self.find_node(x);\n if node.is_none() {\n return false;\n }\n let node = node.unwrap();\n node.borrow_mut().remove();\n true\n }\n #[doc = \"iterator in range [x,]\"]\n pub fn ge_iter(&self, x: &T) -> Range<T> {\n let f = self.traverse(x)[0].clone();\n Range {\n forward: true,\n f: f,\n b: self.right_sentinel.clone(),\n }\n }\n #[doc = \"iterator in range [,x]\"]\n pub fn le_iter(&self, x: &T) -> Range<T> {\n let b = self.traverse_rev(x)[0].clone();\n Range {\n forward: false,\n f: self.left_sentinel.clone(),\n b: b,\n }\n }\n #[doc = \"iterator in range [..]\"]\n pub fn iter(&self) -> Range<T> {\n Range {\n forward: true,\n f: self.left_sentinel.clone(),\n b: self.right_sentinel.clone(),\n }\n }\n }\n pub struct Range<T> {\n forward: bool,\n f: Rc<RefCell<SkipNode<T>>>,\n b: Rc<RefCell<SkipNode<T>>>,\n }\n impl<T: Clone> Iterator for Range<T> {\n type Item = T;\n fn next(&mut self) -> Option<Self::Item> {\n let next0 = if self.forward {\n self.f.borrow().next[0].clone()\n } else {\n self.b.borrow().prev[0].clone()\n };\n if next0.is_none() {\n return None;\n }\n let next = next0.unwrap();\n if self.forward {\n self.f = next;\n self.f.borrow().value.clone()\n } else {\n self.b = next;\n self.b.borrow().value.clone()\n }\n }\n }\n impl<T: Clone> DoubleEndedIterator for Range<T> {\n fn next_back(&mut self) -> Option<Self::Item> {\n let next0 = if self.forward {\n self.b.borrow().prev[0].clone()\n } else {\n self.f.borrow().next[0].clone()\n };\n if next0.is_none() {\n return None;\n }\n let next = next0.unwrap();\n if self.forward {\n self.b = next;\n self.b.borrow().value.clone()\n } else {\n self.f = next;\n self.f.borrow().value.clone()\n }\n }\n }\n impl<T> fmt::Debug for Skiplist<T>\n where\n T: fmt::Debug + Clone + std::cmp::Ord,\n {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n let v: Vec<T> = self.iter().collect();\n writeln!(f, \"{:?}\", v);\n Ok(())\n }\n }\n struct SkipNode<T> {\n value: Option<T>,\n prev: Vec<Option<Rc<RefCell<SkipNode<T>>>>>,\n next: Vec<Option<Rc<RefCell<SkipNode<T>>>>>,\n }\n impl<T> fmt::Debug for SkipNode<T>\n where\n T: fmt::Debug + std::cmp::Ord,\n {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n writeln!(f, \"{:?}, {:?}\", self.value, self.height());\n Ok(())\n }\n }\n impl<T> SkipNode<T>\n where\n T: std::cmp::Ord + fmt::Debug,\n {\n fn sentinel() -> SkipNode<T> {\n SkipNode {\n value: None,\n prev: vec![None; 33],\n next: vec![None; 33],\n }\n }\n fn new(value: T, height: usize) -> SkipNode<T> {\n SkipNode {\n value: Some(value),\n prev: vec![None; height],\n next: vec![None; height],\n }\n }\n fn height(&self) -> usize {\n self.next.len()\n }\n fn remove(&mut self) {\n for level in 0..self.height() {\n let prev_node = self.prev[level].clone().unwrap();\n let next_node = self.next[level].clone().unwrap();\n next_node.borrow_mut().prev[level] = Some(prev_node.clone());\n prev_node.borrow_mut().next[level] = Some(next_node.clone());\n }\n }\n fn connect(x: &Rc<RefCell<Self>>, y: &Rc<RefCell<Self>>, level: usize) {\n let x_next = x.borrow().next[level].clone().unwrap();\n x.borrow_mut().next[level] = Some(y.clone());\n y.borrow_mut().prev[level] = Some(x.clone());\n y.borrow_mut().next[level] = Some(x_next.clone());\n x_next.borrow_mut().prev[level] = Some(y.clone());\n }\n }\n #[test]\n fn test_iter() {\n let mut sl = Skiplist::new();\n for i in 1..6 {\n sl.insert(i);\n }\n for x in sl.iter() {\n println!(\"{}\", x);\n }\n for x in sl.ge_iter(&2) {\n println!(\"{}\", x);\n }\n for x in sl.le_iter(&2) {\n println!(\"{}\", x);\n }\n }\n #[test]\n fn test_pick_height() {\n let mut sl = Skiplist::<i64>::new();\n let mut cnt = vec![0; 60];\n for _ in 0..1_000 {\n cnt[sl.pick_height()] += 1;\n }\n println!(\"{:?}\", cnt);\n }\n #[test]\n fn test_insert() {\n let mut s = Skiplist::new();\n assert_eq!(s.find(&10), false);\n s.insert(10);\n assert_eq!(s.find(&8), false);\n assert_eq!(s.find(&10), true);\n }\n #[test]\n fn test_debug0() {\n let mut s = Skiplist::new();\n let mut data = vec![920, 265, 659];\n for x in data {\n s.insert(x);\n assert!(s.find(&x));\n }\n s.insert(660);\n dbg!(&s);\n assert!(s.find(&660));\n }\n #[test]\n fn test_debug1() {\n let mut s = Skiplist::new();\n s.insert(0);\n assert!(s.find(&0));\n s.insert(5);\n assert!(s.find(&5));\n }\n #[test]\n fn test_debug2() {\n let mut s = Skiplist::new();\n s.insert(0);\n s.insert(5);\n s.print_graph();\n s.insert(9);\n s.print_graph();\n assert_eq!(s.find(&5), true);\n s.remove(&4);\n assert_eq!(s.find(&5), true);\n s.remove(&5);\n s.print_graph();\n assert_eq!(s.find(&5), false);\n s.remove(&9);\n s.print_graph();\n assert_eq!(s.find(&9), false);\n assert_eq!(s.find(&0), true);\n }\n #[test]\n fn test_compare_reference_insert_and_find() {\n use rand::{Rng, SeedableRng, StdRng};\n let mut rng = StdRng::from_seed(&[3, 2, 1]);\n let mut ts = BTreeSet::new();\n let mut sl = Skiplist::new();\n let size = 10000;\n let mut data1 = vec![];\n for _ in 0..size {\n let x = rng.next_u64() % size;\n data1.push(x as usize);\n }\n let mut data2 = vec![];\n for _ in 0..size {\n let x = rng.next_u64() % size;\n data2.push(x as usize);\n }\n let mut data3 = vec![];\n for _ in 0..size {\n let x = rng.next_u64() % size;\n data3.push(x as usize);\n }\n println!(\"insert and find phase\");\n for x in data1 {\n ts.insert(x);\n sl.insert(x);\n assert_eq!(sl.find(&x), ts.contains(&x));\n }\n sl.print_graph();\n println!(\"find phase\");\n for x in data2 {\n assert_eq!(sl.find(&x), ts.contains(&x));\n }\n println!(\"remove phase\");\n for x in data3 {\n assert_eq!(sl.remove(&x), ts.remove(&x));\n assert_eq!(sl.find(&x), ts.contains(&x));\n }\n }\n #[test]\n fn test_skiplist_stat() {\n use rand::{Rng, SeedableRng, StdRng};\n let size = 1000;\n let mut rng = StdRng::from_seed(&[3, 2, 1]);\n let mut s = Skiplist::new();\n println!(\"insert\");\n for _ in 0..size {\n s.insert(rng.next_u64());\n }\n s.show_stat();\n s.reset_stat();\n println!(\"connect\");\n for _ in 0..size {\n s.find(&rng.next_u64());\n }\n s.show_stat();\n }\n #[bench]\n fn bench_skiplist_insert_random(b: &mut test::Bencher) {\n use rand::{Rng, SeedableRng, StdRng};\n let size = 10000;\n let mut s = Skiplist::new();\n let mut rng = StdRng::from_seed(&[3, 2, 1]);\n b.iter(|| {\n for _ in 0..size {\n s.insert(rng.next_u64());\n }\n });\n }\n #[bench]\n fn bench_skiplist_find_random(b: &mut test::Bencher) {\n use rand::{Rng, SeedableRng, StdRng};\n let size = 10000;\n let mut s = Skiplist::new();\n let mut rng = StdRng::from_seed(&[3, 2, 1]);\n for _ in 0..size {\n s.insert(rng.next_u64());\n }\n b.iter(|| {\n for _ in 0..size {\n s.find(&rng.next_u64());\n }\n });\n }\n #[bench]\n fn bench_skiplist_insert_forward(b: &mut test::Bencher) {\n let mut s = Skiplist::new();\n let size = 10000;\n let mut data = vec![];\n for i in 0..size {\n data.push(i);\n }\n b.iter(|| {\n for &x in &data {\n s.insert(x);\n }\n });\n }\n #[bench]\n fn bench_skiplist_insert_reverse(b: &mut test::Bencher) {\n let mut s = Skiplist::new();\n let size = 10000;\n let mut data = vec![];\n for i in 0..size {\n data.push(i);\n }\n data.reverse();\n b.iter(|| {\n for &x in &data {\n s.insert(x);\n }\n });\n }\n #[bench]\n fn bench_skiplist_connect_simple(b: &mut test::Bencher) {\n let left = Rc::new(RefCell::new(SkipNode::new(0, 2)));\n let right = Rc::new(RefCell::new(SkipNode::new(10000000, 2)));\n for l in 0..2 {\n left.borrow_mut().next[l] = Some(right.clone());\n right.borrow_mut().prev[l] = Some(left.clone());\n }\n let mut data = vec![];\n for i in 0..10000 {\n let n = Rc::new(RefCell::new(SkipNode::new(i + 1, 2)));\n data.push(n)\n }\n b.iter(|| {\n for n in &data {\n for l in 0..2 {\n SkipNode::connect(&left, n, l);\n }\n }\n })\n }\n #[bench]\n fn bench_skiplist_connect_random(b: &mut test::Bencher) {\n use rand::{Rng, SeedableRng, StdRng};\n let mut rng = StdRng::from_seed(&[3, 2, 1]);\n let left = Rc::new(RefCell::new(SkipNode::new(0, 2)));\n let right = Rc::new(RefCell::new(SkipNode::new(10000000, 2)));\n for l in 0..2 {\n left.borrow_mut().next[l] = Some(right.clone());\n right.borrow_mut().prev[l] = Some(left.clone());\n }\n let mut prev_cands = vec![left.clone()];\n let mut data = vec![];\n for i in 0..10000 {\n let n = Rc::new(RefCell::new(SkipNode::new(i + 1, 2)));\n let i = rng.next_u64() as usize % prev_cands.len();\n let prev = prev_cands[i].clone();\n data.push((prev, n.clone()));\n prev_cands.push(n.clone());\n }\n b.iter(|| {\n for (prev, n) in &data {\n for l in 0..2 {\n SkipNode::connect(&prev, &n, l);\n }\n }\n })\n }\n #[bench]\n fn bench_skiplist_alloc_new_node(b: &mut test::Bencher) {\n b.iter(|| {\n for _ in 0..10000 {\n Rc::new(RefCell::new(SkipNode::new(0, 2)));\n }\n })\n }\n #[bench]\n fn bench_skiplist_pick_height(b: &mut test::Bencher) {\n let mut sl = Skiplist::<i64>::new();\n b.iter(|| {\n for _ in 0..10000 {\n sl.pick_height();\n }\n })\n }\n #[bench]\n fn bench_btree_insert_random(b: &mut test::Bencher) {\n use rand::{Rng, SeedableRng, StdRng};\n let size = 10000;\n let mut s = BTreeSet::new();\n let mut rng = StdRng::from_seed(&[3, 2, 1]);\n b.iter(|| {\n for _ in 0..size {\n s.insert(rng.next_u64());\n }\n });\n }\n #[bench]\n fn bench_btree_find_random(b: &mut test::Bencher) {\n use rand::{Rng, SeedableRng, StdRng};\n let size = 10000;\n let mut s = BTreeSet::new();\n let mut rng = StdRng::from_seed(&[3, 2, 1]);\n for _ in 0..size {\n s.insert(rng.next_u64());\n }\n b.iter(|| {\n for _ in 0..size {\n s.contains(&rng.next_u64());\n }\n });\n }\n use std::collections::HashMap;\n pub struct Multiset<T> {\n sl: Skiplist<T>,\n counting: HashMap<T, usize>,\n }\n impl<T> Multiset<T>\n where\n T: Ord + fmt::Debug + Clone + std::hash::Hash,\n {\n pub fn new() -> Multiset<T> {\n Multiset {\n sl: Skiplist::new(),\n counting: HashMap::new(),\n }\n }\n pub fn insert(&mut self, x: T) {\n self.sl.insert(x.clone());\n *self.counting.entry(x).or_insert(0) += 1;\n }\n pub fn counting(&self, x: &T) -> usize {\n self.counting.get(x).cloned().unwrap_or(0)\n }\n pub fn remove(&mut self, x: &T) -> bool {\n let cnt = self.counting(x);\n if cnt == 0 {\n return false;\n }\n if cnt >= 2 {\n *self.counting.get_mut(x).unwrap() -= 1;\n } else if cnt == 1 {\n self.counting.remove(x);\n self.sl.remove(x);\n }\n return true;\n }\n pub fn unwrap(&self) -> &Skiplist<T> {\n &self.sl\n }\n }\n #[test]\n fn test_multiset() {\n let mut s = Multiset::new();\n assert_eq!(s.counting(&1), 0);\n s.insert(1);\n assert_eq!(s.counting(&1), 1);\n s.insert(1);\n assert_eq!(s.counting(&1), 2);\n assert!(s.remove(&1));\n assert_eq!(s.unwrap().ge_iter(&1).next().unwrap(), 1);\n assert_eq!(s.counting(&1), 1);\n assert!(s.remove(&1));\n assert_eq!(s.counting(&1), 0);\n assert_eq!(s.unwrap().ge_iter(&1).next(), None);\n }\n}", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "e05ec0a3265586a6789d2d46f8e0f61e", "src_uid": "d0c50562764f2008045fe57e5da5de1c", "difficulty": 1600}
- {"lang": "Rust", "source_code": "#[doc = \" https://github.com/hatoo/competitive-rust-snippets\"]\n#[allow(unused_imports)]\nuse std::cmp::{max, min, Ordering};\n#[allow(unused_imports)]\nuse std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};\n#[allow(unused_imports)]\nuse std::iter::FromIterator;\n#[macro_export]\nmacro_rules ! chmax { ( $ x : expr , $ ( $ v : expr ) ,+ ) => { $ ( $ x = std :: cmp :: max ( $ x ,$ v ) ; ) + } ; }\n#[macro_export]\nmacro_rules ! chmin { ( $ x : expr , $ ( $ v : expr ) ,+ ) => { $ ( $ x = std :: cmp :: min ( $ x ,$ v ) ; ) + } ; }\n#[macro_export]\nmacro_rules ! max { ( $ x : expr ) => ( $ x ) ; ( $ x : expr , $ ( $ xs : expr ) ,+ ) => { std :: cmp :: max ( $ x , max ! ( $ ( $ xs ) ,+ ) ) } ; }\n#[macro_export]\nmacro_rules ! min { ( $ x : expr ) => ( $ x ) ; ( $ x : expr , $ ( $ xs : expr ) ,+ ) => { std :: cmp :: min ( $ x , min ! ( $ ( $ xs ) ,+ ) ) } ; }\n#[macro_export]\nmacro_rules ! dvec { ( $ t : expr ; $ len : expr ) => { vec ! [ $ t ; $ len ] } ; ( $ t : expr ; $ len : expr , $ ( $ rest : expr ) ,* ) => { vec ! [ dvec ! ( $ t ; $ ( $ rest ) ,* ) ; $ len ] } ; }\n#[doc = \" main\"]\n#[allow(unused_imports)]\nuse std::io::{stdin, stdout, BufWriter, Write};\n#[macro_export]\nmacro_rules ! input { ( source = $ s : expr , $ ( $ r : tt ) * ) => { let mut parser = Parser :: from_str ( $ s ) ; input_inner ! { parser , $ ( $ r ) * } } ; ( parser = $ parser : ident , $ ( $ r : tt ) * ) => { input_inner ! { $ parser , $ ( $ r ) * } } ; ( new_stdin_parser = $ parser : ident , $ ( $ r : tt ) * ) => { let stdin = std :: io :: stdin ( ) ; let reader = std :: io :: BufReader :: new ( stdin . lock ( ) ) ; let mut $ parser = Parser :: new ( reader ) ; input_inner ! { $ parser , $ ( $ r ) * } } ; ( $ ( $ r : tt ) * ) => { input ! { new_stdin_parser = parser , $ ( $ r ) * } } ; }\n#[macro_export]\nmacro_rules ! input_inner { ( $ parser : ident ) => { } ; ( $ parser : ident , ) => { } ; ( $ parser : ident , $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let $ var = read_value ! ( $ parser , $ t ) ; input_inner ! { $ parser $ ( $ r ) * } } ; }\n#[macro_export]\nmacro_rules ! read_value { ( $ parser : ident , ( $ ( $ t : tt ) ,* ) ) => { ( $ ( read_value ! ( $ parser , $ t ) ) ,* ) } ; ( $ parser : ident , [ $ t : tt ; $ len : expr ] ) => { ( 0 ..$ len ) . map ( | _ | read_value ! ( $ parser , $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ parser : ident , chars ) => { read_value ! ( $ parser , String ) . chars ( ) . collect ::< Vec < char >> ( ) } ; ( $ parser : ident , usize1 ) => { read_value ! ( $ parser , usize ) - 1 } ; ( $ parser : ident , $ t : ty ) => { $ parser . next ::<$ t > ( ) . expect ( \"Parse error\" ) } ; }\nuse std::io;\nuse std::io::BufRead;\nuse std::str;\npub struct Parser<R> {\n reader: R,\n buf: Vec<u8>,\n pos: usize,\n}\nimpl Parser<io::Empty> {\n pub fn from_str(s: &str) -> Parser<io::Empty> {\n Parser {\n reader: io::empty(),\n buf: s.as_bytes().to_vec(),\n pos: 0,\n }\n }\n}\nimpl<R: BufRead> Parser<R> {\n pub fn new(reader: R) -> Parser<R> {\n Parser {\n reader: reader,\n buf: vec![],\n pos: 0,\n }\n }\n pub fn update_buf(&mut self) {\n self.buf.clear();\n self.pos = 0;\n loop {\n let (len, complete) = {\n let buf2 = self.reader.fill_buf().unwrap();\n self.buf.extend_from_slice(buf2);\n let len = buf2.len();\n if len == 0 {\n break;\n }\n (len, buf2[len - 1] <= 0x20)\n };\n self.reader.consume(len);\n if complete {\n break;\n }\n }\n }\n pub fn next<T: str::FromStr>(&mut self) -> Result<T, T::Err> {\n loop {\n let mut begin = self.pos;\n while begin < self.buf.len() && (self.buf[begin] <= 0x20) {\n begin += 1;\n }\n let mut end = begin;\n while end < self.buf.len() && (self.buf[end] > 0x20) {\n end += 1;\n }\n if begin != self.buf.len() {\n self.pos = end;\n return str::from_utf8(&self.buf[begin..end]).unwrap().parse::<T>();\n } else {\n self.update_buf();\n }\n }\n }\n}\n#[allow(unused_macros)]\nmacro_rules ! debug { ( $ ( $ a : expr ) ,* ) => { eprintln ! ( concat ! ( $ ( stringify ! ( $ a ) , \" = {:?}, \" ) ,* ) , $ ( $ a ) ,* ) ; } }\n#[doc = \" https://github.com/hatoo/competitive-rust-snippets\"]\nconst BIG_STACK_SIZE: bool = true;\n#[allow(dead_code)]\nfn main() {\n use std::thread;\n if BIG_STACK_SIZE {\n thread::Builder::new()\n .stack_size(32 * 1024 * 1024)\n .name(\"solve\".into())\n .spawn(solve)\n .unwrap()\n .join()\n .unwrap();\n } else {\n solve();\n }\n}\nfn solve() {\n let out = stdout();\n let mut out = BufWriter::new(out.lock());\n input!{\n new_stdin_parser = parser,\n q:usize,\n }\n for _ in 0..q {\n input!{\n parser = parser,\n h:usize,n:usize,\n p:[usize;n],\n }\n let mut state = vec![false; h+1];\n for pi in p {\n state[pi] = true;\n }\n let mut magic = 0;\n let mut cur = h;\n while cur > 2 {\n assert!(state[cur]);\n\n let jump1 = cur-1;\n let jump2 = cur-2;\n // 2jump case\n if state[jump1] && state[jump2] {\n cur = jump2;\n }\n else if !state[jump1] {\n state[jump1] = true;\n cur = jump1;\n }\n else {\n magic += 1;\n state[jump2] = true;\n cur = jump2;\n }\n }\n println!(\"{}\",magic);\n }\n}", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "b3249dddb57f553525d6b858ab92ce28", "src_uid": "d0c50562764f2008045fe57e5da5de1c", "difficulty": 1600}
- {"lang": "Rust", "source_code": "#[doc = \" https://github.com/hatoo/competitive-rust-snippets\"]\n#[allow(unused_imports)]\nuse std::cmp::{max, min, Ordering};\n#[allow(unused_imports)]\nuse std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};\n#[allow(unused_imports)]\nuse std::iter::FromIterator;\n#[macro_export]\nmacro_rules ! chmax { ( $ x : expr , $ ( $ v : expr ) ,+ ) => { $ ( $ x = std :: cmp :: max ( $ x ,$ v ) ; ) + } ; }\n#[macro_export]\nmacro_rules ! chmin { ( $ x : expr , $ ( $ v : expr ) ,+ ) => { $ ( $ x = std :: cmp :: min ( $ x ,$ v ) ; ) + } ; }\n#[macro_export]\nmacro_rules ! max { ( $ x : expr ) => ( $ x ) ; ( $ x : expr , $ ( $ xs : expr ) ,+ ) => { std :: cmp :: max ( $ x , max ! ( $ ( $ xs ) ,+ ) ) } ; }\n#[macro_export]\nmacro_rules ! min { ( $ x : expr ) => ( $ x ) ; ( $ x : expr , $ ( $ xs : expr ) ,+ ) => { std :: cmp :: min ( $ x , min ! ( $ ( $ xs ) ,+ ) ) } ; }\n#[macro_export]\nmacro_rules ! dvec { ( $ t : expr ; $ len : expr ) => { vec ! [ $ t ; $ len ] } ; ( $ t : expr ; $ len : expr , $ ( $ rest : expr ) ,* ) => { vec ! [ dvec ! ( $ t ; $ ( $ rest ) ,* ) ; $ len ] } ; }\n#[doc = \" main\"]\n#[allow(unused_imports)]\nuse std::io::{stdin, stdout, BufWriter, Write};\n#[macro_export]\nmacro_rules ! input { ( source = $ s : expr , $ ( $ r : tt ) * ) => { let mut parser = Parser :: from_str ( $ s ) ; input_inner ! { parser , $ ( $ r ) * } } ; ( parser = $ parser : ident , $ ( $ r : tt ) * ) => { input_inner ! { $ parser , $ ( $ r ) * } } ; ( new_stdin_parser = $ parser : ident , $ ( $ r : tt ) * ) => { let stdin = std :: io :: stdin ( ) ; let reader = std :: io :: BufReader :: new ( stdin . lock ( ) ) ; let mut $ parser = Parser :: new ( reader ) ; input_inner ! { $ parser , $ ( $ r ) * } } ; ( $ ( $ r : tt ) * ) => { input ! { new_stdin_parser = parser , $ ( $ r ) * } } ; }\n#[macro_export]\nmacro_rules ! input_inner { ( $ parser : ident ) => { } ; ( $ parser : ident , ) => { } ; ( $ parser : ident , $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let $ var = read_value ! ( $ parser , $ t ) ; input_inner ! { $ parser $ ( $ r ) * } } ; }\n#[macro_export]\nmacro_rules ! read_value { ( $ parser : ident , ( $ ( $ t : tt ) ,* ) ) => { ( $ ( read_value ! ( $ parser , $ t ) ) ,* ) } ; ( $ parser : ident , [ $ t : tt ; $ len : expr ] ) => { ( 0 ..$ len ) . map ( | _ | read_value ! ( $ parser , $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ parser : ident , chars ) => { read_value ! ( $ parser , String ) . chars ( ) . collect ::< Vec < char >> ( ) } ; ( $ parser : ident , usize1 ) => { read_value ! ( $ parser , usize ) - 1 } ; ( $ parser : ident , $ t : ty ) => { $ parser . next ::<$ t > ( ) . expect ( \"Parse error\" ) } ; }\nuse std::io;\nuse std::io::BufRead;\nuse std::str;\npub struct Parser<R> {\n reader: R,\n buf: Vec<u8>,\n pos: usize,\n}\nimpl Parser<io::Empty> {\n pub fn from_str(s: &str) -> Parser<io::Empty> {\n Parser {\n reader: io::empty(),\n buf: s.as_bytes().to_vec(),\n pos: 0,\n }\n }\n}\nimpl<R: BufRead> Parser<R> {\n pub fn new(reader: R) -> Parser<R> {\n Parser {\n reader: reader,\n buf: vec![],\n pos: 0,\n }\n }\n pub fn update_buf(&mut self) {\n self.buf.clear();\n self.pos = 0;\n loop {\n let (len, complete) = {\n let buf2 = self.reader.fill_buf().unwrap();\n self.buf.extend_from_slice(buf2);\n let len = buf2.len();\n if len == 0 {\n break;\n }\n (len, buf2[len - 1] <= 0x20)\n };\n self.reader.consume(len);\n if complete {\n break;\n }\n }\n }\n pub fn next<T: str::FromStr>(&mut self) -> Result<T, T::Err> {\n loop {\n let mut begin = self.pos;\n while begin < self.buf.len() && (self.buf[begin] <= 0x20) {\n begin += 1;\n }\n let mut end = begin;\n while end < self.buf.len() && (self.buf[end] > 0x20) {\n end += 1;\n }\n if begin != self.buf.len() {\n self.pos = end;\n return str::from_utf8(&self.buf[begin..end]).unwrap().parse::<T>();\n } else {\n self.update_buf();\n }\n }\n }\n}\n#[allow(unused_macros)]\nmacro_rules ! debug { ( $ ( $ a : expr ) ,* ) => { eprintln ! ( concat ! ( $ ( stringify ! ( $ a ) , \" = {:?}, \" ) ,* ) , $ ( $ a ) ,* ) ; } }\n#[doc = \" https://github.com/hatoo/competitive-rust-snippets\"]\nconst BIG_STACK_SIZE: bool = true;\n#[allow(dead_code)]\nfn main() {\n use std::thread;\n if BIG_STACK_SIZE {\n thread::Builder::new()\n .stack_size(32 * 1024 * 1024)\n .name(\"solve\".into())\n .spawn(solve)\n .unwrap()\n .join()\n .unwrap();\n } else {\n solve();\n }\n}\nfn solve() {\n let out = stdout();\n let mut out = BufWriter::new(out.lock());\n input!{\n new_stdin_parser = parser,\n q:usize,\n }\n for _ in 0..q {\n input!{\n parser = parser,\n h:usize,n:usize,\n p:[usize;n],\n }\n let mut state = HashSet::new();\n for pi in p {\n state.insert(pi);\n }\n let mut magic = 0;\n let mut cur = h;\n while cur > 2 {\n assert!(state.contains(&cur));\n\n let jump1 = cur-1;\n let jump2 = cur-2;\n // 2jump case\n if state.contains(&jump1) && state.contains(&jump2) {\n state.remove(&cur);\n state.remove(&jump1);\n cur = jump2;\n }\n else if !state.contains(&jump1) {\n state.remove(&cur);\n state.insert(jump1);\n cur = jump1;\n }\n else {\n magic += 1;\n state.remove(&cur);\n state.remove(&jump1);\n state.insert(jump2); // magic\n cur = jump2;\n }\n }\n writeln!(out,\"{}\",magic);\n }\n}", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "50f2554e9f0a95b376b645f7649cb31a", "src_uid": "d0c50562764f2008045fe57e5da5de1c", "difficulty": 1600}
- {"lang": "Rust", "source_code": "#[doc = \" https://github.com/hatoo/competitive-rust-snippets\"]\n#[allow(unused_imports)]\nuse std::cmp::{max, min, Ordering};\n#[allow(unused_imports)]\nuse std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};\n#[allow(unused_imports)]\nuse std::iter::FromIterator;\n#[macro_export]\nmacro_rules ! chmax { ( $ x : expr , $ ( $ v : expr ) ,+ ) => { $ ( $ x = std :: cmp :: max ( $ x ,$ v ) ; ) + } ; }\n#[macro_export]\nmacro_rules ! chmin { ( $ x : expr , $ ( $ v : expr ) ,+ ) => { $ ( $ x = std :: cmp :: min ( $ x ,$ v ) ; ) + } ; }\n#[macro_export]\nmacro_rules ! max { ( $ x : expr ) => ( $ x ) ; ( $ x : expr , $ ( $ xs : expr ) ,+ ) => { std :: cmp :: max ( $ x , max ! ( $ ( $ xs ) ,+ ) ) } ; }\n#[macro_export]\nmacro_rules ! min { ( $ x : expr ) => ( $ x ) ; ( $ x : expr , $ ( $ xs : expr ) ,+ ) => { std :: cmp :: min ( $ x , min ! ( $ ( $ xs ) ,+ ) ) } ; }\n#[macro_export]\nmacro_rules ! dvec { ( $ t : expr ; $ len : expr ) => { vec ! [ $ t ; $ len ] } ; ( $ t : expr ; $ len : expr , $ ( $ rest : expr ) ,* ) => { vec ! [ dvec ! ( $ t ; $ ( $ rest ) ,* ) ; $ len ] } ; }\n#[doc = \" main\"]\n#[allow(unused_imports)]\nuse std::io::{stdin, stdout, BufWriter, Write};\n#[macro_export]\nmacro_rules ! input { ( source = $ s : expr , $ ( $ r : tt ) * ) => { let mut parser = Parser :: from_str ( $ s ) ; input_inner ! { parser , $ ( $ r ) * } } ; ( parser = $ parser : ident , $ ( $ r : tt ) * ) => { input_inner ! { $ parser , $ ( $ r ) * } } ; ( new_stdin_parser = $ parser : ident , $ ( $ r : tt ) * ) => { let stdin = std :: io :: stdin ( ) ; let reader = std :: io :: BufReader :: new ( stdin . lock ( ) ) ; let mut $ parser = Parser :: new ( reader ) ; input_inner ! { $ parser , $ ( $ r ) * } } ; ( $ ( $ r : tt ) * ) => { input ! { new_stdin_parser = parser , $ ( $ r ) * } } ; }\n#[macro_export]\nmacro_rules ! input_inner { ( $ parser : ident ) => { } ; ( $ parser : ident , ) => { } ; ( $ parser : ident , $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let $ var = read_value ! ( $ parser , $ t ) ; input_inner ! { $ parser $ ( $ r ) * } } ; }\n#[macro_export]\nmacro_rules ! read_value { ( $ parser : ident , ( $ ( $ t : tt ) ,* ) ) => { ( $ ( read_value ! ( $ parser , $ t ) ) ,* ) } ; ( $ parser : ident , [ $ t : tt ; $ len : expr ] ) => { ( 0 ..$ len ) . map ( | _ | read_value ! ( $ parser , $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ parser : ident , chars ) => { read_value ! ( $ parser , String ) . chars ( ) . collect ::< Vec < char >> ( ) } ; ( $ parser : ident , usize1 ) => { read_value ! ( $ parser , usize ) - 1 } ; ( $ parser : ident , $ t : ty ) => { $ parser . next ::<$ t > ( ) . expect ( \"Parse error\" ) } ; }\nuse std::io;\nuse std::io::BufRead;\nuse std::str;\npub struct Parser<R> {\n reader: R,\n buf: Vec<u8>,\n pos: usize,\n}\nimpl Parser<io::Empty> {\n pub fn from_str(s: &str) -> Parser<io::Empty> {\n Parser {\n reader: io::empty(),\n buf: s.as_bytes().to_vec(),\n pos: 0,\n }\n }\n}\nimpl<R: BufRead> Parser<R> {\n pub fn new(reader: R) -> Parser<R> {\n Parser {\n reader: reader,\n buf: vec![],\n pos: 0,\n }\n }\n pub fn update_buf(&mut self) {\n self.buf.clear();\n self.pos = 0;\n loop {\n let (len, complete) = {\n let buf2 = self.reader.fill_buf().unwrap();\n self.buf.extend_from_slice(buf2);\n let len = buf2.len();\n if len == 0 {\n break;\n }\n (len, buf2[len - 1] <= 0x20)\n };\n self.reader.consume(len);\n if complete {\n break;\n }\n }\n }\n pub fn next<T: str::FromStr>(&mut self) -> Result<T, T::Err> {\n loop {\n let mut begin = self.pos;\n while begin < self.buf.len() && (self.buf[begin] <= 0x20) {\n begin += 1;\n }\n let mut end = begin;\n while end < self.buf.len() && (self.buf[end] > 0x20) {\n end += 1;\n }\n if begin != self.buf.len() {\n self.pos = end;\n return str::from_utf8(&self.buf[begin..end]).unwrap().parse::<T>();\n } else {\n self.update_buf();\n }\n }\n }\n}\n#[allow(unused_macros)]\nmacro_rules ! debug { ( $ ( $ a : expr ) ,* ) => { eprintln ! ( concat ! ( $ ( stringify ! ( $ a ) , \" = {:?}, \" ) ,* ) , $ ( $ a ) ,* ) ; } }\n#[doc = \" https://github.com/hatoo/competitive-rust-snippets\"]\nconst BIG_STACK_SIZE: bool = true;\n#[allow(dead_code)]\nfn main() {\n use std::thread;\n if BIG_STACK_SIZE {\n thread::Builder::new()\n .stack_size(32 * 1024 * 1024)\n .name(\"solve\".into())\n .spawn(solve)\n .unwrap()\n .join()\n .unwrap();\n } else {\n solve();\n }\n}\nfn solve() {\n let out = stdout();\n let mut out = BufWriter::new(out.lock());\n input!{\n new_stdin_parser = parser,\n q:usize,\n }\n for _ in 0..q {\n input!{\n parser = parser,\n h:usize,n:usize,\n p:[usize;n],\n }\n let mut state = vec![false; h+1];\n for pi in p {\n state[pi] = true;\n }\n let mut magic = 0;\n let mut cur = h;\n while cur > 2 {\n assert!(state[cur]);\n\n let jump1 = cur-1;\n let jump2 = cur-2;\n // 2jump case\n if state[jump1] && state[jump2] {\n cur = jump2;\n }\n else if !state[jump1] {\n state[jump1] = true;\n cur = jump1;\n }\n else {\n magic += 1;\n state[jump2] = true;\n cur = jump2;\n }\n }\n writeln!(out,\"{}\",magic);\n }\n}", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "19419ef1b8b2bad1daa96817856656ea", "src_uid": "d0c50562764f2008045fe57e5da5de1c", "difficulty": 1600}
- {"lang": "Rust", "source_code": "#[doc = \" https://github.com/hatoo/competitive-rust-snippets\"]\n#[allow(unused_imports)]\nuse std::cmp::{max, min, Ordering};\n#[allow(unused_imports)]\nuse std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};\n#[allow(unused_imports)]\nuse std::iter::FromIterator;\n#[macro_export]\nmacro_rules ! chmax { ( $ x : expr , $ ( $ v : expr ) ,+ ) => { $ ( $ x = std :: cmp :: max ( $ x ,$ v ) ; ) + } ; }\n#[macro_export]\nmacro_rules ! chmin { ( $ x : expr , $ ( $ v : expr ) ,+ ) => { $ ( $ x = std :: cmp :: min ( $ x ,$ v ) ; ) + } ; }\n#[macro_export]\nmacro_rules ! max { ( $ x : expr ) => ( $ x ) ; ( $ x : expr , $ ( $ xs : expr ) ,+ ) => { std :: cmp :: max ( $ x , max ! ( $ ( $ xs ) ,+ ) ) } ; }\n#[macro_export]\nmacro_rules ! min { ( $ x : expr ) => ( $ x ) ; ( $ x : expr , $ ( $ xs : expr ) ,+ ) => { std :: cmp :: min ( $ x , min ! ( $ ( $ xs ) ,+ ) ) } ; }\n#[macro_export]\nmacro_rules ! dvec { ( $ t : expr ; $ len : expr ) => { vec ! [ $ t ; $ len ] } ; ( $ t : expr ; $ len : expr , $ ( $ rest : expr ) ,* ) => { vec ! [ dvec ! ( $ t ; $ ( $ rest ) ,* ) ; $ len ] } ; }\n#[doc = \" main\"]\n#[allow(unused_imports)]\nuse std::io::{stdin, stdout, BufWriter, Write};\n#[macro_export]\nmacro_rules ! input { ( source = $ s : expr , $ ( $ r : tt ) * ) => { let mut parser = Parser :: from_str ( $ s ) ; input_inner ! { parser , $ ( $ r ) * } } ; ( parser = $ parser : ident , $ ( $ r : tt ) * ) => { input_inner ! { $ parser , $ ( $ r ) * } } ; ( new_stdin_parser = $ parser : ident , $ ( $ r : tt ) * ) => { let stdin = std :: io :: stdin ( ) ; let reader = std :: io :: BufReader :: new ( stdin . lock ( ) ) ; let mut $ parser = Parser :: new ( reader ) ; input_inner ! { $ parser , $ ( $ r ) * } } ; ( $ ( $ r : tt ) * ) => { input ! { new_stdin_parser = parser , $ ( $ r ) * } } ; }\n#[macro_export]\nmacro_rules ! input_inner { ( $ parser : ident ) => { } ; ( $ parser : ident , ) => { } ; ( $ parser : ident , $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let $ var = read_value ! ( $ parser , $ t ) ; input_inner ! { $ parser $ ( $ r ) * } } ; }\n#[macro_export]\nmacro_rules ! read_value { ( $ parser : ident , ( $ ( $ t : tt ) ,* ) ) => { ( $ ( read_value ! ( $ parser , $ t ) ) ,* ) } ; ( $ parser : ident , [ $ t : tt ; $ len : expr ] ) => { ( 0 ..$ len ) . map ( | _ | read_value ! ( $ parser , $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ parser : ident , chars ) => { read_value ! ( $ parser , String ) . chars ( ) . collect ::< Vec < char >> ( ) } ; ( $ parser : ident , usize1 ) => { read_value ! ( $ parser , usize ) - 1 } ; ( $ parser : ident , $ t : ty ) => { $ parser . next ::<$ t > ( ) . expect ( \"Parse error\" ) } ; }\nuse std::io;\nuse std::io::BufRead;\nuse std::str;\npub struct Parser<R> {\n reader: R,\n buf: Vec<u8>,\n pos: usize,\n}\nimpl Parser<io::Empty> {\n pub fn from_str(s: &str) -> Parser<io::Empty> {\n Parser {\n reader: io::empty(),\n buf: s.as_bytes().to_vec(),\n pos: 0,\n }\n }\n}\nimpl<R: BufRead> Parser<R> {\n pub fn new(reader: R) -> Parser<R> {\n Parser {\n reader: reader,\n buf: vec![],\n pos: 0,\n }\n }\n pub fn update_buf(&mut self) {\n self.buf.clear();\n self.pos = 0;\n loop {\n let (len, complete) = {\n let buf2 = self.reader.fill_buf().unwrap();\n self.buf.extend_from_slice(buf2);\n let len = buf2.len();\n if len == 0 {\n break;\n }\n (len, buf2[len - 1] <= 0x20)\n };\n self.reader.consume(len);\n if complete {\n break;\n }\n }\n }\n pub fn next<T: str::FromStr>(&mut self) -> Result<T, T::Err> {\n loop {\n let mut begin = self.pos;\n while begin < self.buf.len() && (self.buf[begin] <= 0x20) {\n begin += 1;\n }\n let mut end = begin;\n while end < self.buf.len() && (self.buf[end] > 0x20) {\n end += 1;\n }\n if begin != self.buf.len() {\n self.pos = end;\n return str::from_utf8(&self.buf[begin..end]).unwrap().parse::<T>();\n } else {\n self.update_buf();\n }\n }\n }\n}\n#[allow(unused_macros)]\nmacro_rules ! debug { ( $ ( $ a : expr ) ,* ) => { eprintln ! ( concat ! ( $ ( stringify ! ( $ a ) , \" = {:?}, \" ) ,* ) , $ ( $ a ) ,* ) ; } }\n#[doc = \" https://github.com/hatoo/competitive-rust-snippets\"]\nconst BIG_STACK_SIZE: bool = true;\n#[allow(dead_code)]\nfn main() {\n use std::thread;\n if BIG_STACK_SIZE {\n thread::Builder::new()\n .stack_size(32 * 1024 * 1024)\n .name(\"solve\".into())\n .spawn(solve)\n .unwrap()\n .join()\n .unwrap();\n } else {\n solve();\n }\n}\nfn solve() {\n let out = stdout();\n let mut out = BufWriter::new(out.lock());\n input!{\n new_stdin_parser = parser,\n q:usize,\n }\n for _ in 0..q {\n input!{\n parser = parser,\n h:usize,n:usize,\n P:[usize;n],\n }\n let mut P = P;\n P.push(0);\n let mut state = HashSet::new();\n for &Pi in &P {\n state.insert(Pi);\n }\n let mut magic = 0;\n let mut cur = h;\n while cur > 2 {\n assert!(state.contains(&cur));\n\n let jump1 = cur-1;\n let jump2 = cur-2;\n // 2jump case\n if state.contains(&jump1) && state.contains(&jump2) {\n state.remove(&cur);\n state.remove(&jump1);\n cur = jump2;\n }\n else if !state.contains(&jump1) {\n let bs = BinarySearch {\n lower: 0,\n upper: (n-1) as i64,\n p: |i:i64| {\n let i = i as usize;\n P[i] < cur\n },\n };\n let r = bs.lower_bound() as usize;\n state.remove(&cur);\n cur = P[r] + 1;\n state.insert(cur);\n }\n else {\n magic += 1;\n state.remove(&cur);\n state.remove(&jump1);\n state.insert(jump2); // magic\n cur = jump2;\n }\n // dbg!(cur);\n }\n // println!(\"{}\",magic);\n writeln!(out,\"{}\",magic);\n }\n}\n\n#[doc = \"lower,upper are inclusive range\"]\npub struct BinarySearch<F> {\n pub p: F,\n pub lower: i64,\n pub upper: i64,\n}\nimpl<F: Fn(i64) -> bool> BinarySearch<F> {\n #[doc = \"O(log(upper-lower))\"]\n pub fn lower_bound(&self) -> i64 {\n let lower = self.lower;\n let upper = self.upper;\n assert!(lower <= upper);\n let mut lb = lower - 1;\n let mut ub = upper + 1;\n while ub - lb > 1 {\n let mid = (lb + ub) / 2;\n if (self.p)(mid) {\n ub = mid;\n } else {\n lb = mid;\n }\n }\n let latter = ub;\n latter\n }\n}", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "3d16e1247c3d3b72aaa241055c123a56", "src_uid": "d0c50562764f2008045fe57e5da5de1c", "difficulty": 1600}
- {"lang": "Rust", "source_code": "mod union_find {\n pub struct UF {\n p: Vec<i32>,\n }\n #[allow(dead_code)]\n impl UF {\n pub fn new(n: usize) -> UF {\n UF {p: vec![-1; n] }\n }\n pub fn root(&mut self, mut x: usize) -> usize {\n while self.p[x] >= 0 {\n x = self.p[x] as usize;\n }\n x\n }\n pub fn same(&mut self, x: usize, y: usize) -> bool {\n self.root(x) == self.root(y)\n }\n pub fn unite(&mut self, mut x: usize, mut y: usize) {\n x = self.root(x);\n y = self.root(y);\n if x == y {\n return;\n }\n if self.p[x] > self.p[y] {\n std::mem::swap(&mut x, &mut y);\n }\n self.p[x] += self.p[y];\n self.p[y] = x as i32;\n }\n pub fn get_size(&mut self, x: usize) -> usize {\n let r = self.root(x);\n (-self.p[r]) as usize\n }\n }\n}\n//https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 \u3088\u308a\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n ($($r:tt)*) => {\n let s = {\n use std::io::Read;\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n };\n let mut iter = s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n}\n\nmacro_rules! input_inner {\n ($iter:expr) => {};\n ($iter:expr, ) => {};\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n}\n\nmacro_rules! read_value {\n ($iter:expr, ( $($t:tt),* )) => {\n ( $(read_value!($iter, $t)),* )\n };\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()\n };\n ($iter:expr, chars) => {\n read_value!($iter, String).chars().collect::<Vec<char>>()\n };\n ($iter:expr, usize1) => {\n read_value!($iter, usize) - 1\n };\n ($iter:expr, $t:ty) => {\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n// \u3053\u3053\u307e\u3067\n\nfn run() {\n input! {\n n: usize,\n m: usize,\n a: [u64; n],\n e: [(usize, usize, u64); m],\n }\n let mut k = 0;\n let mut a: Vec<(u64, usize)> = a.into_iter().map(|x| {k += 1; (x, k)}).collect();\n a.sort();\n let mut e: Vec<(u64, usize, usize)> = e.into_iter().map(|(a, b, w)| (w, a, b)).collect();\n let (c, x) = a[0];\n for &(w, v) in a[1..].iter() {\n e.push((c + w, x, v));\n }\n e.sort();\n let mut u = union_find::UF::new(n + 1);\n let mut cost = 0;\n for (c, a, b) in e {\n if !u.same(a, b) {\n u.unite(a, b);\n cost += c;\n }\n }\n println!(\"{}\", cost);\n}\n\nfn main() {\n run();\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "f9842aa8632955e94473a732792a682b", "src_uid": "e52ec2fa5bcf5d2027d57b0694b4e15a", "difficulty": 1900}
- {"lang": "Rust", "source_code": "#[allow(unused_imports)]\nuse std::cmp::*;\n#[allow(unused_imports)]\nuse std::collections::*;\nuse std::io::{Write, BufWriter};\n// https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n let mut next = || { iter.next().unwrap() };\n input_inner!{next, $($r)*}\n };\n ($($r:tt)*) => {\n let stdin = std::io::stdin();\n let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));\n let mut next = move || -> String{\n bytes\n .by_ref()\n .map(|r|r.unwrap() as char)\n .skip_while(|c|c.is_whitespace())\n .take_while(|c|!c.is_whitespace())\n .collect()\n };\n input_inner!{next, $($r)*}\n };\n}\n\nmacro_rules! input_inner {\n ($next:expr) => {};\n ($next:expr, ) => {};\n\n ($next:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($next, $t);\n input_inner!{$next $($r)*}\n };\n}\n\nmacro_rules! read_value {\n ($next:expr, ( $($t:tt),* )) => {\n ( $(read_value!($next, $t)),* )\n };\n\n ($next:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()\n };\n\n ($next:expr, chars) => {\n read_value!($next, String).chars().collect::<Vec<char>>()\n };\n\n ($next:expr, usize1) => {\n read_value!($next, usize) - 1\n };\n\n ($next:expr, [ $t:tt ]) => {{\n let len = read_value!($next, usize);\n (0..len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()\n }};\n\n ($next:expr, $t:ty) => {\n $next().parse::<$t>().expect(\"Parse error\")\n };\n}\n\nfn solve() {\n let out = std::io::stdout();\n let mut out = BufWriter::new(out.lock());\n macro_rules! puts {\n ($($format:tt)*) => (write!(out,$($format)*).unwrap());\n }\n input! {\n n: usize,\n m: usize,\n a: [i64; n],\n xyw: [(usize1, usize1, i64); m],\n }\n let mut g = vec![Vec::new(); n];\n for (x, y, w) in xyw {\n g[x].push((y, w));\n g[y].push((x, w));\n }\n let mut amin = (1 << 50, n);\n for i in 0 .. n { amin = min(amin, (a[i], i)); }\n // Prim\n let mut tot = 0;\n let (added, init) = amin;\n let mut used = vec![false; n];\n used[init] = true;\n let mut que = BinaryHeap::new();\n for i in 0 .. n {\n if init != i {\n que.push(Reverse((a[i] + added, i)));\n }\n }\n for &(w, cost) in g[init].iter() {\n que.push(Reverse((cost, w)));\n }\n while let Some(Reverse((cost, v))) = que.pop() {\n if used[v] { continue; }\n tot += cost;\n used[v] = true;\n for &(w, cost) in g[v].iter() {\n que.push(Reverse((cost, w)));\n }\n }\n puts!(\"{}\\n\", tot)\n}\n\nfn main() {\n // In order to avoid potential stack overflow, spawn a new thread.\n let stack_size = 104_857_600; // 100 MB\n let thd = std::thread::Builder::new().stack_size(stack_size);\n thd.spawn(|| solve()).unwrap().join().unwrap();\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "b16b7d0fe6e78d2642950b033861c461", "src_uid": "e52ec2fa5bcf5d2027d57b0694b4e15a", "difficulty": 1900}
- {"lang": "Rust", "source_code": "#[allow(unused_imports)]\nuse std::cmp::{min,max};\n#[allow(unused_imports)]\nuse std::collections::{BTreeMap,BTreeSet};\n#[allow(unused_imports)]\nuse std::ops::*;\n#[allow(unused_imports)]\nuse std::collections::BinaryHeap;\n\n#[allow(unused_macros)]\nmacro_rules! ite {\n ($c:expr, $t:expr, $f:expr) => {{\n if $c { $t } else { $f }\n }};\n}\n\n// ref: tanakh <https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8>\n// diff: using Parser\n#[macro_export]\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut parser = Parser::from_str($s);\n input_inner!{parser, $($r)*}\n };\n (parser = $parser:ident, $($r:tt)*) => {\n input_inner!{$parser, $($r)*}\n };\n (new_stdin_parser = $parser:ident, $($r:tt)*) => {\n let stdin = std::io::stdin();\n let reader = std::io::BufReader::new(stdin.lock());\n let mut $parser = Parser::new(reader);\n input_inner!{$parser, $($r)*}\n };\n ($($r:tt)*) => {\n input!{new_stdin_parser = parser, $($r)*}\n };\n}\n\n#[macro_export]\nmacro_rules! input_inner {\n ($parser:ident) => {};\n ($parser:ident, ) => {};\n ($parser:ident, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($parser, $t);\n input_inner!{$parser $($r)*}\n };\n}\n\n#[macro_export]\nmacro_rules! read_value {\n ($parser:ident, ( $($t:tt),* )) => {\n ( $(read_value!($parser, $t)),* )\n };\n ($parser:ident, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($parser, $t)).collect::<Vec<_>>()\n };\n ($parser:ident, chars) => {\n read_value!($parser, String).chars().collect::<Vec<char>>()\n };\n ($parser:ident, usize1) => {\n read_value!($parser, usize) - 1\n };\n ($parser:ident, $t:ty) => {\n $parser.next::<$t>().expect(\"Parse error\")\n };\n}\n\nfn main() {\n input! {\n n: usize,\n m: usize,\n xs: [i64; n],\n es: [(usize1, usize1, i64); m]\n }\n let mut offers = vec![BinaryHeap::new(); n];\n for &(x,y,w) in &es {\n offers[x].push((-w,y));\n offers[y].push((-w,x));\n }\n let mut used = vec![false; n];\n\n let first = 0;\n\n used[first] = true;\n let mut used_count = 1;\n let mut unused_heap = BinaryHeap::new();\n for i in 0..n {\n unused_heap.push((-xs[i], i));\n }\n\n let mut left_offers = BinaryHeap::new();\n let mut left_min = xs[first];\n left_offers.append(&mut offers[first]);\n\n let mut res = 0;\n while used_count < n {\n while let Some((nw, next)) = left_offers.pop() {\n if ! used[next] {\n left_offers.push((nw, next));\n break;\n }\n }\n while let Some((nw, v)) = unused_heap.pop() {\n if ! used[v] {\n unused_heap.push((nw, v));\n break;\n }\n }\n let mut min_next = None;\n let mut min_cost = None;\n if let Some(&(nw, next)) = left_offers.peek() {\n let t = -nw;\n if min_cost.is_none() || min_cost.unwrap() > t {\n min_cost = Some(t);\n min_next = Some(next);\n }\n }\n if let Some(&(nw, next)) = unused_heap.peek() {\n let t = left_min + -nw;\n if min_cost.is_none() || min_cost.unwrap() > t {\n min_cost = Some(t);\n min_next = Some(next);\n }\n }\n\n left_offers.append(&mut offers[min_next.unwrap()]);\n left_min = min(left_min, xs[min_next.unwrap()]);\n res += min_cost.unwrap();\n used[min_next.unwrap()] = true;\n\n used_count += 1;\n }\n println!(\"{}\", res);\n}\n\nuse std::io::BufRead;\nuse std::io;\nuse std::str;\n\n// ref: tatsuya6502 <https://qiita.com/tatsuya6502/items/cd448486f7ef7b5b8c7e>\n// ref: wariuni <https://qiita.com/tatsuya6502/items/cd448486f7ef7b5b8c7e#comment-7040a5ae96305e884eb9>\n// diff: using std::io::BufRead::fill_buf()\npub struct Parser<R> {\n reader: R,\n buf: Vec<u8>,\n pos: usize,\n}\n\nimpl Parser<io::Empty> {\n pub fn from_str(s: &str) -> Parser<io::Empty> {\n Parser {\n reader: io::empty(),\n buf: s.as_bytes().to_vec(),\n pos: 0,\n }\n }\n}\n\nimpl<R:BufRead> Parser<R> {\n pub fn new(reader: R) -> Parser<R> {\n Parser {\n reader: reader,\n buf: vec![],\n pos: 0,\n }\n }\n pub fn update_buf(&mut self) {\n self.buf.clear();\n self.pos = 0;\n loop {\n let (len,complete) = {\n let buf2 = self.reader.fill_buf().unwrap();\n self.buf.extend_from_slice(buf2);\n let len = buf2.len();\n (len, buf2[len-1] <= 0x20)\n };\n self.reader.consume(len);\n if complete {\n break;\n }\n }\n }\n pub fn next<T:str::FromStr>(&mut self) -> Result<T, T::Err> {\n loop {\n let mut begin = self.pos;\n while begin < self.buf.len() && (self.buf[begin] <= 0x20) {\n begin += 1;\n }\n let mut end = begin;\n while end < self.buf.len() && (self.buf[end] > 0x20) {\n end += 1;\n }\n if begin != self.buf.len() {\n self.pos = end;\n return str::from_utf8(&self.buf[begin..end]).unwrap().parse::<T>();\n }\n else {\n self.update_buf();\n }\n }\n }\n}\n\nuse std::fmt::Display;\n#[allow(dead_code)]\nfn write_vec<T: Display>(xs: &Vec<T>) {\n if xs.len() == 0 {\n println!();\n return;\n }\n print!(\"{}\", xs[0]);\n for i in 1..xs.len() {\n print!(\" {}\", xs[i]);\n }\n println!();\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "fdbf3a62685242bd099d947dddc8cddf", "src_uid": "e52ec2fa5bcf5d2027d57b0694b4e15a", "difficulty": 1900}
- {"lang": "Rust", "source_code": "#![allow(unused_variables)]\n#![allow(unused_must_use)]\n#![allow(unused_imports)]\nuse std::collections::BinaryHeap;\nuse std::collections::BTreeSet;\nuse std::collections::HashMap;\nuse std::collections::HashSet;\nuse std::io::{self, prelude::*};\nuse std::cmp::{min,max};\nuse std::cmp::Reverse;\n\n\n\n\nfn collapse(x: &usize, uf: &mut Vec<usize>) {\n let mut xs = vec![];\n let mut y = *x;\n\n while uf[y] != y {\n xs.push(y);\n y = uf[y];\n }\n\n for i in 0..xs.len() {\n uf[xs[i]] = y;\n }\n}\n\nfn solve<R: BufRead, W: Write>(mut input: FastInput<R>, mut w: W) {\n let n: usize = input.token();\n let m: usize = input.token();\n\n let mut vs = vec![];\n let mut uf = vec![];\n let mut components = n;\n\n for i in 0..n {\n let ai: i64 = input.token();\n vs.push((ai, i));\n uf.push(i);\n }\n\n vs.sort();\n\n\n let mut es = vec![];\n\n for i in 0..m {\n let a: usize = input.token();\n let b: usize = input.token();\n let w: i64 = input.token();\n es.push((w, a - 1, b - 1));\n }\n\n let mut heap = BinaryHeap::new();\n\n for i in 0..es.len() {\n heap.push(Reverse((es[i].0, es[i].1, es[i].2)));\n }\n\n for i in 1..n {\n heap.push(Reverse((vs[0].0 + vs[i].0, vs[i].1, vs[0].1)));\n }\n\n let mut total_cost: i64 = 0;\n\n while let Some(Reverse((v, x, y))) = heap.pop() {\n // println!(\"Processing {}-{} ({})\", x, y, v);\n collapse(&x, &mut uf);\n collapse(&y, &mut uf);\n if uf[y] == uf[x] {\n // println!(\"skip\");\n continue;\n }\n /*\n for i in 0..n {\n print!(\"({} -> {})\", i, uf[i]);\n }\n println!(\"\");\n */\n let z = uf[y];\n uf[z] = uf[x];\n uf[z] = uf[x];\n components -= 1;\n total_cost += v as i64;\n \n if components == 1 {\n break;\n }\n }\n\n write!(w, \"{}\\n\", total_cost);\n}\n\nfn main() {\n let stdin = io::stdin();\n let stdout = io::stdout();\n let input = FastInput::from(stdin.lock());\n let writer = io::BufWriter::new(stdout.lock());\n solve(input, writer);\n}\n\ntrait TokenStream<T> {\n fn token(&mut self) -> T;\n}\n\nstruct FastInput<R> {\n stdin: R,\n pos: usize,\n}\n\nimpl<R: BufRead> From<R> for FastInput<R> {\n fn from(r: R) -> Self {\n FastInput { stdin: r, pos: 0 }\n }\n}\n\nimpl<R: BufRead> TokenStream<u8> for FastInput<R> {\n fn token(&mut self) -> u8 {\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n while self.pos < buf.len() {\n self.pos += 1;\n if buf[self.pos - 1] > 32 {\n return buf[self.pos - 1];\n }\n }\n if self.pos == 0 {\n return 0;\n }\n } else {\n return 0;\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n}\n\nimpl<R: BufRead> TokenStream<Vec<u8>> for FastInput<R> {\n fn token(&mut self) -> Vec<u8> {\n let mut ans = Vec::new();\n let mut parse_token = false;\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n if !parse_token {\n while self.pos < buf.len() && buf[self.pos] <= 32 {\n self.pos += 1;\n }\n }\n while self.pos < buf.len() && buf[self.pos] > 32 {\n parse_token = true;\n ans.push(buf[self.pos]);\n self.pos += 1;\n }\n if self.pos != buf.len() || self.pos == 0 {\n return ans;\n }\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n}\n\nmacro_rules! impl_token_stream {\n ($($t:ident),+) => {$(\n impl<R: BufRead> TokenStream<$t> for FastInput<R> {\n fn token(&mut self) -> $t {\n let mut ans = 0;\n let mut parse_token = false;\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n if !parse_token {\n while self.pos < buf.len() && buf[self.pos] <= 32 {\n self.pos += 1;\n }\n }\n while self.pos < buf.len() && buf[self.pos] > 32 {\n parse_token = true;\n ans = ans * 10 + (buf[self.pos] - b'0') as $t;\n self.pos += 1;\n }\n if self.pos != buf.len() || self.pos == 0 {\n return ans;\n }\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n }\n )+}\n}\n\nimpl_token_stream!(usize);\nimpl_token_stream!(i64);\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "b9c5cbd0fe408301cbd316e9aacf92aa", "src_uid": "e52ec2fa5bcf5d2027d57b0694b4e15a", "difficulty": 1900}
- {"lang": "Rust", "source_code": "#![allow(unused_variables)]\n#![allow(unused_must_use)]\n#![allow(unused_imports)]\nuse std::collections::BinaryHeap;\nuse std::collections::BTreeSet;\nuse std::collections::HashMap;\nuse std::collections::HashSet;\nuse std::io::{self, prelude::*};\nuse std::cmp::{min,max};\nuse std::cmp::Reverse;\n\n\n\n#[derive(Debug, Ord, Eq, PartialEq, PartialOrd)]\nenum Edge {\n Normal,\n Offer,\n} \n\nfn collapse(x: &usize, uf: &mut Vec<usize>) {\n let mut xs = vec![];\n let mut y = *x;\n\n while uf[y] != y {\n xs.push(y);\n y = uf[y];\n }\n\n for i in 0..xs.len() {\n uf[xs[i]] = y;\n }\n}\n\nfn solve<R: BufRead, W: Write>(mut input: FastInput<R>, mut w: W) {\n let n: usize = input.token();\n let m: usize = input.token();\n\n let mut vs = vec![];\n let mut uf = vec![];\n let mut indexes = HashMap::new();\n let mut components = n;\n\n for i in 0..n {\n let ai: usize = input.token();\n vs.push((ai, i));\n uf.push(i);\n }\n\n vs.sort();\n\n for i in 0..n {\n indexes.insert(vs[i].1, i);\n }\n\n let mut es = vec![];\n\n for i in 0..m {\n let a: usize = input.token();\n let b: usize = input.token();\n let w: usize = input.token();\n if vs[indexes[&(a - 1)]].0 + vs[indexes[&(b - 1)]].0 > w {\n es.push((w, a - 1, b - 1));\n }\n }\n\n let mut heap = BinaryHeap::new();\n\n for i in 0..es.len() {\n heap.push(Reverse((es[i].0, es[i].1, es[i].2, Edge::Offer)));\n }\n\n for i in 1..n {\n heap.push(Reverse((vs[0].0 + vs[i].0, vs[i].1, vs[0].1, Edge::Normal)));\n }\n\n let mut total_cost = 0;\n\n while let Some(Reverse((v, x, y, t))) = heap.pop() {\n // println!(\"Processing {}-{} ({}, {:?})\", x, y, v, t);\n collapse(&x, &mut uf);\n collapse(&y, &mut uf);\n if uf[y] == uf[x] {\n // println!(\"skip\");\n continue;\n }\n /*\n for i in 0..n {\n print!(\"({} -> {})\", i, uf[i]);\n }\n println!(\"\");\n */\n let z = uf[y];\n uf[z] = uf[x];\n components -= 1;\n total_cost += v;\n \n if components == 1 {\n break;\n }\n\n if t == Edge::Normal {\n let mut new_y = vs[indexes[&y] + 1].1;\n if new_y == x {\n new_y = vs[indexes[&y] + 2].1;\n }\n let new_v = vs[indexes[&new_y]].0 + vs[indexes[&x]].0;\n // println!(\"Add {}-{}, {}\", x,y,v);\n heap.push(Reverse((new_v, x, new_y, Edge::Normal)));\n }\n }\n\n write!(w, \"{}\\n\", total_cost);\n}\n\nfn main() {\n let stdin = io::stdin();\n let stdout = io::stdout();\n let input = FastInput::from(stdin.lock());\n let writer = io::BufWriter::new(stdout.lock());\n solve(input, writer);\n}\n\ntrait TokenStream<T> {\n fn token(&mut self) -> T;\n}\n\nstruct FastInput<R> {\n stdin: R,\n pos: usize,\n}\n\nimpl<R: BufRead> From<R> for FastInput<R> {\n fn from(r: R) -> Self {\n FastInput { stdin: r, pos: 0 }\n }\n}\n\nimpl<R: BufRead> TokenStream<u8> for FastInput<R> {\n fn token(&mut self) -> u8 {\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n while self.pos < buf.len() {\n self.pos += 1;\n if buf[self.pos - 1] > 32 {\n return buf[self.pos - 1];\n }\n }\n if self.pos == 0 {\n return 0;\n }\n } else {\n return 0;\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n}\n\nimpl<R: BufRead> TokenStream<Vec<u8>> for FastInput<R> {\n fn token(&mut self) -> Vec<u8> {\n let mut ans = Vec::new();\n let mut parse_token = false;\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n if !parse_token {\n while self.pos < buf.len() && buf[self.pos] <= 32 {\n self.pos += 1;\n }\n }\n while self.pos < buf.len() && buf[self.pos] > 32 {\n parse_token = true;\n ans.push(buf[self.pos]);\n self.pos += 1;\n }\n if self.pos != buf.len() || self.pos == 0 {\n return ans;\n }\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n}\n\nmacro_rules! impl_token_stream {\n ($($t:ident),+) => {$(\n impl<R: BufRead> TokenStream<$t> for FastInput<R> {\n fn token(&mut self) -> $t {\n let mut ans = 0;\n let mut parse_token = false;\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n if !parse_token {\n while self.pos < buf.len() && buf[self.pos] <= 32 {\n self.pos += 1;\n }\n }\n while self.pos < buf.len() && buf[self.pos] > 32 {\n parse_token = true;\n ans = ans * 10 + (buf[self.pos] - b'0') as $t;\n self.pos += 1;\n }\n if self.pos != buf.len() || self.pos == 0 {\n return ans;\n }\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n }\n )+}\n}\n\nimpl_token_stream!(usize);\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "debfc82b21595e9df45a98e9516ab86f", "src_uid": "e52ec2fa5bcf5d2027d57b0694b4e15a", "difficulty": 1900}
- {"lang": "Rust", "source_code": "#![allow(unused_variables)]\n#![allow(unused_must_use)]\n#![allow(unused_imports)]\nuse std::collections::BinaryHeap;\nuse std::collections::BTreeSet;\nuse std::collections::HashMap;\nuse std::collections::HashSet;\nuse std::io::{self, prelude::*};\nuse std::cmp::{min,max};\nuse std::cmp::Reverse;\n\n\n\n#[derive(Debug, Ord, Eq, PartialEq, PartialOrd)]\nenum Edge {\n Normal,\n Offer,\n} \n\nfn collapse(x: &usize, uf: &mut Vec<usize>) {\n let mut xs = vec![];\n let mut y = *x;\n\n while uf[y] != y {\n xs.push(y);\n y = uf[y];\n }\n\n for i in 0..xs.len() {\n uf[xs[i]] = y;\n }\n}\n\nfn solve<R: BufRead, W: Write>(mut input: FastInput<R>, mut w: W) {\n let n: usize = input.token();\n let m: usize = input.token();\n\n let mut vs = vec![];\n let mut uf = vec![];\n let mut indexes = HashMap::new();\n let mut components = n;\n\n for i in 0..n {\n let ai: usize = input.token();\n vs.push((ai, i));\n uf.push(i);\n }\n\n vs.sort();\n\n for i in 0..n {\n indexes.insert(vs[i].1, i);\n }\n\n let mut es = vec![];\n\n for i in 0..m {\n let a: usize = input.token();\n let b: usize = input.token();\n let w: usize = input.token();\n if vs[indexes[&(a - 1)]].0 + vs[indexes[&(b - 1)]].0 > w {\n es.push((w, a - 1, b - 1));\n }\n }\n\n let mut heap = BinaryHeap::new();\n\n for i in 0..es.len() {\n heap.push(Reverse((es[i].0, es[i].1, es[i].2, Edge::Offer)));\n }\n\n for i in 1..n {\n heap.push(Reverse((vs[0].0 + vs[i].0, vs[i].1, vs[0].1, Edge::Normal)));\n }\n\n let mut total_cost = 0;\n\n while let Some(Reverse((v, x, y, t))) = heap.pop() {\n // println!(\"Processing {}-{} ({}, {:?})\", x, y, v, t);\n collapse(&x, &mut uf);\n collapse(&y, &mut uf);\n if uf[y] == uf[x] {\n // println!(\"skip\");\n continue;\n }\n /*\n for i in 0..n {\n print!(\"({} -> {})\", i, uf[i]);\n }\n println!(\"\");\n */\n let z = uf[y];\n uf[z] = uf[x];\n components -= 1;\n total_cost += v;\n \n if components == 1 {\n break;\n }\n\n if t == Edge::Normal {\n let mut new_y = vs[indexes[&y] + 1].1;\n if new_y == x {\n new_y += 1;\n }\n let new_v = vs[indexes[&new_y]].0 + vs[indexes[&x]].0;\n heap.push(Reverse((new_v, x, new_y, Edge::Normal)));\n }\n }\n\n write!(w, \"{}\\n\", total_cost);\n}\n\nfn main() {\n let stdin = io::stdin();\n let stdout = io::stdout();\n let input = FastInput::from(stdin.lock());\n let writer = io::BufWriter::new(stdout.lock());\n solve(input, writer);\n}\n\ntrait TokenStream<T> {\n fn token(&mut self) -> T;\n}\n\nstruct FastInput<R> {\n stdin: R,\n pos: usize,\n}\n\nimpl<R: BufRead> From<R> for FastInput<R> {\n fn from(r: R) -> Self {\n FastInput { stdin: r, pos: 0 }\n }\n}\n\nimpl<R: BufRead> TokenStream<u8> for FastInput<R> {\n fn token(&mut self) -> u8 {\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n while self.pos < buf.len() {\n self.pos += 1;\n if buf[self.pos - 1] > 32 {\n return buf[self.pos - 1];\n }\n }\n if self.pos == 0 {\n return 0;\n }\n } else {\n return 0;\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n}\n\nimpl<R: BufRead> TokenStream<Vec<u8>> for FastInput<R> {\n fn token(&mut self) -> Vec<u8> {\n let mut ans = Vec::new();\n let mut parse_token = false;\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n if !parse_token {\n while self.pos < buf.len() && buf[self.pos] <= 32 {\n self.pos += 1;\n }\n }\n while self.pos < buf.len() && buf[self.pos] > 32 {\n parse_token = true;\n ans.push(buf[self.pos]);\n self.pos += 1;\n }\n if self.pos != buf.len() || self.pos == 0 {\n return ans;\n }\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n}\n\nmacro_rules! impl_token_stream {\n ($($t:ident),+) => {$(\n impl<R: BufRead> TokenStream<$t> for FastInput<R> {\n fn token(&mut self) -> $t {\n let mut ans = 0;\n let mut parse_token = false;\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n if !parse_token {\n while self.pos < buf.len() && buf[self.pos] <= 32 {\n self.pos += 1;\n }\n }\n while self.pos < buf.len() && buf[self.pos] > 32 {\n parse_token = true;\n ans = ans * 10 + (buf[self.pos] - b'0') as $t;\n self.pos += 1;\n }\n if self.pos != buf.len() || self.pos == 0 {\n return ans;\n }\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n }\n )+}\n}\n\nimpl_token_stream!(usize);\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "7436893ea0f98234e2478703c923ad36", "src_uid": "e52ec2fa5bcf5d2027d57b0694b4e15a", "difficulty": 1900}
- {"lang": "Rust", "source_code": "#![allow(unused_variables)]\n#![allow(unused_must_use)]\n#![allow(unused_imports)]\nuse std::collections::BinaryHeap;\nuse std::collections::BTreeSet;\nuse std::collections::HashMap;\nuse std::collections::HashSet;\nuse std::io::{self, prelude::*};\nuse std::cmp::{min,max};\nuse std::cmp::Reverse;\n\n\n\n\nfn collapse(x: &usize, uf: &mut Vec<usize>) {\n let mut xs = vec![];\n let mut y = *x;\n\n while uf[y] != y {\n xs.push(y);\n y = uf[y];\n }\n\n for i in 0..xs.len() {\n uf[xs[i]] = y;\n }\n}\n\nfn solve<R: BufRead, W: Write>(mut input: FastInput<R>, mut w: W) {\n let n: usize = input.token();\n let m: usize = input.token();\n\n let mut vs = vec![];\n let mut uf = vec![];\n let mut components = n;\n\n for i in 0..n {\n let ai: usize = input.token();\n vs.push((ai, i));\n uf.push(i);\n }\n\n vs.sort();\n\n let mut es = vec![];\n\n for i in 0..m {\n let a: usize = input.token();\n let b: usize = input.token();\n let w: usize = input.token();\n }\n\n let mut heap = BinaryHeap::new();\n\n for i in 0..es.len() {\n heap.push(Reverse((es[i].0, es[i].1, es[i].2)));\n }\n\n for i in 1..n {\n heap.push(Reverse((vs[0].0 + vs[i].0, vs[i].1, vs[0].1)));\n }\n\n let mut total_cost = 0;\n\n while let Some(Reverse((v, x, y))) = heap.pop() {\n // println!(\"Processing {}-{} ({})\", x, y, v);\n collapse(&x, &mut uf);\n collapse(&y, &mut uf);\n if uf[y] == uf[x] {\n // println!(\"skip\");\n continue;\n }\n /*\n for i in 0..n {\n print!(\"({} -> {})\", i, uf[i]);\n }\n println!(\"\");\n */\n let z = uf[y];\n uf[z] = uf[x];\n uf[y] = uf[x];\n components -= 1;\n total_cost += v;\n \n if components == 1 {\n break;\n }\n }\n\n write!(w, \"{}\\n\", total_cost);\n}\n\nfn main() {\n let stdin = io::stdin();\n let stdout = io::stdout();\n let input = FastInput::from(stdin.lock());\n let writer = io::BufWriter::new(stdout.lock());\n solve(input, writer);\n}\n\ntrait TokenStream<T> {\n fn token(&mut self) -> T;\n}\n\nstruct FastInput<R> {\n stdin: R,\n pos: usize,\n}\n\nimpl<R: BufRead> From<R> for FastInput<R> {\n fn from(r: R) -> Self {\n FastInput { stdin: r, pos: 0 }\n }\n}\n\nimpl<R: BufRead> TokenStream<u8> for FastInput<R> {\n fn token(&mut self) -> u8 {\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n while self.pos < buf.len() {\n self.pos += 1;\n if buf[self.pos - 1] > 32 {\n return buf[self.pos - 1];\n }\n }\n if self.pos == 0 {\n return 0;\n }\n } else {\n return 0;\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n}\n\nimpl<R: BufRead> TokenStream<Vec<u8>> for FastInput<R> {\n fn token(&mut self) -> Vec<u8> {\n let mut ans = Vec::new();\n let mut parse_token = false;\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n if !parse_token {\n while self.pos < buf.len() && buf[self.pos] <= 32 {\n self.pos += 1;\n }\n }\n while self.pos < buf.len() && buf[self.pos] > 32 {\n parse_token = true;\n ans.push(buf[self.pos]);\n self.pos += 1;\n }\n if self.pos != buf.len() || self.pos == 0 {\n return ans;\n }\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n}\n\nmacro_rules! impl_token_stream {\n ($($t:ident),+) => {$(\n impl<R: BufRead> TokenStream<$t> for FastInput<R> {\n fn token(&mut self) -> $t {\n let mut ans = 0;\n let mut parse_token = false;\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n if !parse_token {\n while self.pos < buf.len() && buf[self.pos] <= 32 {\n self.pos += 1;\n }\n }\n while self.pos < buf.len() && buf[self.pos] > 32 {\n parse_token = true;\n ans = ans * 10 + (buf[self.pos] - b'0') as $t;\n self.pos += 1;\n }\n if self.pos != buf.len() || self.pos == 0 {\n return ans;\n }\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n }\n )+}\n}\n\nimpl_token_stream!(usize);\n", "lang_cluster": "Rust", "compilation_error": true, "code_uid": "774ae6f349debd587b6ab33372181ab6", "src_uid": "e52ec2fa5bcf5d2027d57b0694b4e15a", "difficulty": 1900}
- {"lang": "Rust", "source_code": "#![allow(unused_variables)]\n#![allow(unused_must_use)]\n#![allow(unused_imports)]\nuse std::collections::BinaryHeap;\nuse std::collections::BTreeSet;\nuse std::collections::HashMap;\nuse std::collections::HashSet;\nuse std::io::{self, prelude::*};\nuse std::cmp::{min,max};\nuse std::cmp::Reverse;\n\n\n\n#[derive(Debug, Ord, Eq, PartialEq, PartialOrd)]\nenum Edge {\n Normal,\n Offer,\n} \n\nfn collapse(x: &usize, uf: &mut Vec<usize>) {\n let mut xs = vec![];\n let mut y = *x;\n\n while uf[y] != y {\n xs.push(y);\n y = uf[y];\n }\n\n for i in 0..xs.len() {\n uf[xs[i]] = y;\n }\n}\n\nfn solve<R: BufRead, W: Write>(mut input: FastInput<R>, mut w: W) {\n let n: usize = input.token();\n let m: usize = input.token();\n\n let mut vs = vec![];\n let mut uf = vec![];\n let mut indexes = HashMap::new();\n let mut components = n;\n\n for i in 0..n {\n let ai: usize = input.token();\n vs.push((ai, i));\n uf.push(i);\n }\n\n vs.sort();\n\n for i in 0..n {\n indexes.insert(vs[i].1, i);\n }\n\n let mut es = vec![];\n\n for i in 0..m {\n let a: usize = input.token();\n let b: usize = input.token();\n let w: usize = input.token();\n if vs[indexes[&(a - 1)]].0 + vs[indexes[&(b - 1)]].0 > w {\n es.push((w, a - 1, b - 1));\n }\n }\n\n let mut heap = BinaryHeap::new();\n\n for i in 0..es.len() {\n heap.push(Reverse((es[i].0, es[i].1, es[i].2, Edge::Offer)));\n }\n\n for i in 1..n {\n heap.push(Reverse((vs[0].0 + vs[i].0 , vs[i].1, vs[0].1, Edge::Normal)));\n }\n\n let mut total_cost = 0;\n\n while let Some(Reverse((v, x, y, t))) = heap.pop() {\n // println!(\"Processing {}-{} ({}, {:?})\", x, y, v, t);\n collapse(&x, &mut uf);\n collapse(&y, &mut uf);\n if uf[y] == uf[x] {\n continue;\n }\n uf[y] = min(uf[x], uf[y]);\n uf[x] = min(uf[x], uf[y]);\n components -= 1;\n total_cost += v;\n \n if components == 1 {\n break;\n }\n\n if t == Edge::Normal {\n let new_y = vs[indexes[&y] + 1].1;\n let new_v = vs[indexes[&new_y]].0 + vs[indexes[&x]].0;\n // println!(\"New y is {}, new value is {}\", new_y, new_v);\n heap.push(Reverse((new_v, x, new_y, Edge::Normal)));\n }\n }\n\n write!(w, \"{}\\n\", total_cost);\n}\n\nfn main() {\n let stdin = io::stdin();\n let stdout = io::stdout();\n let input = FastInput::from(stdin.lock());\n let writer = io::BufWriter::new(stdout.lock());\n solve(input, writer);\n}\n\ntrait TokenStream<T> {\n fn token(&mut self) -> T;\n}\n\nstruct FastInput<R> {\n stdin: R,\n pos: usize,\n}\n\nimpl<R: BufRead> From<R> for FastInput<R> {\n fn from(r: R) -> Self {\n FastInput { stdin: r, pos: 0 }\n }\n}\n\nimpl<R: BufRead> TokenStream<u8> for FastInput<R> {\n fn token(&mut self) -> u8 {\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n while self.pos < buf.len() {\n self.pos += 1;\n if buf[self.pos - 1] > 32 {\n return buf[self.pos - 1];\n }\n }\n if self.pos == 0 {\n return 0;\n }\n } else {\n return 0;\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n}\n\nimpl<R: BufRead> TokenStream<Vec<u8>> for FastInput<R> {\n fn token(&mut self) -> Vec<u8> {\n let mut ans = Vec::new();\n let mut parse_token = false;\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n if !parse_token {\n while self.pos < buf.len() && buf[self.pos] <= 32 {\n self.pos += 1;\n }\n }\n while self.pos < buf.len() && buf[self.pos] > 32 {\n parse_token = true;\n ans.push(buf[self.pos]);\n self.pos += 1;\n }\n if self.pos != buf.len() || self.pos == 0 {\n return ans;\n }\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n}\n\nmacro_rules! impl_token_stream {\n ($($t:ident),+) => {$(\n impl<R: BufRead> TokenStream<$t> for FastInput<R> {\n fn token(&mut self) -> $t {\n let mut ans = 0;\n let mut parse_token = false;\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n if !parse_token {\n while self.pos < buf.len() && buf[self.pos] <= 32 {\n self.pos += 1;\n }\n }\n while self.pos < buf.len() && buf[self.pos] > 32 {\n parse_token = true;\n ans = ans * 10 + (buf[self.pos] - b'0') as $t;\n self.pos += 1;\n }\n if self.pos != buf.len() || self.pos == 0 {\n return ans;\n }\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n }\n )+}\n}\n\nimpl_token_stream!(usize);\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "6001af463b447143b982d72e3cf895e5", "src_uid": "e52ec2fa5bcf5d2027d57b0694b4e15a", "difficulty": 1900}
- {"lang": "Rust", "source_code": "#![allow(unused_variables)]\n#![allow(unused_must_use)]\n#![allow(unused_imports)]\nuse std::collections::BinaryHeap;\nuse std::collections::BTreeSet;\nuse std::collections::HashMap;\nuse std::collections::HashSet;\nuse std::io::{self, prelude::*};\nuse std::cmp::{min,max};\nuse std::cmp::Reverse;\n\n\n\n\nfn collapse(x: &usize, uf: &mut Vec<usize>) {\n let mut xs = vec![];\n let mut y = *x;\n\n while uf[y] != y {\n xs.push(y);\n y = uf[y];\n }\n\n for i in 0..xs.len() {\n uf[xs[i]] = y;\n }\n}\n\nfn solve<R: BufRead, W: Write>(mut input: FastInput<R>, mut w: W) {\n let n: usize = input.token();\n let m: usize = input.token();\n\n let mut vs = vec![];\n let mut uf = vec![];\n let mut components = n;\n\n for i in 0..n {\n let ai: usize = input.token();\n vs.push((ai, i));\n uf.push(i);\n }\n\n vs.sort();\n\n\n let mut es = vec![];\n\n for i in 0..m {\n let a: usize = input.token();\n let b: usize = input.token();\n let w: usize = input.token();\n es.push((w, a - 1, b - 1));\n }\n\n let mut heap = BinaryHeap::new();\n\n for i in 0..es.len() {\n heap.push(Reverse((es[i].0, es[i].1, es[i].2)));\n }\n\n for i in 1..n {\n heap.push(Reverse((vs[0].0 + vs[i].0, vs[i].1, vs[0].1)));\n }\n\n let mut total_cost = 0;\n\n while let Some(Reverse((v, x, y))) = heap.pop() {\n // println!(\"Processing {}-{} ({})\", x, y, v);\n collapse(&x, &mut uf);\n collapse(&y, &mut uf);\n if uf[y] == uf[x] {\n // println!(\"skip\");\n continue;\n }\n /*\n for i in 0..n {\n print!(\"({} -> {})\", i, uf[i]);\n }\n println!(\"\");\n */\n let z = uf[y];\n uf[z] = uf[x];\n uf[y] = uf[x];\n components -= 1;\n total_cost += v;\n \n if components == 1 {\n break;\n }\n }\n\n write!(w, \"{}\\n\", total_cost);\n}\n\nfn main() {\n let stdin = io::stdin();\n let stdout = io::stdout();\n let input = FastInput::from(stdin.lock());\n let writer = io::BufWriter::new(stdout.lock());\n solve(input, writer);\n}\n\ntrait TokenStream<T> {\n fn token(&mut self) -> T;\n}\n\nstruct FastInput<R> {\n stdin: R,\n pos: usize,\n}\n\nimpl<R: BufRead> From<R> for FastInput<R> {\n fn from(r: R) -> Self {\n FastInput { stdin: r, pos: 0 }\n }\n}\n\nimpl<R: BufRead> TokenStream<u8> for FastInput<R> {\n fn token(&mut self) -> u8 {\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n while self.pos < buf.len() {\n self.pos += 1;\n if buf[self.pos - 1] > 32 {\n return buf[self.pos - 1];\n }\n }\n if self.pos == 0 {\n return 0;\n }\n } else {\n return 0;\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n}\n\nimpl<R: BufRead> TokenStream<Vec<u8>> for FastInput<R> {\n fn token(&mut self) -> Vec<u8> {\n let mut ans = Vec::new();\n let mut parse_token = false;\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n if !parse_token {\n while self.pos < buf.len() && buf[self.pos] <= 32 {\n self.pos += 1;\n }\n }\n while self.pos < buf.len() && buf[self.pos] > 32 {\n parse_token = true;\n ans.push(buf[self.pos]);\n self.pos += 1;\n }\n if self.pos != buf.len() || self.pos == 0 {\n return ans;\n }\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n}\n\nmacro_rules! impl_token_stream {\n ($($t:ident),+) => {$(\n impl<R: BufRead> TokenStream<$t> for FastInput<R> {\n fn token(&mut self) -> $t {\n let mut ans = 0;\n let mut parse_token = false;\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n if !parse_token {\n while self.pos < buf.len() && buf[self.pos] <= 32 {\n self.pos += 1;\n }\n }\n while self.pos < buf.len() && buf[self.pos] > 32 {\n parse_token = true;\n ans = ans * 10 + (buf[self.pos] - b'0') as $t;\n self.pos += 1;\n }\n if self.pos != buf.len() || self.pos == 0 {\n return ans;\n }\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n }\n )+}\n}\n\nimpl_token_stream!(usize);\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "a357270b40a9dc77497979ce6049a1f0", "src_uid": "e52ec2fa5bcf5d2027d57b0694b4e15a", "difficulty": 1900}
- {"lang": "Rust", "source_code": "#![allow(unused_variables)]\n#![allow(unused_must_use)]\n#![allow(unused_imports)]\nuse std::collections::BinaryHeap;\nuse std::collections::BTreeSet;\nuse std::collections::HashMap;\nuse std::collections::HashSet;\nuse std::io::{self, prelude::*};\nuse std::cmp::{min,max};\nuse std::cmp::Reverse;\n\n\n\n\nfn collapse(x: &usize, uf: &mut Vec<usize>) {\n let mut xs = vec![];\n let mut y = *x;\n\n while uf[y] != y {\n xs.push(y);\n y = uf[y];\n }\n\n for i in 0..xs.len() {\n uf[xs[i]] = y;\n }\n}\n\nfn solve<R: BufRead, W: Write>(mut input: FastInput<R>, mut w: W) {\n let n: usize = input.token();\n let m: usize = input.token();\n\n let mut vs = vec![];\n let mut uf = vec![];\n let mut components = n;\n\n for i in 0..n {\n let ai: usize = input.token();\n vs.push((ai, i));\n uf.push(i);\n }\n\n vs.sort();\n\n\n let mut es = vec![];\n\n for i in 0..m {\n let a: usize = input.token();\n let b: usize = input.token();\n let w: usize = input.token();\n es.push((w, a - 1, b - 1));\n }\n\n let mut heap = BinaryHeap::new();\n\n for i in 0..es.len() {\n heap.push(Reverse((es[i].0, es[i].1, es[i].2)));\n }\n\n for i in 1..n {\n heap.push(Reverse((vs[0].0 + vs[i].0, vs[i].1, vs[0].1)));\n }\n\n let mut total_cost: i64 = 0;\n\n while let Some(Reverse((v, x, y))) = heap.pop() {\n // println!(\"Processing {}-{} ({})\", x, y, v);\n collapse(&x, &mut uf);\n collapse(&y, &mut uf);\n if uf[y] == uf[x] {\n // println!(\"skip\");\n continue;\n }\n /*\n for i in 0..n {\n print!(\"({} -> {})\", i, uf[i]);\n }\n println!(\"\");\n */\n let z = uf[y];\n uf[z] = uf[x];\n uf[z] = uf[x];\n components -= 1;\n total_cost += v as i64;\n \n if components == 1 {\n break;\n }\n }\n\n write!(w, \"{}\\n\", total_cost);\n}\n\nfn main() {\n let stdin = io::stdin();\n let stdout = io::stdout();\n let input = FastInput::from(stdin.lock());\n let writer = io::BufWriter::new(stdout.lock());\n solve(input, writer);\n}\n\ntrait TokenStream<T> {\n fn token(&mut self) -> T;\n}\n\nstruct FastInput<R> {\n stdin: R,\n pos: usize,\n}\n\nimpl<R: BufRead> From<R> for FastInput<R> {\n fn from(r: R) -> Self {\n FastInput { stdin: r, pos: 0 }\n }\n}\n\nimpl<R: BufRead> TokenStream<u8> for FastInput<R> {\n fn token(&mut self) -> u8 {\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n while self.pos < buf.len() {\n self.pos += 1;\n if buf[self.pos - 1] > 32 {\n return buf[self.pos - 1];\n }\n }\n if self.pos == 0 {\n return 0;\n }\n } else {\n return 0;\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n}\n\nimpl<R: BufRead> TokenStream<Vec<u8>> for FastInput<R> {\n fn token(&mut self) -> Vec<u8> {\n let mut ans = Vec::new();\n let mut parse_token = false;\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n if !parse_token {\n while self.pos < buf.len() && buf[self.pos] <= 32 {\n self.pos += 1;\n }\n }\n while self.pos < buf.len() && buf[self.pos] > 32 {\n parse_token = true;\n ans.push(buf[self.pos]);\n self.pos += 1;\n }\n if self.pos != buf.len() || self.pos == 0 {\n return ans;\n }\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n}\n\nmacro_rules! impl_token_stream {\n ($($t:ident),+) => {$(\n impl<R: BufRead> TokenStream<$t> for FastInput<R> {\n fn token(&mut self) -> $t {\n let mut ans = 0;\n let mut parse_token = false;\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n if !parse_token {\n while self.pos < buf.len() && buf[self.pos] <= 32 {\n self.pos += 1;\n }\n }\n while self.pos < buf.len() && buf[self.pos] > 32 {\n parse_token = true;\n ans = ans * 10 + (buf[self.pos] - b'0') as $t;\n self.pos += 1;\n }\n if self.pos != buf.len() || self.pos == 0 {\n return ans;\n }\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n }\n )+}\n}\n\nimpl_token_stream!(usize);\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "bc9ed7e6f30546f73d1d231d0980f44b", "src_uid": "e52ec2fa5bcf5d2027d57b0694b4e15a", "difficulty": 1900}
- {"lang": "Rust", "source_code": "#![allow(unused_variables)]\n#![allow(unused_must_use)]\n#![allow(unused_imports)]\nuse std::collections::BinaryHeap;\nuse std::collections::BTreeSet;\nuse std::collections::HashMap;\nuse std::collections::HashSet;\nuse std::io::{self, prelude::*};\nuse std::cmp::{min,max};\nuse std::cmp::Reverse;\n\n\n\n\nfn collapse(x: &usize, uf: &mut Vec<usize>) {\n let mut xs = vec![];\n let mut y = *x;\n\n while uf[y] != y {\n xs.push(y);\n y = uf[y];\n }\n\n for i in 0..xs.len() {\n uf[xs[i]] = y;\n }\n}\n\nfn solve<R: BufRead, W: Write>(mut input: FastInput<R>, mut w: W) {\n let n: usize = input.token();\n let m: usize = input.token();\n\n let mut vs = vec![];\n let mut uf = vec![];\n let mut indexes = HashMap::new();\n let mut components = n;\n\n for i in 0..n {\n let ai: usize = input.token();\n vs.push((ai, i));\n uf.push(i);\n }\n\n vs.sort();\n\n for i in 0..n {\n indexes.insert(vs[i].1, i);\n }\n\n let mut es = vec![];\n\n for i in 0..m {\n let a: usize = input.token();\n let b: usize = input.token();\n let w: usize = input.token();\n if vs[indexes[&(a - 1)]].0 + vs[indexes[&(b - 1)]].0 > w {\n es.push((w, a - 1, b - 1));\n }\n }\n\n let mut heap = BinaryHeap::new();\n\n for i in 0..es.len() {\n heap.push(Reverse((es[i].0, es[i].1, es[i].2)));\n }\n\n for i in 1..n {\n heap.push(Reverse((vs[0].0 + vs[i].0, vs[i].1, vs[0].1)));\n }\n\n let mut total_cost = 0;\n\n while let Some(Reverse((v, x, y))) = heap.pop() {\n // println!(\"Processing {}-{} ({})\", x, y, v);\n collapse(&x, &mut uf);\n collapse(&y, &mut uf);\n if uf[y] == uf[x] {\n // println!(\"skip\");\n continue;\n }\n /*\n for i in 0..n {\n print!(\"({} -> {})\", i, uf[i]);\n }\n println!(\"\");\n */\n let z = uf[y];\n uf[z] = uf[x];\n components -= 1;\n total_cost += v;\n \n if components == 1 {\n break;\n }\n }\n\n write!(w, \"{}\\n\", total_cost);\n}\n\nfn main() {\n let stdin = io::stdin();\n let stdout = io::stdout();\n let input = FastInput::from(stdin.lock());\n let writer = io::BufWriter::new(stdout.lock());\n solve(input, writer);\n}\n\ntrait TokenStream<T> {\n fn token(&mut self) -> T;\n}\n\nstruct FastInput<R> {\n stdin: R,\n pos: usize,\n}\n\nimpl<R: BufRead> From<R> for FastInput<R> {\n fn from(r: R) -> Self {\n FastInput { stdin: r, pos: 0 }\n }\n}\n\nimpl<R: BufRead> TokenStream<u8> for FastInput<R> {\n fn token(&mut self) -> u8 {\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n while self.pos < buf.len() {\n self.pos += 1;\n if buf[self.pos - 1] > 32 {\n return buf[self.pos - 1];\n }\n }\n if self.pos == 0 {\n return 0;\n }\n } else {\n return 0;\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n}\n\nimpl<R: BufRead> TokenStream<Vec<u8>> for FastInput<R> {\n fn token(&mut self) -> Vec<u8> {\n let mut ans = Vec::new();\n let mut parse_token = false;\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n if !parse_token {\n while self.pos < buf.len() && buf[self.pos] <= 32 {\n self.pos += 1;\n }\n }\n while self.pos < buf.len() && buf[self.pos] > 32 {\n parse_token = true;\n ans.push(buf[self.pos]);\n self.pos += 1;\n }\n if self.pos != buf.len() || self.pos == 0 {\n return ans;\n }\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n}\n\nmacro_rules! impl_token_stream {\n ($($t:ident),+) => {$(\n impl<R: BufRead> TokenStream<$t> for FastInput<R> {\n fn token(&mut self) -> $t {\n let mut ans = 0;\n let mut parse_token = false;\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n if !parse_token {\n while self.pos < buf.len() && buf[self.pos] <= 32 {\n self.pos += 1;\n }\n }\n while self.pos < buf.len() && buf[self.pos] > 32 {\n parse_token = true;\n ans = ans * 10 + (buf[self.pos] - b'0') as $t;\n self.pos += 1;\n }\n if self.pos != buf.len() || self.pos == 0 {\n return ans;\n }\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n }\n )+}\n}\n\nimpl_token_stream!(usize);\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "30031a2d79e2be68fcee9570a0bca6dd", "src_uid": "e52ec2fa5bcf5d2027d57b0694b4e15a", "difficulty": 1900}
- {"lang": "Rust", "source_code": "#[allow(unused_imports)]\nuse std::cmp::{min,max};\n//const INF: i32 = 0x3f3f3f3f;\n\nstruct Scanner {\n buffer: std::collections::VecDeque<String>\n}\n\nimpl Scanner {\n fn new() -> Scanner {\n Scanner {\n buffer: std::collections::VecDeque::new()\n }\n }\n\n fn next<T: std::str::FromStr>(&mut self) -> T {\n while self.buffer.is_empty() {\n let mut input = String::new();\n std::io::stdin().read_line(&mut input).ok();\n self.buffer = input.split_whitespace()\n .map(ToString::to_string).collect();\n }\n let front = self.buffer.pop_front().unwrap();\n front.parse::<T>().ok().unwrap()\n }\n}\n\n/// Data structure for Knuth-Morris-Pratt string matching against a pattern.\npub struct Matcher<'a> {\n /// The string pattern to search for.\n pub pattern: &'a [i32],\n /// KMP match failure automaton. fail[i] is the length of the longest\n /// proper prefix-suffix of pattern[0...i].\n pub fail: Vec<usize>,\n}\n\nimpl<'a> Matcher<'a> {\n /// Precomputes the automaton that allows linear-time string matching.\n ///\n /// # Panics\n ///\n /// Panics if pattern is empty.\n pub fn new(pattern: &'a [i32]) -> Self {\n let mut fail = Vec::with_capacity(pattern.len());\n fail.push(0);\n let mut len = 0;\n for &ch in &pattern[1..] {\n while len > 0 && pattern[len] != ch {\n len = fail[len - 1];\n }\n if pattern[len] == ch {\n len += 1;\n }\n fail.push(len);\n }\n Self { pattern, fail }\n }\n\n /// KMP algorithm, sets matches[i] = length of longest prefix of pattern\n /// matching a suffix of text[0...i].\n pub fn kmp_match(&self, text: &[i32]) -> bool {\n let mut len = 0;\n for &ch in text {\n if len == self.pattern.len() {\n len = self.fail[len - 1];\n }\n while len > 0 && self.pattern[len] != ch {\n len = self.fail[len - 1];\n }\n if self.pattern[len] == ch {\n len += 1;\n }\n if len == self.pattern.len() {\n return true;\n }\n }\n return false;\n }\n}\n\nfn main1() {\n let mut scan = Scanner::new();\n let n = scan.next::<i32>();\n let m = scan.next::<usize>();\n let mut adj = vec![vec![]; n as usize];\n for _ in 0..m {\n let a = scan.next::<i32>() - 1;\n let b = scan.next::<i32>() - 1;\n adj[a as usize].push((b - a + n) % n);\n adj[b as usize].push((a - b + n) % n);\n }\n \n let mut pat = vec![];\n for mut jumps in adj {\n pat.push(0);\n jumps.sort_unstable();\n pat.extend(jumps);\n }\n let mut pat2 = pat.clone();\n pat2.extend(pat.clone());\n pat2.pop();\n \n let symmetric = Matcher::new(&pat).kmp_match(&pat2[1..]);\n if symmetric {\n print!(\"Yes\");\n } else {\n print!(\"No\");\n }\n}\n\nfn main() {\n std::thread::Builder::new().stack_size(50 << 20)\n .spawn(main1).unwrap().join().unwrap();\n}", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "597f36f07770c326e1493fb84eac1c1a", "src_uid": "dd7a7a4e5feb50ab6abb93d90c559c2b", "difficulty": 1900}
- {"lang": "Rust", "source_code": "#[allow(unused_imports)]\nuse std::cmp::*;\n#[allow(unused_imports)]\nuse std::collections::*;\nuse std::io::{Read, BufWriter, Write};\n#[allow(dead_code)]\nfn getline() -> String {\n let mut ret = String::new();\n std::io::stdin().read_line(&mut ret).ok().unwrap();\n ret\n}\nfn get_word() -> String {\n let mut stdin = std::io::stdin();\n let mut u8b: [u8; 1] = [0];\n loop {\n let mut buf: Vec<u8> = Vec::with_capacity(16);\n loop {\n let res = stdin.read(&mut u8b);\n if res.unwrap_or(0) == 0 || u8b[0] <= b' ' {\n break;\n } else {\n buf.push(u8b[0]);\n }\n }\n if buf.len() >= 1 {\n let ret = String::from_utf8(buf).unwrap();\n return ret;\n }\n }\n}\n\n#[allow(dead_code)]\nfn get<T: std::str::FromStr>() -> T { get_word().parse().ok().unwrap() }\n\nconst INF: i64 = 1 << 53;\n\nfn solve() {\n let n = get();\n let mut a: Vec<i64> = (0 .. n).map(|_| get()).collect();\n a.insert(0, -INF);\n a.push(-INF);\n let mut dp = vec![vec![vec![INF; n + 1]; n + 1]; 2];\n dp[0][0][0] = 0;\n for i in 1 .. n + 1 {\n let cost =\n max(0, a[i - 1] - a[i] + 1) + max(0, a[i + 1] - a[i] + 1);\n let cost2 = if i >= 2 {\n -max(0, a[i - 1] - a[i - 2] + 1) + max(0, a[i - 1] - min(a[i], a[i - 2]) + 1) + max(0, a[i + 1] - a[i] + 1)\n } else {\n INF\n };\n for j in 0 .. n + 1 {\n dp[0][i][j] = min(dp[0][i][j], min(dp[0][i - 1][j], dp[1][i - 1][j]));\n if j > 0 {\n dp[1][i][j] = min(dp[1][i][j], dp[0][i - 1][j - 1] + cost);\n if i >= 2 {\n dp[1][i][j] = min(dp[1][i][j], dp[1][i - 2][j - 1] + cost2);\n }\n }\n }\n }\n let mut ans = vec![INF; n + 1];\n for i in 0 .. n + 1 {\n ans[i] = min(dp[0][n][i], dp[1][n][i]);\n }\n let stdout = std::io::stdout();\n let mut stdout = BufWriter::new(stdout.lock());\n for i in 1 .. (n + 1) / 2 + 1 {\n write!(stdout, \"{}{}\", ans[i], if i == (n + 1) / 2 { \"\\n\" } else { \" \" }).unwrap();\n }\n}\n\nfn main() {\n // In order to avoid potential stack overflow, spawn a new thread.\n let stack_size = 104_857_600; // 100 MB\n let thd = std::thread::Builder::new().stack_size(stack_size);\n thd.spawn(|| solve()).unwrap().join().unwrap();\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "f9038f5d60c3531ce8031537d3614ac2", "src_uid": "9534b468bfb6126fc16b896532ced8c5", "difficulty": 1900}
- {"lang": "Rust", "source_code": "pub fn read_num() -> Vec<i32> {\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n\n line.split_whitespace()\n .map(|s| s.parse().unwrap())\n .collect()\n }\n\nfn main() {\n\tlet mut line = String::new();\n\n let nk = read_num();\n\tlet mut arr = read_num();\n\n\tarr.sort();\n\tarr.truncate(nk[1] as usize);\n\t\n\tlet ans: i32 = arr.iter().sum();\n\n\tprintln!(\"{}\", ans);\n}", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "207738b355eb44b08f0c2d06dab83aec", "src_uid": "5097e92916e49cdc6fb4953b864186db", "difficulty": 1200}
- {"lang": "Rust", "source_code": "#![allow(unused_imports)]\n#![allow(non_snake_case)]\n#![allow(non_shorthand_field_patterns)]\n\nuse std::cmp::{max, min, Ordering};\nuse std::collections::*;\nuse std::fmt::{Debug, Formatter};\nuse std::io::*;\nuse std::ops::*;\nuse std::rc::Rc;\nuse std::*;\n\n// -----------------------------------------------\n// Framework\n// -----------------------------------------------\n\n#[allow(unused_macros)]\nmacro_rules! read {\n ([$t:ty] ; $n:expr) =>\n ((0..$n).map(|_| read!([$t])).collect::<Vec<_>>());\n ($($t:ty),+ ; $n:expr) =>\n ((0..$n).map(|_| read!($($t),+)).collect::<Vec<_>>());\n ([$t:ty]) =>\n (rl().split_whitespace().map(|w| w.parse().unwrap()).collect::<Vec<$t>>());\n ($t:ty) =>\n (rl().parse::<$t>().unwrap());\n ($($t:ty),*) => {{\n let buf = rl();\n let mut w = buf.split_whitespace();\n ($(w.next().unwrap().parse::<$t>().unwrap()),*)\n }};\n}\n\n#[allow(unused_macros)]\nmacro_rules! debug {\n ($($arg:expr),*) => {\n #[cfg(debug_assertions)]\n {\n let entries = [$(&stringify!([$arg]:), &$arg as &Debug),*];\n stderr().write_fmt(format_args!(\"{:#?}\\n\", entries)).unwrap();\n }\n };\n}\n\n#[allow(dead_code)]\nfn rl() -> String {\n let mut buf = String::new();\n io::stdin().read_line(&mut buf).unwrap();\n buf.trim_right().to_owned()\n}\n\ntrait IteratorExt: Iterator + Sized {\n fn vec(self) -> Vec<Self::Item> {\n self.collect()\n }\n}\n\nimpl<T: Iterator> IteratorExt for T {}\n\n// -----------------------------------------------\n// Solution\n// -----------------------------------------------\n\n#[derive(Clone, Copy, Debug)]\nstruct Query {\n t: usize,\n x: usize,\n y: usize,\n}\n\n// \u5ea7\u6a19\u5727\u7e2e\u5f8c\u306e\u6570\u5217\u306e\u5024\u306e\u6700\u5927\u5024\nconst N: usize = 200000;\n\n// \u30d0\u30b1\u30c3\u30c8\u306e\u30b5\u30a4\u30ba (~~ N^(2/3))\nconst SZ: usize = 2100;\n\n// \u30d0\u30b1\u30c3\u30c8\u6570\u306e\u6700\u5927\u5024 (>= N/SZ)\nconst B: usize = 60;\n\nstruct Solver {\n /// \u66f4\u65b0\u30af\u30a8\u30ea\u30fc\u3092t\u500b\u5b9f\u884c\u3057\u305f\u5f8c\u306e\u533a\u9593 [x, y] \u306e mex \u3092\u7b54\u3048\u308b\u30af\u30a8\u30ea\u30fc\n mex_query: Vec<Query>,\n /// t\u756a\u76ee\u306e\u8981\u7d20\u3092x\u304b\u3089y\u306b\u5909\u66f4\u3059\u308b\u30af\u30a8\u30ea\u30fc\n ch_query: Vec<Query>,\n /// T\u500b\u306e\u30af\u30a8\u30ea\u30fc\u306e\u5b9f\u884c\u5f8c\u306b\u304a\u3051\u308b\u533a\u9593 [L, R] \u306b\u6ce8\u76ee\u3057\u3066\u3044\u308b\u3053\u3068\u3092\u8868\u3059\u3002\n T: isize,\n L: isize,\n R: isize,\n /// ct[a] = \u6570\u5024 a \u304c\u73fe\u5728\u306e\u533a\u9593\u306b\u73fe\u308c\u308b\u56de\u6570\n ct: Vec<usize>,\n /// sz[k] = \u73fe\u5728\u306e\u533a\u9593\u306b\u304a\u3044\u3066\u3001\u3061\u3087\u3046\u3069 k \u56de\u51fa\u73fe\u3059\u308b\u6570\u5024\u306e\u500b\u6570\n sz: Vec<i32>,\n /// \u73fe\u5728\u306e(T\u500b\u306e\u30af\u30a8\u30ea\u30fc\u306e\u5b9f\u884c\u5f8c\u306e)\u6570\u5217\n a: Vec<usize>,\n mx: Vec<Vec<HashSet<(usize, usize)>>>,\n}\n\nimpl Solver {\n pub fn new() -> Solver {\n Solver {\n mex_query: Vec::new(),\n ch_query: Vec::new(),\n ct: vec![0; N],\n sz: vec![0; N],\n a: Vec::new(),\n L: 0,\n R: -1,\n T: -1,\n mx: vec![vec![HashSet::new(); B]; B],\n }\n }\n\n // R += 1\n pub fn pr(&mut self) {\n self.R += 1;\n let R = self.R as usize;\n\n // \u533a\u9593\u306b\u8ffd\u52a0\u3055\u308c\u308b\u8981\u7d20\n let a = self.a[R];\n\n // \u66f4\u65b0\u524d\u306b\u3001a \u304c\u533a\u9593\u5185\u306b\u51fa\u73fe\u3057\u3066\u3044\u305f\u56de\u6570\n let k = self.ct[a];\n\n // a \u306e\u51fa\u73fe\u3059\u308b\u56de\u6570\u306f1\u56de\u5897\u3048\u308b\u3002\n self.ct[a] += 1;\n\n // \u300ck \u56de\u51fa\u73fe\u3059\u308b\u6570\u5024\u300d\u306f a \u304c\u6d88\u3048\u30661\u6e1b\u308a\u3001(k + 1) \u56de\u3003\u306fa\u304c\u52a0\u308f\u3063\u30661\u5897\u3048\u308b\u3002\n self.sz[k] -= 1;\n self.sz[k + 1] += 1;\n }\n\n // \u4e0a\u3068\u540c\u69d8\u3002a\u306e\u51fa\u73fe\u3059\u308b\u56de\u6570\u306f\u6e1b\u308b\u3002\n pub fn pl(&mut self) {\n let a = self.a[self.L as usize];\n\n self.sz[self.ct[a]] -= 1;\n self.ct[a] -= 1;\n self.sz[self.ct[a]] += 1;\n\n self.L += 1;\n }\n\n pub fn mr(&mut self) {\n assert!(self.R >= 0);\n let R = self.R as usize;\n\n let a = self.a[R];\n self.sz[self.ct[a]] -= 1;\n self.ct[a] -= 1;\n self.sz[self.ct[a]] += 1;\n\n self.R -= 1;\n }\n\n pub fn ml(&mut self) {\n assert!(self.L >= 1);\n\n let a = self.a[self.L as usize];\n self.sz[self.ct[a]] -= 1;\n self.ct[a] += 1;\n self.sz[self.ct[a]] += 1;\n\n self.L -= 1;\n }\n\n fn update(&mut self, i: usize, x: usize, y: usize) {\n // i \u756a\u76ee\u306e\u8981\u7d20\u3092 x \u304b\u3089 y\u306b\u5909\u66f4\u3059\u308b\n assert!(self.a[i] == x);\n\n if self.in_focus(i) {\n // x \u306e\u51fa\u73fe\u3059\u308b\u56de\u6570\u304c\u6e1b\u308b\n let a = self.a[i];\n self.sz[self.ct[a]] -= 1;\n self.ct[a] -= 1;\n self.sz[self.ct[a]] += 1;\n }\n\n self.a[i] = y;\n\n if self.in_focus(i) {\n // y \u306e\u51fa\u73fe\u3059\u308b\u56de\u6570\u304c\u6e1b\u308b\n let a = self.a[i];\n self.sz[self.ct[a]] -= 1;\n self.ct[a] += 1;\n self.sz[self.ct[a]] += 1;\n }\n }\n\n // T += 1\n pub fn pt(&mut self) {\n self.T += 1;\n let Query { t: i, x, y } = self.ch_query[self.T as usize];\n self.update(i, x, y);\n }\n\n /// T -= 1\n pub fn mt(&mut self) {\n let Query { t: i, x, y } = self.ch_query[self.T as usize];\n self.update(i, y, x);\n self.T -= 1;\n }\n\n /// \u6307\u5b9a\u3055\u308c\u305f\u4f4d\u7f6e\u304c\u73fe\u5728\u306e\u533a\u9593\u306b\u542b\u307e\u308c\u3066\u3044\u308b\u304b\uff1f\n pub fn in_focus(&self, i: usize) -> bool {\n self.L <= i as isize && i as isize <= self.R\n }\n\n /// \u73fe\u5728\u306e\u533a\u9593\u306e mex \u3092\u8a08\u7b97\u3059\u308b\u3002O(\u221aN)\n pub fn mex(&self) -> usize {\n let mut k = 1;\n loop {\n if self.sz[k] == 0 {\n return k;\n }\n k += 1;\n }\n }\n\n pub fn entry_point(mut self) {\n let (_, QN) = read!(usize, usize);\n let A = read![[i64]];\n let Q = read![i32, i64, i64; QN];\n\n let mut compressor = HashMap::with_capacity(N);\n let mut sigma = |a: i64| {\n let m = compressor.len();\n let e = compressor.entry(a).or_insert(m);\n *e\n };\n\n let A = A.iter().map(|&a| sigma(a)).vec();\n self.a = A.clone();\n let mut TA = A;\n\n for i in 0..QN {\n let (t, l, r) = Q[i];\n\n if t == 1 {\n let l = (l - 1) as usize;\n let r = (r - 1) as usize;\n\n self.mex_query.push(Query {\n t: self.ch_query.len(),\n x: l,\n y: r,\n });\n } else {\n let l = (l - 1) as usize;\n let (x, y) = (TA[l], sigma(r));\n self.ch_query.push(Query {\n t: l as usize,\n x: x,\n y: y,\n });\n TA[l] = y;\n }\n }\n\n // \u30d6\u30ed\u30c3\u30af\u3054\u3068\u306b\u30af\u30a8\u30ea\u30fc\u3092\u5206\u985e\n let M = self.mex_query.len();\n for qi in 0..M {\n let Query { t, x, y } = self.mex_query[qi];\n let (i, j) = (t / SZ, x / SZ);\n self.mx[i][j].insert((y, qi));\n }\n\n let mut answers = vec![0; M];\n\n for i in 0..B {\n for j in 0..B {\n let mx = std::mem::replace(&mut self.mx[i][j], HashSet::default());\n for (_, qi) in mx {\n let Query { t, x: l, y: r } = self.mex_query[qi];\n\n // (T, L, R) \u3092\u4e0e\u3048\u3089\u308c\u305f (t, l, r) \u306b\u8fd1\u3065\u3051\u3066\u3044\u304f\u3002\n\n while self.R < r as isize {\n self.pr();\n }\n while self.R > r as isize {\n self.mr();\n }\n while self.L < l as isize {\n self.pl();\n }\n while self.L > l as isize {\n self.ml();\n }\n while ((self.T + 1) as usize) < t {\n self.pt();\n }\n while ((self.T + 1) as usize) > t {\n self.mt();\n }\n\n // assert!(\n // (self.T + 1) as usize == t && self.L == l as isize && self.R == r as isize\n // );\n\n // debug!(self.T, self.L, self.R, &self.ct[0..5], &self.sz[0..5]);\n\n answers[qi] = self.mex();\n }\n }\n }\n\n for mex in answers {\n println!(\"{}\", mex);\n }\n }\n}\n\npub fn main() {\n Solver::new().entry_point();\n}\n\n// problem\n// http://codeforces.com/contest/940/problem/F\n\n// ref [CF 940 F - Machine Learning - \u88cf\u7d19](http://imulan.hatenablog.jp/entry/2018/03/22/182619)\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "4ec9cbc2054331f42603b48f1cff01dc", "src_uid": "eb6362941b5186d20721c99fb4808d52", "difficulty": 2600}
- {"lang": "Rust", "source_code": "#![allow(unused_imports)]\n#![allow(non_snake_case)]\n#![allow(non_shorthand_field_patterns)]\n\nuse std::cmp::{max, min, Ordering};\nuse std::collections::*;\nuse std::fmt::{Debug, Formatter};\nuse std::io::*;\nuse std::ops::*;\nuse std::rc::Rc;\nuse std::*;\n\n// -----------------------------------------------\n// Framework\n// -----------------------------------------------\n\n#[allow(unused_macros)]\nmacro_rules! read {\n ([$t:ty] ; $n:expr) =>\n ((0..$n).map(|_| read!([$t])).collect::<Vec<_>>());\n ($($t:ty),+ ; $n:expr) =>\n ((0..$n).map(|_| read!($($t),+)).collect::<Vec<_>>());\n ([$t:ty]) =>\n (rl().split_whitespace().map(|w| w.parse().unwrap()).collect::<Vec<$t>>());\n ($t:ty) =>\n (rl().parse::<$t>().unwrap());\n ($($t:ty),*) => {{\n let buf = rl();\n let mut w = buf.split_whitespace();\n ($(w.next().unwrap().parse::<$t>().unwrap()),*)\n }};\n}\n\n#[allow(unused_macros)]\nmacro_rules! debug {\n ($($arg:expr),*) => {\n #[cfg(debug_assertions)]\n {\n let entries = [$(&stringify!([$arg]:), &$arg as &Debug),*];\n stderr().write_fmt(format_args!(\"{:#?}\\n\", entries)).unwrap();\n }\n };\n}\n\n#[allow(dead_code)]\nfn rl() -> String {\n let mut buf = String::new();\n io::stdin().read_line(&mut buf).unwrap();\n buf.trim_right().to_owned()\n}\n\ntrait IteratorExt: Iterator + Sized {\n fn vec(self) -> Vec<Self::Item> {\n self.collect()\n }\n}\n\nimpl<T: Iterator> IteratorExt for T {}\n\n// -----------------------------------------------\n// Solution\n// -----------------------------------------------\n\n#[derive(Clone, Copy, Debug)]\nstruct Query {\n t: usize,\n x: usize,\n y: usize,\n}\n\n// \u5ea7\u6a19\u5727\u7e2e\u5f8c\u306e\u6570\u5217\u306e\u5024\u306e\u6700\u5927\u5024\nconst N: usize = 200000;\n\n// \u30d0\u30b1\u30c3\u30c8\u306e\u30b5\u30a4\u30ba (~~ N^(2/3))\nconst SZ: usize = 2100;\n\n// \u30d0\u30b1\u30c3\u30c8\u6570\u306e\u6700\u5927\u5024 (>= N/SZ)\nconst B: usize = 60;\n\nstruct Solver {\n /// \u66f4\u65b0\u30af\u30a8\u30ea\u30fc\u3092t\u500b\u5b9f\u884c\u3057\u305f\u5f8c\u306e\u533a\u9593 [x, y] \u306e mex \u3092\u7b54\u3048\u308b\u30af\u30a8\u30ea\u30fc\n mex_query: Vec<Query>,\n /// t\u756a\u76ee\u306e\u8981\u7d20\u3092x\u304b\u3089y\u306b\u5909\u66f4\u3059\u308b\u30af\u30a8\u30ea\u30fc\n ch_query: Vec<Query>,\n /// T\u500b\u306e\u30af\u30a8\u30ea\u30fc\u306e\u5b9f\u884c\u5f8c\u306b\u304a\u3051\u308b\u533a\u9593 [L, R] \u306b\u6ce8\u76ee\u3057\u3066\u3044\u308b\u3053\u3068\u3092\u8868\u3059\u3002\n T: isize,\n L: isize,\n R: isize,\n /// ct[a] = \u6570\u5024 a \u304c\u73fe\u5728\u306e\u533a\u9593\u306b\u73fe\u308c\u308b\u56de\u6570\n ct: Vec<usize>,\n /// sz[k] = \u73fe\u5728\u306e\u533a\u9593\u306b\u304a\u3044\u3066\u3001\u3061\u3087\u3046\u3069 k \u56de\u51fa\u73fe\u3059\u308b\u6570\u5024\u306e\u500b\u6570\n sz: Vec<i32>,\n /// \u73fe\u5728\u306e(T\u500b\u306e\u30af\u30a8\u30ea\u30fc\u306e\u5b9f\u884c\u5f8c\u306e)\u6570\u5217\n a: Vec<usize>,\n mx: Vec<Vec<Vec<(usize, usize)>>>,\n}\n\nimpl Solver {\n pub fn new() -> Solver {\n Solver {\n mex_query: Vec::new(),\n ch_query: Vec::new(),\n ct: vec![0; N],\n sz: vec![0; N],\n a: Vec::new(),\n L: 0,\n R: -1,\n T: -1,\n mx: vec![vec![Vec::new(); B]; B],\n }\n }\n\n fn inspect(&self) {\n let M = 10;\n debug!(self.T, self.L, self.R, &self.ct[0..M], &self.sz[0..M]);\n }\n\n // R += 1\n pub fn pr(&mut self) {\n // self.inspect();\n\n self.R += 1;\n let R = self.R as usize;\n\n // \u533a\u9593\u306b\u8ffd\u52a0\u3055\u308c\u308b\u8981\u7d20\n let a = self.a[R];\n\n // \u66f4\u65b0\u524d\u306b\u3001a \u304c\u533a\u9593\u5185\u306b\u51fa\u73fe\u3057\u3066\u3044\u305f\u56de\u6570\n let k = self.ct[a];\n\n // a \u306e\u51fa\u73fe\u3059\u308b\u56de\u6570\u306f1\u56de\u5897\u3048\u308b\u3002\n self.ct[a] += 1;\n\n // \u300ck \u56de\u51fa\u73fe\u3059\u308b\u6570\u5024\u300d\u306f a \u304c\u6d88\u3048\u30661\u6e1b\u308a\u3001(k + 1) \u56de\u3003\u306fa\u304c\u52a0\u308f\u3063\u30661\u5897\u3048\u308b\u3002\n self.sz[k] -= 1;\n self.sz[k + 1] += 1;\n }\n\n // \u4e0a\u3068\u540c\u69d8\u3002a\u306e\u51fa\u73fe\u3059\u308b\u56de\u6570\u306f\u6e1b\u308b\u3002\n pub fn pl(&mut self) {\n // self.inspect();\n let a = self.a[self.L as usize];\n\n self.sz[self.ct[a]] -= 1;\n self.ct[a] -= 1;\n self.sz[self.ct[a]] += 1;\n\n self.L += 1;\n }\n\n pub fn mr(&mut self) {\n // self.inspect();\n assert!(self.R >= 0);\n let R = self.R as usize;\n\n let a = self.a[R];\n self.sz[self.ct[a]] -= 1;\n self.ct[a] -= 1;\n self.sz[self.ct[a]] += 1;\n\n self.R -= 1;\n }\n\n pub fn ml(&mut self) {\n // self.inspect();\n assert!(self.L >= 1);\n self.L -= 1;\n\n let a = self.a[self.L as usize];\n self.sz[self.ct[a]] -= 1;\n self.ct[a] += 1;\n self.sz[self.ct[a]] += 1;\n }\n\n fn update(&mut self, i: usize, x: usize, y: usize) {\n // i \u756a\u76ee\u306e\u8981\u7d20\u3092 x \u304b\u3089 y\u306b\u5909\u66f4\u3059\u308b\n assert!(self.a[i] == x);\n\n if self.in_focus(i) {\n // x \u306e\u51fa\u73fe\u3059\u308b\u56de\u6570\u304c\u6e1b\u308b\n let a = self.a[i];\n self.sz[self.ct[a]] -= 1;\n self.ct[a] -= 1;\n self.sz[self.ct[a]] += 1;\n }\n\n self.a[i] = y;\n\n if self.in_focus(i) {\n // y \u306e\u51fa\u73fe\u3059\u308b\u56de\u6570\u304c\u6e1b\u308b\n let a = self.a[i];\n self.sz[self.ct[a]] -= 1;\n self.ct[a] += 1;\n self.sz[self.ct[a]] += 1;\n }\n }\n\n // T += 1\n pub fn pt(&mut self) {\n // self.inspect();\n self.T += 1;\n let Query { t: i, x, y } = self.ch_query[self.T as usize];\n self.update(i, x, y);\n }\n\n /// T -= 1\n pub fn mt(&mut self) {\n // self.inspect();\n let Query { t: i, x, y } = self.ch_query[self.T as usize];\n self.update(i, y, x);\n self.T -= 1;\n }\n\n /// \u6307\u5b9a\u3055\u308c\u305f\u4f4d\u7f6e\u304c\u73fe\u5728\u306e\u533a\u9593\u306b\u542b\u307e\u308c\u3066\u3044\u308b\u304b\uff1f\n pub fn in_focus(&self, i: usize) -> bool {\n self.L <= i as isize && i as isize <= self.R\n }\n\n /// \u73fe\u5728\u306e\u533a\u9593\u306e mex \u3092\u8a08\u7b97\u3059\u308b\u3002O(\u221aN)\n pub fn mex(&self) -> usize {\n let mut k = 1;\n loop {\n if self.sz[k] == 0 {\n return k;\n }\n k += 1;\n }\n }\n\n pub fn entry_point(mut self, A: Vec<i64>, Q: Vec<(i32, i64, i64)>) -> Vec<usize> {\n let mut compressor = BTreeMap::new();\n let mut sigma = |a: i64| {\n let m = compressor.len();\n let e = compressor.entry(a).or_insert(m);\n *e\n };\n\n let A = A.iter().map(|&a| sigma(a)).vec();\n self.a = A.clone();\n let mut TA = A;\n\n for i in 0..Q.len() {\n let (t, l, r) = Q[i];\n\n if t == 1 {\n let l = (l - 1) as usize;\n let r = (r - 1) as usize;\n\n self.mex_query.push(Query {\n t: self.ch_query.len(),\n x: l,\n y: r,\n });\n } else {\n let l = (l - 1) as usize;\n let (x, y) = (TA[l], sigma(r));\n self.ch_query.push(Query {\n t: l as usize,\n x: x,\n y: y,\n });\n TA[l] = y;\n }\n }\n\n // \u30d6\u30ed\u30c3\u30af\u3054\u3068\u306b\u30af\u30a8\u30ea\u30fc\u3092\u5206\u985e\n // \u30d6\u30ed\u30c3\u30af\u30b5\u30a4\u30ba\u3092SZ\u3068\u3059\u308b\u3068\u3001\u5404\u30d6\u30ed\u30c3\u30af\u306b\u304a\u3044\u3066 t,l \u306f O(SZ) \u3057\u304b\u5909\u5316\u3057\u306a\u3044\u3053\u3068\u306b\u3067\u304d\u308b\u3002\n // \u30d6\u30ed\u30c3\u30af\u5185\u306e\u30af\u30a8\u30ea\u30fc\u3092 r \u306b\u3064\u3044\u3066\u30bd\u30fc\u30c8\u3059\u308c\u3070 r \u306f\u5358\u8abf\u5897\u52a0\u3059\u308b\u306e\u3067\u30011\u30d6\u30ed\u30c3\u30af\u3042\u305f\u308a O(N/SZ) \u6642\u9593\u304b\u304b\u308b\u3002\n\n let M = self.mex_query.len();\n for qi in 0..M {\n let Query { t, x, y } = self.mex_query[qi];\n let (i, j) = (t / SZ, x / SZ);\n self.mx[i][j].push((y, qi));\n }\n\n let mut answers = vec![0; M];\n\n for vs in std::mem::replace(&mut self.mx, Vec::default()) {\n for mut ws in vs {\n ws.sort();\n\n for (_, qi) in ws {\n let Query { t, x: l, y: r } = self.mex_query[qi];\n\n // (T, L, R) \u3092\u4e0e\u3048\u3089\u308c\u305f (t, l, r) \u306b\u8fd1\u3065\u3051\u3066\u3044\u304f\u3002\n // L \u304c R \u3092\u8ffd\u3044\u8d8a\u3055\u306a\u3044\u3088\u3046\u306b\u6ce8\u610f\u3002\n\n while self.L > l as isize {\n self.ml();\n }\n while self.R < r as isize {\n self.pr();\n }\n while self.L < l as isize {\n self.pl();\n }\n while self.R > r as isize {\n self.mr();\n }\n while ((self.T + 1) as usize) < t {\n self.pt();\n }\n while ((self.T + 1) as usize) > t {\n self.mt();\n }\n\n // assert!(\n // (self.T + 1) as usize == t && self.L == l as isize && self.R == r as isize\n // );\n\n // debug!(self.T, self.L, self.R, &self.ct[0..5], &self.sz[0..5]);\n\n answers[qi] = self.mex();\n }\n }\n }\n\n answers\n }\n}\n\npub fn main() {\n let (_, QN) = read!(usize, usize);\n let A = read![[i64]];\n let Q = read![i32, i64, i64; QN];\n\n let answers = Solver::new().entry_point(A, Q);\n for mex in answers {\n println!(\"{}\", mex);\n }\n}\n\n#[cfg(test)]\nmod tests {\n use super::*;\n\n #[test]\n fn test_sample1() {\n let A = vec![1, 2, 3, 1, 1, 2, 2, 2, 9, 9];\n let Q = vec![(1, 1, 1), (1, 2, 8), (2, 7, 1), (1, 2, 8)];\n let answer = Solver::new().entry_point(A, Q);\n assert_eq!(answer, vec![2, 3, 2]);\n }\n\n #[test]\n fn test() {\n let M = 100;\n let QN = 10;\n let A = (0..N).map(|i| (i * i * i % 17 + 1) as i64).vec();\n let Q = (0..QN)\n .map(|i| {\n let l = (i * i * i % M) as i64;\n let r = (l + (M - l) / 2) as i64;\n let t = (i % 2) as i32;\n (t + 1, l + 1, r + 1)\n })\n .vec();\n\n let answer = Solver::new().entry_point(A, Q);\n assert_eq!(answer, vec![1, 1, 3, 4, 4]);\n }\n}\n\n// problem\n// http://codeforces.com/contest/940/problem/F\n\n// ref [CF 940 F - Machine Learning - \u88cf\u7d19](http://imulan.hatenablog.jp/entry/2018/03/22/182619)\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "a32865b069a3287a4c21dcad61842052", "src_uid": "eb6362941b5186d20721c99fb4808d52", "difficulty": 2600}
- {"lang": "Rust", "source_code": "#![allow(unused_imports)]\n#![allow(non_snake_case)]\n#![allow(non_shorthand_field_patterns)]\n\nuse std::cmp::{max, min, Ordering};\nuse std::collections::*;\nuse std::fmt::{Debug, Formatter};\nuse std::io::*;\nuse std::ops::*;\nuse std::rc::Rc;\nuse std::*;\n\n// -----------------------------------------------\n// Framework\n// -----------------------------------------------\n\n#[allow(unused_macros)]\nmacro_rules! read {\n ([$t:ty] ; $n:expr) =>\n ((0..$n).map(|_| read!([$t])).collect::<Vec<_>>());\n ($($t:ty),+ ; $n:expr) =>\n ((0..$n).map(|_| read!($($t),+)).collect::<Vec<_>>());\n ([$t:ty]) =>\n (rl().split_whitespace().map(|w| w.parse().unwrap()).collect::<Vec<$t>>());\n ($t:ty) =>\n (rl().parse::<$t>().unwrap());\n ($($t:ty),*) => {{\n let buf = rl();\n let mut w = buf.split_whitespace();\n ($(w.next().unwrap().parse::<$t>().unwrap()),*)\n }};\n}\n\n#[allow(unused_macros)]\nmacro_rules! debug {\n ($($arg:expr),*) => {\n #[cfg(debug_assertions)]\n {\n let entries = [$(&stringify!([$arg]:), &$arg as &Debug),*];\n stderr().write_fmt(format_args!(\"{:#?}\\n\", entries)).unwrap();\n }\n };\n}\n\n#[allow(dead_code)]\nfn rl() -> String {\n let mut buf = String::new();\n io::stdin().read_line(&mut buf).unwrap();\n buf.trim_right().to_owned()\n}\n\ntrait IteratorExt: Iterator + Sized {\n fn vec(self) -> Vec<Self::Item> {\n self.collect()\n }\n}\n\nimpl<T: Iterator> IteratorExt for T {}\n\n// -----------------------------------------------\n// Solution\n// -----------------------------------------------\n\n// ref [CF 940 F - Machine Learning - \u88cf\u7d19](http://imulan.hatenablog.jp/entry/2018/03/22/182619)\n\n#[derive(Clone, Copy, Debug)]\nstruct Query {\n t: usize,\n x: usize,\n y: usize,\n}\n\n// \u5ea7\u6a19\u5727\u7e2e\u5f8c\u306e\u6570\u5217\u306e\u5024\u306e\u6700\u5927\u5024\nconst N: usize = 200000;\n\n// \u30d0\u30b1\u30c3\u30c8\u306e\u30b5\u30a4\u30ba (~~ N^(2/3))\nconst SZ: usize = 2100;\n\n// \u30d0\u30b1\u30c3\u30c8\u6570\u306e\u6700\u5927\u5024 (>= N/SZ)\nconst B: usize = 60;\n\nstruct Solver {\n /// \u66f4\u65b0\u30af\u30a8\u30ea\u30fc\u3092t\u500b\u5b9f\u884c\u3057\u305f\u5f8c\u306e\u533a\u9593 [x, y] \u306e mex \u3092\u7b54\u3048\u308b\u30af\u30a8\u30ea\u30fc\n mex_query: Vec<Query>,\n /// t\u756a\u76ee\u306e\u8981\u7d20\u3092x\u304b\u3089y\u306b\u5909\u66f4\u3059\u308b\u30af\u30a8\u30ea\u30fc\n ch_query: Vec<Query>,\n /// T\u500b\u306e\u30af\u30a8\u30ea\u30fc\u306e\u5b9f\u884c\u5f8c\u306b\u304a\u3051\u308b\u533a\u9593 [L, R] \u306b\u6ce8\u76ee\u3057\u3066\u3044\u308b\u3053\u3068\u3092\u8868\u3059\u3002\n T: isize,\n L: usize,\n R: isize,\n /// ct[a] = \u6570\u5024 a \u304c\u73fe\u5728\u306e\u533a\u9593\u306b\u73fe\u308c\u308b\u56de\u6570\n ct: Vec<usize>,\n /// sz[k] = \u73fe\u5728\u306e\u533a\u9593\u306b\u304a\u3044\u3066\u3001\u3061\u3087\u3046\u3069 k \u56de\u51fa\u73fe\u3059\u308b\u6570\u5024\u306e\u500b\u6570\n sz: Vec<usize>,\n /// \u73fe\u5728\u306e(T\u500b\u306e\u30af\u30a8\u30ea\u30fc\u306e\u5b9f\u884c\u5f8c\u306e)\u6570\u5217\n a: Vec<usize>,\n mx: Vec<Vec<HashSet<(usize, usize)>>>,\n}\n\nimpl Solver {\n pub fn new() -> Solver {\n let mut solver = Solver {\n mex_query: Vec::new(),\n ch_query: Vec::new(),\n ct: vec![0; N],\n sz: vec![0; N],\n a: Vec::new(),\n L: 0,\n R: -1,\n T: -1,\n mx: vec![vec![HashSet::new(); B]; B],\n };\n solver.sz[0] = std::usize::MAX / 2;\n solver\n }\n\n // R += 1\n pub fn pr(&mut self) {\n self.R += 1;\n let R = self.R as usize;\n\n // \u533a\u9593\u306b\u8ffd\u52a0\u3055\u308c\u308b\u8981\u7d20\n let a = self.a[R];\n\n // \u66f4\u65b0\u524d\u306b\u3001a \u304c\u533a\u9593\u5185\u306b\u51fa\u73fe\u3057\u3066\u3044\u305f\u56de\u6570\n let k = self.ct[a];\n\n // a \u306e\u51fa\u73fe\u3059\u308b\u56de\u6570\u306f1\u56de\u5897\u3048\u308b\u3002\n self.ct[a] += 1;\n\n // \u300ck \u56de\u51fa\u73fe\u3059\u308b\u6570\u5024\u300d\u306f a \u304c\u6d88\u3048\u30661\u6e1b\u308a\u3001(k + 1) \u56de\u3003\u306fa\u304c\u52a0\u308f\u3063\u30661\u5897\u3048\u308b\u3002\n self.sz[k] -= 1;\n self.sz[k + 1] += 1;\n }\n\n // \u4e0a\u3068\u540c\u69d8\u3002a\u306e\u51fa\u73fe\u3059\u308b\u56de\u6570\u306f\u6e1b\u308b\u3002\n pub fn pl(&mut self) {\n let a = self.a[self.L];\n\n self.sz[self.ct[a]] -= 1;\n self.ct[a] -= 1;\n self.sz[self.ct[a]] += 1;\n\n self.L += 1;\n }\n\n pub fn mr(&mut self) {\n assert!(self.R >= 0);\n let R = self.R as usize;\n\n let a = self.a[R];\n self.sz[self.ct[a]] -= 1;\n self.ct[a] -= 1;\n self.sz[self.ct[a]] += 1;\n\n self.R -= 1;\n }\n\n pub fn ml(&mut self) {\n assert!(self.L >= 1);\n\n let a = self.a[self.L];\n self.sz[self.ct[a]] -= 1;\n self.ct[a] += 1;\n self.sz[self.ct[a]] += 1;\n\n self.L -= 1;\n }\n\n fn update(&mut self, i: usize, x: usize, y: usize) {\n // i \u756a\u76ee\u306e\u8981\u7d20\u3092 x \u304b\u3089 y\u306b\u5909\u66f4\u3059\u308b\n assert!(self.a[i] == x);\n\n if self.in_focus(i) {\n // x \u306e\u51fa\u73fe\u3059\u308b\u56de\u6570\u304c\u6e1b\u308b\n let a = self.a[i];\n self.sz[self.ct[a]] -= 1;\n self.ct[a] -= 1;\n self.sz[self.ct[a]] += 1;\n }\n\n self.a[i] = y;\n\n if self.in_focus(i) {\n // y \u306e\u51fa\u73fe\u3059\u308b\u56de\u6570\u304c\u6e1b\u308b\n let a = self.a[i];\n self.sz[self.ct[a]] -= 1;\n self.ct[a] += 1;\n self.sz[self.ct[a]] += 1;\n }\n }\n\n // T += 1\n pub fn pt(&mut self) {\n self.T += 1;\n let Query { t: i, x: x, y: y } = self.ch_query[self.T as usize];\n self.update(i, x, y);\n }\n\n /// T -= 1\n pub fn mt(&mut self) {\n let Query { t: i, x: x, y: y } = self.ch_query[self.T as usize];\n self.update(i, y, x);\n self.T -= 1;\n }\n\n /// \u6307\u5b9a\u3055\u308c\u305f\u4f4d\u7f6e\u304c\u73fe\u5728\u306e\u533a\u9593\u306b\u542b\u307e\u308c\u3066\u3044\u308b\u304b\uff1f\n pub fn in_focus(&self, i: usize) -> bool {\n self.L <= i && i as isize <= self.R\n }\n\n /// \u73fe\u5728\u306e\u533a\u9593\u306e mex \u3092\u8a08\u7b97\u3059\u308b\u3002O(\u221aN)\n pub fn mex(&self) -> usize {\n let mut k = 1;\n loop {\n if self.sz[k] == 0 {\n return k;\n }\n k += 1;\n }\n }\n\n pub fn entry_point(mut self) {\n let (_, QN) = read!(usize, usize);\n let A = read![[i64]];\n let Q = read![i32, i64, i64; QN];\n\n let mut compressor = HashMap::with_capacity(N);\n let mut sigma = |a: i64| {\n let m = compressor.len();\n let e = compressor.entry(a).or_insert(m);\n *e\n };\n\n let A = A.iter().map(|&a| sigma(a)).vec();\n self.a = A.clone();\n let mut TA = A;\n\n for i in 0..QN {\n let (t, l, r) = Q[i];\n\n if t == 1 {\n let l = (l - 1) as usize;\n let r = (r - 1) as usize;\n\n self.mex_query.push(Query {\n t: self.ch_query.len(),\n x: l,\n y: r,\n });\n } else {\n let l = (l - 1) as usize;\n let (x, y) = (TA[l], sigma(r));\n self.ch_query.push(Query {\n t: l as usize,\n x: x,\n y: y,\n });\n TA[l] = y;\n }\n }\n\n // \u30d6\u30ed\u30c3\u30af\u3054\u3068\u306b\u30af\u30a8\u30ea\u30fc\u3092\u5206\u985e\n let M = self.mex_query.len();\n for qi in 0..M {\n let Query { t: t, x: x, y: y } = self.mex_query[qi];\n let (i, j) = (t / SZ, x / SZ);\n self.mx[i][j].insert((y, qi));\n }\n\n let mut answers = vec![0; M];\n\n for i in 0..B {\n for j in 0..B {\n let mx = std::mem::replace(&mut self.mx[i][j], HashSet::default());\n for (_, qi) in mx {\n let Query { t: t, x: l, y: r } = self.mex_query[qi];\n\n // (T, L, R) \u3092\u4e0e\u3048\u3089\u308c\u305f (t, l, r) \u306b\u8fd1\u3065\u3051\u3066\u3044\u304f\u3002\n\n while self.R < r as isize {\n self.pr();\n }\n while self.R > r as isize {\n self.mr();\n }\n while self.L < l {\n self.pl();\n }\n while self.L > l {\n self.ml();\n }\n while ((self.T + 1) as usize) < t {\n self.pt();\n }\n while ((self.T + 1) as usize) > t {\n self.mt();\n }\n\n assert!((self.T + 1) as usize == t && self.L == l && self.R as usize == r);\n\n // debug!(self.T, self.L, self.R, &self.ct[0..5], &self.sz[0..5]);\n\n answers[qi] = self.mex();\n }\n }\n }\n\n for mex in answers {\n println!(\"{}\", mex);\n }\n }\n}\n\npub fn main() {\n Solver::new().entry_point();\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "53042937dfaf3136becbc8647d26d46a", "src_uid": "eb6362941b5186d20721c99fb4808d52", "difficulty": 2600}
- {"lang": "Rust", "source_code": "#![allow(unused_imports)]\n#![allow(non_snake_case)]\n#![allow(non_shorthand_field_patterns)]\n\nuse std::cmp::{max, min, Ordering};\nuse std::collections::*;\nuse std::fmt::{Debug, Formatter};\nuse std::io::*;\nuse std::ops::*;\nuse std::rc::Rc;\nuse std::*;\n\n// -----------------------------------------------\n// Framework\n// -----------------------------------------------\n\n#[allow(unused_macros)]\nmacro_rules! read {\n ([$t:ty] ; $n:expr) =>\n ((0..$n).map(|_| read!([$t])).collect::<Vec<_>>());\n ($($t:ty),+ ; $n:expr) =>\n ((0..$n).map(|_| read!($($t),+)).collect::<Vec<_>>());\n ([$t:ty]) =>\n (rl().split_whitespace().map(|w| w.parse().unwrap()).collect::<Vec<$t>>());\n ($t:ty) =>\n (rl().parse::<$t>().unwrap());\n ($($t:ty),*) => {{\n let buf = rl();\n let mut w = buf.split_whitespace();\n ($(w.next().unwrap().parse::<$t>().unwrap()),*)\n }};\n}\n\n#[allow(unused_macros)]\nmacro_rules! debug {\n ($($arg:expr),*) => {\n #[cfg(debug_assertions)]\n {\n let entries = [$(&stringify!([$arg]:), &$arg as &Debug),*];\n stderr().write_fmt(format_args!(\"{:#?}\\n\", entries)).unwrap();\n }\n };\n}\n\n#[allow(dead_code)]\nfn rl() -> String {\n let mut buf = String::new();\n io::stdin().read_line(&mut buf).unwrap();\n buf.trim_right().to_owned()\n}\n\ntrait IteratorExt: Iterator + Sized {\n fn vec(self) -> Vec<Self::Item> {\n self.collect()\n }\n}\n\nimpl<T: Iterator> IteratorExt for T {}\n\n// -----------------------------------------------\n// Solution\n// -----------------------------------------------\n\n#[derive(Clone, Copy, Debug)]\nstruct Query {\n t: usize,\n x: usize,\n y: usize,\n}\n\n// \u5ea7\u6a19\u5727\u7e2e\u5f8c\u306e\u6570\u5217\u306e\u5024\u306e\u6700\u5927\u5024\nconst N: usize = 200000;\n\n// \u30d0\u30b1\u30c3\u30c8\u306e\u30b5\u30a4\u30ba (~~ N^(2/3))\nconst SZ: usize = 2100;\n\n// \u30d0\u30b1\u30c3\u30c8\u6570\u306e\u6700\u5927\u5024 (>= N/SZ)\nconst B: usize = 60;\n\nstruct Solver {\n /// \u66f4\u65b0\u30af\u30a8\u30ea\u30fc\u3092t\u500b\u5b9f\u884c\u3057\u305f\u5f8c\u306e\u533a\u9593 [x, y] \u306e mex \u3092\u7b54\u3048\u308b\u30af\u30a8\u30ea\u30fc\n mex_query: Vec<Query>,\n /// t\u756a\u76ee\u306e\u8981\u7d20\u3092x\u304b\u3089y\u306b\u5909\u66f4\u3059\u308b\u30af\u30a8\u30ea\u30fc\n ch_query: Vec<Query>,\n /// T\u500b\u306e\u30af\u30a8\u30ea\u30fc\u306e\u5b9f\u884c\u5f8c\u306b\u304a\u3051\u308b\u533a\u9593 [L, R] \u306b\u6ce8\u76ee\u3057\u3066\u3044\u308b\u3053\u3068\u3092\u8868\u3059\u3002\n T: isize,\n L: isize,\n R: isize,\n /// ct[a] = \u6570\u5024 a \u304c\u73fe\u5728\u306e\u533a\u9593\u306b\u73fe\u308c\u308b\u56de\u6570\n ct: Vec<usize>,\n /// sz[k] = \u73fe\u5728\u306e\u533a\u9593\u306b\u304a\u3044\u3066\u3001\u3061\u3087\u3046\u3069 k \u56de\u51fa\u73fe\u3059\u308b\u6570\u5024\u306e\u500b\u6570\n sz: Vec<i32>,\n /// \u73fe\u5728\u306e(T\u500b\u306e\u30af\u30a8\u30ea\u30fc\u306e\u5b9f\u884c\u5f8c\u306e)\u6570\u5217\n a: Vec<usize>,\n mx: Vec<Vec<HashSet<(usize, usize)>>>,\n}\n\nimpl Solver {\n pub fn new() -> Solver {\n Solver {\n mex_query: Vec::new(),\n ch_query: Vec::new(),\n ct: vec![0; N],\n sz: vec![0; N],\n a: Vec::new(),\n L: 0,\n R: -1,\n T: -1,\n mx: vec![vec![HashSet::new(); B]; B],\n }\n }\n\n fn inspect(&self) {\n let M = 10;\n debug!(self.T, self.L, self.R, &self.ct[0..M], &self.sz[0..M]);\n }\n\n // R += 1\n pub fn pr(&mut self) {\n // self.inspect();\n\n self.R += 1;\n let R = self.R as usize;\n\n // \u533a\u9593\u306b\u8ffd\u52a0\u3055\u308c\u308b\u8981\u7d20\n let a = self.a[R];\n\n // \u66f4\u65b0\u524d\u306b\u3001a \u304c\u533a\u9593\u5185\u306b\u51fa\u73fe\u3057\u3066\u3044\u305f\u56de\u6570\n let k = self.ct[a];\n\n // a \u306e\u51fa\u73fe\u3059\u308b\u56de\u6570\u306f1\u56de\u5897\u3048\u308b\u3002\n self.ct[a] += 1;\n\n // \u300ck \u56de\u51fa\u73fe\u3059\u308b\u6570\u5024\u300d\u306f a \u304c\u6d88\u3048\u30661\u6e1b\u308a\u3001(k + 1) \u56de\u3003\u306fa\u304c\u52a0\u308f\u3063\u30661\u5897\u3048\u308b\u3002\n self.sz[k] -= 1;\n self.sz[k + 1] += 1;\n }\n\n // \u4e0a\u3068\u540c\u69d8\u3002a\u306e\u51fa\u73fe\u3059\u308b\u56de\u6570\u306f\u6e1b\u308b\u3002\n pub fn pl(&mut self) {\n // self.inspect();\n let a = self.a[self.L as usize];\n\n self.sz[self.ct[a]] -= 1;\n self.ct[a] -= 1;\n self.sz[self.ct[a]] += 1;\n\n self.L += 1;\n }\n\n pub fn mr(&mut self) {\n // self.inspect();\n assert!(self.R >= 0);\n let R = self.R as usize;\n\n let a = self.a[R];\n self.sz[self.ct[a]] -= 1;\n self.ct[a] -= 1;\n self.sz[self.ct[a]] += 1;\n\n self.R -= 1;\n }\n\n pub fn ml(&mut self) {\n // self.inspect();\n assert!(self.L >= 1);\n self.L -= 1;\n\n let a = self.a[self.L as usize];\n self.sz[self.ct[a]] -= 1;\n self.ct[a] += 1;\n self.sz[self.ct[a]] += 1;\n }\n\n fn update(&mut self, i: usize, x: usize, y: usize) {\n // i \u756a\u76ee\u306e\u8981\u7d20\u3092 x \u304b\u3089 y\u306b\u5909\u66f4\u3059\u308b\n assert!(self.a[i] == x);\n\n if self.in_focus(i) {\n // x \u306e\u51fa\u73fe\u3059\u308b\u56de\u6570\u304c\u6e1b\u308b\n let a = self.a[i];\n self.sz[self.ct[a]] -= 1;\n self.ct[a] -= 1;\n self.sz[self.ct[a]] += 1;\n }\n\n self.a[i] = y;\n\n if self.in_focus(i) {\n // y \u306e\u51fa\u73fe\u3059\u308b\u56de\u6570\u304c\u6e1b\u308b\n let a = self.a[i];\n self.sz[self.ct[a]] -= 1;\n self.ct[a] += 1;\n self.sz[self.ct[a]] += 1;\n }\n }\n\n // T += 1\n pub fn pt(&mut self) {\n // self.inspect();\n self.T += 1;\n let Query { t: i, x, y } = self.ch_query[self.T as usize];\n self.update(i, x, y);\n }\n\n /// T -= 1\n pub fn mt(&mut self) {\n // self.inspect();\n let Query { t: i, x, y } = self.ch_query[self.T as usize];\n self.update(i, y, x);\n self.T -= 1;\n }\n\n /// \u6307\u5b9a\u3055\u308c\u305f\u4f4d\u7f6e\u304c\u73fe\u5728\u306e\u533a\u9593\u306b\u542b\u307e\u308c\u3066\u3044\u308b\u304b\uff1f\n pub fn in_focus(&self, i: usize) -> bool {\n self.L <= i as isize && i as isize <= self.R\n }\n\n /// \u73fe\u5728\u306e\u533a\u9593\u306e mex \u3092\u8a08\u7b97\u3059\u308b\u3002O(\u221aN)\n pub fn mex(&self) -> usize {\n let mut k = 1;\n loop {\n if self.sz[k] == 0 {\n return k;\n }\n k += 1;\n }\n }\n\n pub fn entry_point(mut self, A: Vec<i64>, Q: Vec<(i32, i64, i64)>) -> Vec<usize> {\n let mut compressor = HashMap::with_capacity(N);\n let mut sigma = |a: i64| {\n let m = compressor.len();\n let e = compressor.entry(a).or_insert(m);\n *e\n };\n\n let A = A.iter().map(|&a| sigma(a)).vec();\n self.a = A.clone();\n let mut TA = A;\n\n for i in 0..Q.len() {\n let (t, l, r) = Q[i];\n\n if t == 1 {\n let l = (l - 1) as usize;\n let r = (r - 1) as usize;\n\n self.mex_query.push(Query {\n t: self.ch_query.len(),\n x: l,\n y: r,\n });\n } else {\n let l = (l - 1) as usize;\n let (x, y) = (TA[l], sigma(r));\n self.ch_query.push(Query {\n t: l as usize,\n x: x,\n y: y,\n });\n TA[l] = y;\n }\n }\n\n // \u30d6\u30ed\u30c3\u30af\u3054\u3068\u306b\u30af\u30a8\u30ea\u30fc\u3092\u5206\u985e\n let M = self.mex_query.len();\n for qi in 0..M {\n let Query { t, x, y } = self.mex_query[qi];\n let (i, j) = (t / SZ, x / SZ);\n self.mx[i][j].insert((y, qi));\n }\n\n let mut answers = vec![0; M];\n\n for i in 0..B {\n for j in 0..B {\n let mx = std::mem::replace(&mut self.mx[i][j], HashSet::default());\n for (_, qi) in mx {\n let Query { t, x: l, y: r } = self.mex_query[qi];\n\n // (T, L, R) \u3092\u4e0e\u3048\u3089\u308c\u305f (t, l, r) \u306b\u8fd1\u3065\u3051\u3066\u3044\u304f\u3002\n\n while self.L > l as isize {\n self.ml();\n }\n while self.R < r as isize {\n self.pr();\n }\n while self.L < l as isize {\n self.pl();\n }\n while self.R > r as isize {\n self.mr();\n }\n while ((self.T + 1) as usize) < t {\n self.pt();\n }\n while ((self.T + 1) as usize) > t {\n self.mt();\n }\n\n // assert!(\n // (self.T + 1) as usize == t && self.L == l as isize && self.R == r as isize\n // );\n\n // debug!(self.T, self.L, self.R, &self.ct[0..5], &self.sz[0..5]);\n\n answers[qi] = self.mex();\n }\n }\n }\n\n answers\n }\n}\n\npub fn main() {\n let (_, QN) = read!(usize, usize);\n let A = read![[i64]];\n let Q = read![i32, i64, i64; QN];\n\n let answers = Solver::new().entry_point(A, Q);\n for mex in answers {\n println!(\"{}\", mex);\n }\n}\n\n#[cfg(test)]\nmod tests {\n use super::*;\n\n #[test]\n fn test_sample1() {\n let M = 10;\n let QN = 4;\n let A = vec![1, 2, 3, 1, 1, 2, 2, 2, 9, 9];\n let Q = vec![(1, 1, 1), (1, 2, 8), (2, 7, 1), (1, 2, 8)];\n let answer = Solver::new().entry_point(A, Q);\n assert_eq!(answer, vec![2, 3, 2]);\n }\n\n #[test]\n fn test() {\n let M = 100;\n let QN = 10;\n let A = (0..N).map(|i| (i * i * i % 17 + 1) as i64).vec();\n let Q = (0..QN)\n .map(|i| {\n let l = (i * i * i % M) as i64;\n let r = (l + (M - l) / 2) as i64;\n let t = (i % 2) as i32;\n (t + 1, l + 1, r + 1)\n })\n .vec();\n\n let answer = Solver::new().entry_point(A, Q);\n assert_eq!(answer, vec![]);\n }\n}\n\n// problem\n// http://codeforces.com/contest/940/problem/F\n\n// ref [CF 940 F - Machine Learning - \u88cf\u7d19](http://imulan.hatenablog.jp/entry/2018/03/22/182619)\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "7ecc0a9b8ce26b7eb92f7fd1dc8658c1", "src_uid": "eb6362941b5186d20721c99fb4808d52", "difficulty": 2600}
- {"lang": "Rust", "source_code": "//https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 \u3088\u308a\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n ($($r:tt)*) => {\n let s = {\n use std::io::Read;\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n };\n let mut iter = s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n}\n\nmacro_rules! input_inner {\n ($iter:expr) => {};\n ($iter:expr, ) => {};\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n}\n\nmacro_rules! read_value {\n ($iter:expr, ( $($t:tt),* )) => {\n ( $(read_value!($iter, $t)),* )\n };\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()\n };\n ($iter:expr, chars) => {\n read_value!($iter, String).chars().collect::<Vec<char>>()\n };\n ($iter:expr, bytes) => {\n read_value!($iter, String).bytes().collect::<Vec<u8>>()\n };\n ($iter:expr, usize1) => {\n read_value!($iter, usize) - 1\n };\n ($iter:expr, $t:ty) => {\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n//\n\n// \u6642\u7a7a\u9593Mo\n// \u5e45N, \u6c42\u5024X, \u66f4\u65b0Y \u3068\u7f6e\u304f\n// \u30d6\u30ed\u30c3\u30af\u30b5\u30a4\u30ba\u3092B\u3068\u3057\u305f\u3068\u304d\u306e\u8a08\u7b97\u91cf\u306f\uff1f\n//\n// 1/2 \u3068\u304b\u7121\u8996\u3057\u3066\n//\n// \u66f4\u65b0\u56de\u6570: (N / B) ^ 2 * Y\n// \u30dd\u30a4\u30f3\u30bf\u3092\u52d5\u304b\u3059\u56de\u6570 X * B\n//\n// \u521d\u671f\u5316\u306e\u8a08\u7b97\u91cf\u3082\u3044\u308b\uff1f (N / B) ^ 2 * N\n// dF/dB = X - (1 / 2) * (N^2 * Y + N^3) / B^3\n// = (2 * X * B^3 - (N^2 * Y + N^3)) / B^3\n// 2\u306e\u9805\u3092\u7121\u8996\u3057\u3066\uff1f\n// B = ((N^2 * Y + N^3) / X) ^ (2 / 3)\n// X = Y = Q\n// B = (N^2 + N^3 / Q) ^ (2 / 3)\n\nuse std::io::Write;\n\nstruct State {\n cnt: Vec<usize>,\n elem: Vec<usize>,\n mex: usize,\n}\n\nimpl State {\n fn new(n: usize) -> Self {\n let mut state = State {\n cnt: vec![0; n + 1],\n elem: vec![0; n + 1],\n mex: 0,\n };\n state.init();\n state\n }\n fn init(&mut self) {\n let len = self.cnt.len();\n self.cnt.clear();\n self.cnt.resize(len, 0);\n self.elem.clear();\n self.elem.resize(len, 0);\n self.elem[0] = len;\n self.mex = 1;\n }\n fn insert(&mut self, x: usize) {\n let c = &mut self.cnt[x];\n self.elem[*c] -= 1;\n *c += 1;\n self.elem[*c] += 1;\n let p = &mut self.mex;\n if self.elem[*c - 1] == 0 && *c - 1 < *p {\n *p = *c - 1;\n } else if *c == *p {\n *p += 1;\n }\n }\n fn delete(&mut self, x: usize) {\n let c = &mut self.cnt[x];\n self.elem[*c] -= 1;\n *c -= 1;\n self.elem[*c] += 1;\n let p = &mut self.mex;\n if self.elem[*c + 1] == 0 && *c + 1 < *p {\n *p = *c + 1;\n } else if *c == *p {\n *p += 1;\n }\n }\n fn find(&self) -> usize {\n self.mex\n }\n}\n\nfn run() {\n input! {\n n: usize,\n q: usize,\n a: [usize; n],\n ask: [(u8, usize1, usize); q],\n }\n let mut z = a.clone();\n for &(_, _, x) in ask.iter().filter(|p| p.0 == 2) {\n z.push(x);\n }\n z.sort();\n z.dedup();\n let mut a = a;\n for a in a.iter_mut() {\n *a = z.binary_search(a).unwrap();\n }\n let mut ask = ask;\n for p in ask.iter_mut().filter(|p| p.0 == 2) {\n p.2 = z.binary_search(&p.2).unwrap();\n }\n let batch = {\n 1000\n /*\n let n = n as f64;\n let q = q as f64;\n (n.powi(2) + n.powi(3) / q).cbrt().powi(2) as usize\n */\n };\n let mut update = vec![];\n let mut query = vec![vec![vec![]; n / batch + 1]; n / batch + 1];\n for (i, (op, a, b)) in ask.into_iter().enumerate() {\n if op == 1 {\n query[a / batch][b / batch].push((a, b, i));\n } else {\n update.push((a, b, i));\n }\n }\n let mut ans = vec![0; q];\n let mut state = State::new(z.len() + n);\n for (i, q) in query.iter().enumerate() {\n for q in q.iter() {\n if q.is_empty() {\n continue;\n }\n state.init();\n let mut a = a.clone();\n let mut x = i * batch;\n let mut y = i * batch;\n let mut z = 0;\n for &(l, r, k) in q.iter() {\n while z < update.len() && update[z].2 < k {\n let p = update[z].0;\n let v = update[z].1;\n if x <= p && p < y {\n state.delete(a[p]);\n state.insert(v);\n }\n a[p] = v;\n z += 1;\n }\n while l < x {\n x -= 1;\n state.insert(a[x]);\n }\n while y < r {\n state.insert(a[y]);\n y += 1;\n }\n while x < l {\n state.delete(a[x]);\n x += 1;\n }\n while r < y {\n y -= 1;\n state.delete(a[y]);\n }\n ans[k] = state.find();\n }\n }\n }\n let out = std::io::stdout();\n let mut out = std::io::BufWriter::new(out.lock());\n for a in ans {\n if a > 0 {\n writeln!(out, \"{}\", a).ok();\n }\n }\n}\n\nfn main() {\n run();\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "93a973a1160160130a4a351b36fa2ce0", "src_uid": "eb6362941b5186d20721c99fb4808d52", "difficulty": 2600}
- {"lang": "Rust", "source_code": "//https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 \u3088\u308a\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n ($($r:tt)*) => {\n let s = {\n use std::io::Read;\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n };\n let mut iter = s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n}\n\nmacro_rules! input_inner {\n ($iter:expr) => {};\n ($iter:expr, ) => {};\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n}\n\nmacro_rules! read_value {\n ($iter:expr, ( $($t:tt),* )) => {\n ( $(read_value!($iter, $t)),* )\n };\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()\n };\n ($iter:expr, chars) => {\n read_value!($iter, String).chars().collect::<Vec<char>>()\n };\n ($iter:expr, bytes) => {\n read_value!($iter, String).bytes().collect::<Vec<u8>>()\n };\n ($iter:expr, usize1) => {\n read_value!($iter, usize) - 1\n };\n ($iter:expr, $t:ty) => {\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n//\n\n// \u6642\u7a7a\u9593Mo\n// \u5e45N, \u6c42\u5024X, \u66f4\u65b0Y \u3068\u7f6e\u304f\n// \u30d6\u30ed\u30c3\u30af\u30b5\u30a4\u30ba\u3092B\u3068\u3057\u305f\u3068\u304d\u306e\u8a08\u7b97\u91cf\u306f\uff1f\n//\n// 1/2 \u3068\u304b\u7121\u8996\u3057\u3066\n//\n// \u66f4\u65b0\u56de\u6570: (N / B) ^ 2 * Y\n// \u30dd\u30a4\u30f3\u30bf\u3092\u52d5\u304b\u3059\u56de\u6570 X * B\n//\n// \u521d\u671f\u5316\u306e\u8a08\u7b97\u91cf\u3082\u3044\u308b\uff1f (N / B) ^ 2 * N\n// dF/dB = X - (1 / 2) * (N^2 * Y + N^3) / B^3\n// = (2 * X * B^3 - (N^2 * Y + N^3)) / B^3\n// 2\u306e\u9805\u3092\u7121\u8996\u3057\u3066\uff1f\n// B = ((N^2 * Y + N^3) / X) ^ (2 / 3)\n// X = Y = Q\n// B = (N^2 + N^3 / Q) ^ (2 / 3)\n\nuse std::io::Write;\n\nstruct State {\n cnt: Vec<usize>,\n elem: Vec<usize>,\n mex: usize,\n}\n\nimpl State {\n fn new(n: usize) -> Self {\n let mut state = State {\n cnt: vec![0; n + 1],\n elem: vec![0; n + 1],\n mex: 0,\n };\n state.init();\n state\n }\n fn init(&mut self) {\n let len = self.cnt.len();\n self.cnt.clear();\n self.cnt.resize(len, 0);\n self.elem.clear();\n self.elem.resize(len, 0);\n self.elem[0] = len;\n self.mex = 1;\n }\n fn insert(&mut self, x: usize) {\n let c = &mut self.cnt[x];\n self.elem[*c] -= 1;\n *c += 1;\n self.elem[*c] += 1;\n let p = &mut self.mex;\n if self.elem[*c - 1] == 0 && *c - 1 < *p {\n *p = *c - 1;\n }\n while self.elem[*p] > 0 {\n *p += 1;\n }\n }\n fn delete(&mut self, x: usize) {\n let c = &mut self.cnt[x];\n self.elem[*c] -= 1;\n *c -= 1;\n self.elem[*c] += 1;\n let p = &mut self.mex;\n if self.elem[*c + 1] == 0 && *c + 1 < *p {\n *p = *c + 1;\n }\n while self.elem[*p] > 0 {\n *p += 1;\n }\n }\n fn find(&self) -> usize {\n self.mex\n }\n}\n\nfn run() {\n input! {\n n: usize,\n q: usize,\n a: [usize; n],\n ask: [(u8, usize1, usize); q],\n }\n let mut z = a.clone();\n for &(_, _, x) in ask.iter().filter(|p| p.0 == 2) {\n z.push(x);\n }\n z.sort();\n z.dedup();\n let mut a = a;\n for a in a.iter_mut() {\n *a = z.binary_search(a).unwrap();\n }\n let mut ask = ask;\n for p in ask.iter_mut().filter(|p| p.0 == 2) {\n p.2 = z.binary_search(&p.2).unwrap();\n }\n let batch = {\n let n = n as f64;\n (n.powi(2) * 8.0).cbrt().ceil() as usize\n };\n let mut update = vec![];\n let mut query = vec![vec![vec![]; n / batch + 1]; n / batch + 1];\n for (i, (op, a, b)) in ask.into_iter().enumerate() {\n if op == 1 {\n query[a / batch][b / batch].push((a, b, i));\n } else {\n update.push((a, b, i));\n }\n }\n let mut ans = vec![0; q];\n let mut state = State::new(z.len() + n);\n for (i, q) in query.iter().enumerate() {\n for q in q.iter() {\n if q.is_empty() {\n continue;\n }\n state.init();\n let mut a = a.clone();\n let mut x = i * batch;\n let mut y = i * batch;\n let mut z = 0;\n for &(l, r, k) in q.iter() {\n while z < update.len() && update[z].2 < k {\n let p = update[z].0;\n let v = update[z].1;\n if x <= p && p < y {\n state.delete(a[p]);\n state.insert(v);\n }\n a[p] = v;\n z += 1;\n }\n while l < x {\n x -= 1;\n state.insert(a[x]);\n }\n while y < r {\n state.insert(a[y]);\n y += 1;\n }\n while x < l {\n state.delete(a[x]);\n x += 1;\n }\n while r < y {\n y -= 1;\n state.delete(a[y]);\n }\n ans[k] = state.find();\n }\n }\n }\n let out = std::io::stdout();\n let mut out = std::io::BufWriter::new(out.lock());\n for a in ans {\n if a > 0 {\n writeln!(out, \"{}\", a).ok();\n }\n }\n}\n\nfn main() {\n run();\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "89fa5b8e8b4d76ecf2c4367f51dd58db", "src_uid": "eb6362941b5186d20721c99fb4808d52", "difficulty": 2600}
- {"lang": "Rust", "source_code": "//https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 \u3088\u308a\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n ($($r:tt)*) => {\n let s = {\n use std::io::Read;\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n };\n let mut iter = s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n}\n\nmacro_rules! input_inner {\n ($iter:expr) => {};\n ($iter:expr, ) => {};\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n}\n\nmacro_rules! read_value {\n ($iter:expr, ( $($t:tt),* )) => {\n ( $(read_value!($iter, $t)),* )\n };\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()\n };\n ($iter:expr, chars) => {\n read_value!($iter, String).chars().collect::<Vec<char>>()\n };\n ($iter:expr, bytes) => {\n read_value!($iter, String).bytes().collect::<Vec<u8>>()\n };\n ($iter:expr, usize1) => {\n read_value!($iter, usize) - 1\n };\n ($iter:expr, $t:ty) => {\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n//\n\n// \u6642\u7a7a\u9593Mo\n// \u5e45N, \u6c42\u5024X, \u66f4\u65b0Y \u3068\u7f6e\u304f\n// \u30d6\u30ed\u30c3\u30af\u30b5\u30a4\u30ba\u3092B\u3068\u3057\u305f\u3068\u304d\u306e\u8a08\u7b97\u91cf\u306f\uff1f\n//\n// 1/2 \u3068\u304b\u7121\u8996\u3057\u3066\n//\n// \u66f4\u65b0\u56de\u6570: (N / B) ^ 2 * Y\n// \u30dd\u30a4\u30f3\u30bf\u3092\u52d5\u304b\u3059\u56de\u6570 X * B\n//\n// \u521d\u671f\u5316\u306e\u8a08\u7b97\u91cf\u3082\u3044\u308b\uff1f (N / B) ^ 2 * N\n// dF/dB = X - (1 / 2) * (N^2 * Y + N^3) / B^3\n// = (2 * X * B^3 - (N^2 * Y + N^3)) / B^3\n// 2\u306e\u9805\u3092\u7121\u8996\u3057\u3066\uff1f\n// B = ((N^2 * Y + N^3) / X) ^ (2 / 3)\n// X = Y = Q\n// B = (N^2 + N^3 / Q) ^ (2 / 3)\n\nuse std::io::Write;\n\nstruct State {\n cnt: Vec<usize>,\n elem: Vec<usize>,\n mex: usize,\n}\n\nimpl State {\n fn new(n: usize) -> Self {\n let mut state = State {\n cnt: vec![0; n + 1],\n elem: vec![0; n + 1],\n mex: 0,\n };\n state.init();\n state\n }\n fn init(&mut self) {\n let len = self.cnt.len();\n self.cnt.clear();\n self.cnt.resize(len, 0);\n self.elem.clear();\n self.elem.resize(len, 0);\n self.elem[0] = len;\n self.mex = 1;\n }\n fn insert(&mut self, x: usize) {\n let c = &mut self.cnt[x];\n self.elem[*c] -= 1;\n *c += 1;\n self.elem[*c] += 1;\n let p = &mut self.mex;\n if self.elem[*c - 1] == 0 && *c - 1 < *p {\n *p = *c - 1;\n }\n while self.elem[*p] > 0 {\n *p += 1;\n }\n }\n fn delete(&mut self, x: usize) {\n let c = &mut self.cnt[x];\n self.elem[*c] -= 1;\n *c -= 1;\n self.elem[*c] += 1;\n let p = &mut self.mex;\n if self.elem[*c + 1] == 0 && *c + 1 < *p {\n *p = *c + 1;\n }\n while self.elem[*p] > 0 {\n *p += 1;\n }\n }\n fn find(&self) -> usize {\n self.mex\n }\n}\n\nfn run() {\n input! {\n n: usize,\n q: usize,\n a: [usize; n],\n ask: [(u8, usize1, usize); q],\n }\n let mut z = a.clone();\n for &(_, _, x) in ask.iter().filter(|p| p.0 == 2) {\n z.push(x);\n }\n z.sort();\n z.dedup();\n let mut a = a;\n for a in a.iter_mut() {\n *a = z.binary_search(a).unwrap();\n }\n let mut ask = ask;\n for p in ask.iter_mut().filter(|p| p.0 == 2) {\n p.2 = z.binary_search(&p.2).unwrap();\n }\n let batch = {\n 2154\n /*\n let n = n as f64;\n let q = q as f64;\n (n.powi(2) + n.powi(3) / q).cbrt().powi(2) as usize\n */\n };\n let mut update = vec![];\n let mut query = vec![vec![vec![]; n / batch + 1]; n / batch + 1];\n for (i, (op, a, b)) in ask.into_iter().enumerate() {\n if op == 1 {\n query[a / batch][b / batch].push((a, b, i));\n } else {\n update.push((a, b, i));\n }\n }\n let mut ans = vec![0; q];\n let mut state = State::new(z.len() + n);\n for (i, q) in query.iter().enumerate() {\n for q in q.iter() {\n if q.is_empty() {\n continue;\n }\n state.init();\n let mut a = a.clone();\n let mut x = i * batch;\n let mut y = i * batch;\n let mut z = 0;\n for &(l, r, k) in q.iter() {\n while z < update.len() && update[z].2 < k {\n let p = update[z].0;\n let v = update[z].1;\n if x <= p && p < y {\n state.delete(a[p]);\n state.insert(v);\n }\n a[p] = v;\n z += 1;\n }\n while l < x {\n x -= 1;\n state.insert(a[x]);\n }\n while y < r {\n state.insert(a[y]);\n y += 1;\n }\n while x < l {\n state.delete(a[x]);\n x += 1;\n }\n while r < y {\n y -= 1;\n state.delete(a[y]);\n }\n ans[k] = state.find();\n }\n }\n }\n let out = std::io::stdout();\n let mut out = std::io::BufWriter::new(out.lock());\n for a in ans {\n if a > 0 {\n writeln!(out, \"{}\", a).ok();\n }\n }\n}\n\nfn main() {\n run();\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "cf551eff198b533729c493e16a085969", "src_uid": "eb6362941b5186d20721c99fb4808d52", "difficulty": 2600}
- {"lang": "Rust", "source_code": "use std::io;\n\n\nfn main() {\n let (_, k) = {\n let i = read::<usize>();\n (i[0], i[1])\n };\n let mut an = read::<usize>();\n an.sort();\n\n let ans = if k == 0 { an[0] - 1 } else { an[k - 1] };\n\n let mut cnt = 0;\n for a in an {\n if a <= ans { cnt += 1; }\n }\n\n if cnt != k || !(1 <= ans && ans <= 10e9 as usize) {\n println!(\"-1\"); return;\n }\n println!(\"{}\", ans);\n}\n\n\n#[allow(dead_code)]\nfn read<T>() -> Vec<T>\nwhere T:\nstd::str::FromStr,\nT::Err: std::fmt::Debug {\n\n let mut buf = String::new();\n io::stdin().read_line(&mut buf).unwrap();\n buf.split_whitespace()\n .map(|s| s.trim().parse().unwrap())\n .collect()\n}\n\n#[allow(dead_code)]\nfn read_one<T>() -> T\nwhere T:\nstd::str::FromStr,\nT::Err: std::fmt::Debug {\n\n let mut buf = String::new();\n io::stdin().read_line(&mut buf).unwrap();\n buf.trim().parse().unwrap()\n}", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "0d195fa54637b168f210a8b2b619a10c", "src_uid": "55297e2a65144323af4d6abd6a6ef050", "difficulty": 1200}
- {"lang": "Rust", "source_code": "//spnauti-rusT\nuse std::io::*;\nuse std::str::{self,*};\nuse std::fmt::Debug;\n#[allow(unused_imports)] use std::cmp::Ordering::{self,*};\n#[allow(unused_imports)] use std::ops::{self,*};\n#[allow(unused_imports)] use std::iter::{self,*};\n#[allow(unused_imports)] use std::collections::*;\n#[allow(unused_macros)]\nmacro_rules! m {\n ($c:tt, $x:expr, $y:expr) => {{\n let b = $y; let a = &mut $x;\n if b $c *a { *a = b; true } else { false }\n }};\n}\n#[allow(unused_macros)]\nmacro_rules! l {\n ($($v:ident),* = $i:ident.$f:ident $a:tt) => {\n $( let $v = $i.$f$a; )*\n };\n ($($v:ident),*:$t:ty = $i:ident.$f:ident $a:tt) => {\n $( let $v:$t = $i.$f$a; )*\n };\n}\nstruct WordReader<'a> { it : SplitAsciiWhitespace<'a> }\n#[allow(dead_code)]\nimpl<'a> WordReader<'a> {\n fn new<T: Read>(b: &mut String, mut r: T) -> WordReader {\n b.clear();\n r.read_to_string(b).ok();\n WordReader { it: b.split_ascii_whitespace() }\n }\n fn from_stdin(b: &mut String) -> WordReader {\n WordReader::new(b, stdin())\n }\n fn sl(&mut self) -> &str { self.it.next().unwrap() }\n fn bs(&mut self) -> &[u8] { self.sl().as_bytes() }\n fn s(&mut self) -> String { String::from(self.sl()) }\n fn i(&mut self) -> i32 { self.p() }\n fn f(&mut self) -> f64 { self.p() }\n fn u(&mut self) -> usize { self.p() }\n fn sk(&mut self, n: usize) { self.it.nth(n - 1); }\n fn ii(&mut self, n: usize) -> impl Iterator<Item=i32> {\n self.ip(n).into_iter()\n }\n fn vi(&mut self, n: usize) -> Vec<i32> {\n self.vp::<i32>(n)\n }\n fn p<T: FromStr>(&mut self) -> T where T::Err: Debug {\n self.sl().parse::<T>().unwrap()\n }\n fn ip<T: FromStr>(&mut self, n: usize) -> impl Iterator<Item=T> where T::Err: Debug {\n self.vp(n).into_iter()\n }\n fn vp<T: FromStr>(&mut self, n: usize) -> Vec<T> where T::Err: Debug {\n (0..n).map(|_| self.p()).collect()\n }\n}\n//------------------- End rusT\n\nfn main() {\n let mut bin = String::new();\n let mut input = WordReader::from_stdin(&mut bin);\n\n let n = input.u();\n let k = input.u();\n let mut a = input.vi(n);\n a.sort();\n if (k == 0 && a[0] == 1) || (k < n && a[k - 1] == a[k]) {\n println!(\"-1\");\n } else if k == 0{\n println!(\"1\");\n } else {\n println!(\"{}\", a[k - 1]);\n }\n}\n\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "794415695fbf8b1b4f9f695e6a00d844", "src_uid": "55297e2a65144323af4d6abd6a6ef050", "difficulty": 1200}
- {"lang": "Rust", "source_code": "//spnauti-rusT\nuse std::io::*;\nuse std::str::{self,*};\nuse std::fmt::Debug;\n#[allow(unused_imports)] use std::cmp::Ordering::{self,*};\n#[allow(unused_imports)] use std::ops::{self,*};\n#[allow(unused_imports)] use std::iter::{self,*};\n#[allow(unused_imports)] use std::collections::*;\n#[allow(unused_macros)]\nmacro_rules! m {\n ($c:tt, $x:expr, $y:expr) => {{\n let b = $y; let a = &mut $x;\n if b $c *a { *a = b; true } else { false }\n }};\n}\n#[allow(unused_macros)]\nmacro_rules! l {\n ($($v:ident),* = $i:ident.$f:ident $a:tt) => {\n $( let $v = $i.$f$a; )*\n };\n ($($v:ident),*:$t:ty = $i:ident.$f:ident $a:tt) => {\n $( let $v:$t = $i.$f$a; )*\n };\n}\nstruct WordReader<'a> { it : SplitAsciiWhitespace<'a> }\n#[allow(dead_code)]\nimpl<'a> WordReader<'a> {\n fn new<T: Read>(b: &mut String, mut r: T) -> WordReader {\n b.clear();\n r.read_to_string(b).ok();\n WordReader { it: b.split_ascii_whitespace() }\n }\n fn from_stdin(b: &mut String) -> WordReader {\n WordReader::new(b, stdin())\n }\n fn sl(&mut self) -> &str { self.it.next().unwrap() }\n fn bs(&mut self) -> &[u8] { self.sl().as_bytes() }\n fn s(&mut self) -> String { String::from(self.sl()) }\n fn i(&mut self) -> i32 { self.p() }\n fn f(&mut self) -> f64 { self.p() }\n fn u(&mut self) -> usize { self.p() }\n fn sk(&mut self, n: usize) { self.it.nth(n - 1); }\n fn ii(&mut self, n: usize) -> impl Iterator<Item=i32> {\n self.ip(n).into_iter()\n }\n fn vi(&mut self, n: usize) -> Vec<i32> {\n self.vp::<i32>(n)\n }\n fn p<T: FromStr>(&mut self) -> T where T::Err: Debug {\n self.sl().parse::<T>().unwrap()\n }\n fn ip<T: FromStr>(&mut self, n: usize) -> impl Iterator<Item=T> where T::Err: Debug {\n self.vp(n).into_iter()\n }\n fn vp<T: FromStr>(&mut self, n: usize) -> Vec<T> where T::Err: Debug {\n (0..n).map(|_| self.p()).collect()\n }\n}\n//------------------- End rusT\n\nfn main() {\n let mut bin = String::new();\n let mut input = WordReader::from_stdin(&mut bin);\n\n let n = input.u();\n let k = input.u();\n let mut a = input.vi(n);\n a.sort();\n if (k == 0 && a[0] == 1) || (k > 0 && k < n && a[k - 1] == a[k]) {\n println!(\"-1\");\n } else if k == 0 {\n println!(\"1\");\n } else {\n println!(\"{}\", a[k - 1]);\n }\n}\n\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "aa5c9f4696b075de7aa32cd4d6a85563", "src_uid": "55297e2a65144323af4d6abd6a6ef050", "difficulty": 1200}
- {"lang": "Rust", "source_code": "#![allow(unused_imports)]\n#![allow(unused_macros)]\n#![allow(dead_code)]\n#![allow(unused_labels)]\n\nuse std::char::*;\nuse std::cmp::*;\nuse std::collections::*;\nuse std::io::*;\nuse std::str::FromStr;\n\nmacro_rules! debug {($($a:expr),*) => {eprintln!(concat!($(stringify!($a), \" = {:?}, \"),*), $($a),*);}}\nmacro_rules! input { ( source = $ s : expr , $ ( $ r : tt ) * ) => { let mut iter = $ s . split_whitespace ( ) ; let mut next = || { iter . next ( ) . unwrap ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; ( $ ( $ r : tt ) * ) => { let stdin = std :: io :: stdin ( ) ; let mut bytes = std :: io :: Read :: bytes ( std :: io :: BufReader :: new ( stdin . lock ( ) ) ) ; let mut next = move || -> String { bytes . by_ref ( ) . map ( | r | r . unwrap ( ) as char ) . skip_while ( | c | c . is_whitespace ( ) ) . take_while ( | c |! c . is_whitespace ( ) ) . collect ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; }\nmacro_rules! input_inner { ( $ next : expr ) => { } ; ( $ next : expr , ) => { } ; ( $ next : expr , $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let $ var = read_value ! ( $ next , $ t ) ; input_inner ! { $ next $ ( $ r ) * } } ; }\nmacro_rules! read_value { ( $ next : expr , ( $ ( $ t : tt ) ,* ) ) => { ( $ ( read_value ! ( $ next , $ t ) ) ,* ) } ; ( $ next : expr , [ $ t : tt ; $ len : expr ] ) => { ( 0 ..$ len ) . map ( | _ | read_value ! ( $ next , $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ next : expr , chars ) => { read_value ! ( $ next , String ) . chars ( ) . collect ::< Vec < char >> ( ) } ; ( $ next : expr , usize1 ) => { read_value ! ( $ next , usize ) - 1 } ; ( $ next : expr , $ t : ty ) => { $ next ( ) . parse ::<$ t > ( ) . expect ( \"Parse error\" ) } ; }\n\n\nfn read<T: FromStr>() -> T {\n let stdin = stdin();\n let stdin = stdin.lock();\n let token: String = stdin\n .bytes()\n .map(|c| c.expect(\"failed to read char\") as char)\n .skip_while(|c| c.is_whitespace())\n .take_while(|c| !c.is_whitespace())\n .collect();\n token.parse().ok().expect(\"failed to parse token\")\n}\n\nuse std::f64;\n\nfn min<T: PartialOrd>(a:T, b:T) -> T {\n if a < b { a }\n else { b }\n}\n\nfn max<T: PartialOrd>(a:T, b:T) -> T {\n if a < b { b }\n else { a }\n}\n\nconst MAX:usize = 30;\nconst INF:i64 = std::i64::MAX;\nconst MOD:i64 = 1e9 as i64 + 7;\n\nstruct Graph {\n e: Vec<Vec<usize>>,\n v: Vec<usize>,\n u: Vec<usize>,\n f: Vec<bool>,\n c: i64,\n vc: Vec<i64>,\n}\n\nimpl Graph {\n fn new(n:usize) -> Self {\n Graph {\n e: vec![vec![];n],\n v: vec![],\n u: vec![n;n],\n f: vec![false;n],\n c: 0,\n vc: vec![0;n],\n }\n }\n\n fn dfs(&mut self, crt: usize) {\n if self.f[crt] { return; }\n self.c += 1;\n self.f[crt] = true;\n self.v.push(crt);\n self.vc[crt] = self.c;\n self.u[crt] = self.v.len()-1;\n for i in 0..self.e[crt].len() {\n self.dfs(self.e[crt][i]);\n }\n //debug!(crt, self.c, self.vc[crt]);\n self.vc[crt] = self.c - self.vc[crt];\n }\n}\n\nfn binary_search(s: &Vec<i64>, v:i64) -> usize {\n let mut left = 0;\n let mut right = s.len();\n\n while right-left > 1 {\n let mid = (right+left)/2;\n //debug!(left,mid,right,s[mid]);\n if s[mid] < v { left = mid; }\n else { right = mid; }\n }\n left\n}\n\nfn main() {\n //let t:usize = read();\n\n //'outer: for _ in 0..t {\n let n:usize = read();\n let k:usize = read();\n let mut a:Vec<i64> = (0..n).map(|_| read()).collect();\n\n a.sort();\n\n if a[k-1] == a[k] {\n println!(\"-1\");\n } else {\n println!(\"{}\", a[k-1]);\n }\n\n //}\n}\n\n/*\n\n\n*/\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "c9f5ff0d0176504510b4c0b39d298576", "src_uid": "55297e2a65144323af4d6abd6a6ef050", "difficulty": 1200}
- {"lang": "Rust", "source_code": "#![allow(unused_imports)]\n#![allow(unused_macros)]\n#![allow(dead_code)]\n#![allow(unused_labels)]\n\nuse std::char::*;\nuse std::cmp::*;\nuse std::collections::*;\nuse std::io::*;\nuse std::str::FromStr;\n\nmacro_rules! debug {($($a:expr),*) => {eprintln!(concat!($(stringify!($a), \" = {:?}, \"),*), $($a),*);}}\nmacro_rules! input { ( source = $ s : expr , $ ( $ r : tt ) * ) => { let mut iter = $ s . split_whitespace ( ) ; let mut next = || { iter . next ( ) . unwrap ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; ( $ ( $ r : tt ) * ) => { let stdin = std :: io :: stdin ( ) ; let mut bytes = std :: io :: Read :: bytes ( std :: io :: BufReader :: new ( stdin . lock ( ) ) ) ; let mut next = move || -> String { bytes . by_ref ( ) . map ( | r | r . unwrap ( ) as char ) . skip_while ( | c | c . is_whitespace ( ) ) . take_while ( | c |! c . is_whitespace ( ) ) . collect ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; }\nmacro_rules! input_inner { ( $ next : expr ) => { } ; ( $ next : expr , ) => { } ; ( $ next : expr , $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let $ var = read_value ! ( $ next , $ t ) ; input_inner ! { $ next $ ( $ r ) * } } ; }\nmacro_rules! read_value { ( $ next : expr , ( $ ( $ t : tt ) ,* ) ) => { ( $ ( read_value ! ( $ next , $ t ) ) ,* ) } ; ( $ next : expr , [ $ t : tt ; $ len : expr ] ) => { ( 0 ..$ len ) . map ( | _ | read_value ! ( $ next , $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ next : expr , chars ) => { read_value ! ( $ next , String ) . chars ( ) . collect ::< Vec < char >> ( ) } ; ( $ next : expr , usize1 ) => { read_value ! ( $ next , usize ) - 1 } ; ( $ next : expr , $ t : ty ) => { $ next ( ) . parse ::<$ t > ( ) . expect ( \"Parse error\" ) } ; }\n\n\nfn read<T: FromStr>() -> T {\n let stdin = stdin();\n let stdin = stdin.lock();\n let token: String = stdin\n .bytes()\n .map(|c| c.expect(\"failed to read char\") as char)\n .skip_while(|c| c.is_whitespace())\n .take_while(|c| !c.is_whitespace())\n .collect();\n token.parse().ok().expect(\"failed to parse token\")\n}\n\nuse std::f64;\n\nfn min<T: PartialOrd>(a:T, b:T) -> T {\n if a < b { a }\n else { b }\n}\n\nfn max<T: PartialOrd>(a:T, b:T) -> T {\n if a < b { b }\n else { a }\n}\n\nconst MAX:usize = 30;\nconst INF:i64 = std::i64::MAX;\nconst MOD:i64 = 1e9 as i64 + 7;\n\nstruct Graph {\n e: Vec<Vec<usize>>,\n v: Vec<usize>,\n u: Vec<usize>,\n f: Vec<bool>,\n c: i64,\n vc: Vec<i64>,\n}\n\nimpl Graph {\n fn new(n:usize) -> Self {\n Graph {\n e: vec![vec![];n],\n v: vec![],\n u: vec![n;n],\n f: vec![false;n],\n c: 0,\n vc: vec![0;n],\n }\n }\n\n fn dfs(&mut self, crt: usize) {\n if self.f[crt] { return; }\n self.c += 1;\n self.f[crt] = true;\n self.v.push(crt);\n self.vc[crt] = self.c;\n self.u[crt] = self.v.len()-1;\n for i in 0..self.e[crt].len() {\n self.dfs(self.e[crt][i]);\n }\n //debug!(crt, self.c, self.vc[crt]);\n self.vc[crt] = self.c - self.vc[crt];\n }\n}\n\nfn binary_search(s: &Vec<i64>, v:i64) -> usize {\n let mut left = 0;\n let mut right = s.len();\n\n while right-left > 1 {\n let mid = (right+left)/2;\n //debug!(left,mid,right,s[mid]);\n if s[mid] < v { left = mid; }\n else { right = mid; }\n }\n left\n}\n\nfn main() {\n //let t:usize = read();\n\n //'outer: for _ in 0..t {\n let n:usize = read();\n let k:usize = read();\n let mut a:Vec<i64> = (0..n).map(|_| read()).collect();\n\n a.sort();\n if k == 0 {\n if a[0] == 1 {\n println!(\"-1\");\n } else {\n println!(\"1\");\n }\n return;\n }\n if k == n {\n println!(\"{}\", a[k-1]);\n return;\n }\n\n if a[k-1] == a[k] {\n println!(\"-1\");\n } else {\n println!(\"{}\", a[k-1]);\n }\n\n //}\n}\n\n/*\n\n\n*/\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "a08d9c584e1fc2221b741e30811e84b5", "src_uid": "55297e2a65144323af4d6abd6a6ef050", "difficulty": 1200}
- {"lang": "Rust", "source_code": "#![allow(unused_imports)]\n#![allow(unused_macros)]\n#![allow(dead_code)]\n#![allow(unused_labels)]\n\nuse std::char::*;\nuse std::cmp::*;\nuse std::collections::*;\nuse std::io::*;\nuse std::str::FromStr;\n\nmacro_rules! debug {($($a:expr),*) => {eprintln!(concat!($(stringify!($a), \" = {:?}, \"),*), $($a),*);}}\nmacro_rules! input { ( source = $ s : expr , $ ( $ r : tt ) * ) => { let mut iter = $ s . split_whitespace ( ) ; let mut next = || { iter . next ( ) . unwrap ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; ( $ ( $ r : tt ) * ) => { let stdin = std :: io :: stdin ( ) ; let mut bytes = std :: io :: Read :: bytes ( std :: io :: BufReader :: new ( stdin . lock ( ) ) ) ; let mut next = move || -> String { bytes . by_ref ( ) . map ( | r | r . unwrap ( ) as char ) . skip_while ( | c | c . is_whitespace ( ) ) . take_while ( | c |! c . is_whitespace ( ) ) . collect ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; }\nmacro_rules! input_inner { ( $ next : expr ) => { } ; ( $ next : expr , ) => { } ; ( $ next : expr , $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let $ var = read_value ! ( $ next , $ t ) ; input_inner ! { $ next $ ( $ r ) * } } ; }\nmacro_rules! read_value { ( $ next : expr , ( $ ( $ t : tt ) ,* ) ) => { ( $ ( read_value ! ( $ next , $ t ) ) ,* ) } ; ( $ next : expr , [ $ t : tt ; $ len : expr ] ) => { ( 0 ..$ len ) . map ( | _ | read_value ! ( $ next , $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ next : expr , chars ) => { read_value ! ( $ next , String ) . chars ( ) . collect ::< Vec < char >> ( ) } ; ( $ next : expr , usize1 ) => { read_value ! ( $ next , usize ) - 1 } ; ( $ next : expr , $ t : ty ) => { $ next ( ) . parse ::<$ t > ( ) . expect ( \"Parse error\" ) } ; }\n\n\nfn read<T: FromStr>() -> T {\n let stdin = stdin();\n let stdin = stdin.lock();\n let token: String = stdin\n .bytes()\n .map(|c| c.expect(\"failed to read char\") as char)\n .skip_while(|c| c.is_whitespace())\n .take_while(|c| !c.is_whitespace())\n .collect();\n token.parse().ok().expect(\"failed to parse token\")\n}\n\nuse std::f64;\n\nfn min<T: PartialOrd>(a:T, b:T) -> T {\n if a < b { a }\n else { b }\n}\n\nfn max<T: PartialOrd>(a:T, b:T) -> T {\n if a < b { b }\n else { a }\n}\n\nconst MAX:usize = 30;\nconst INF:i64 = std::i64::MAX;\nconst MOD:i64 = 1e9 as i64 + 7;\n\nstruct Graph {\n e: Vec<Vec<usize>>,\n v: Vec<usize>,\n u: Vec<usize>,\n f: Vec<bool>,\n c: i64,\n vc: Vec<i64>,\n}\n\nimpl Graph {\n fn new(n:usize) -> Self {\n Graph {\n e: vec![vec![];n],\n v: vec![],\n u: vec![n;n],\n f: vec![false;n],\n c: 0,\n vc: vec![0;n],\n }\n }\n\n fn dfs(&mut self, crt: usize) {\n if self.f[crt] { return; }\n self.c += 1;\n self.f[crt] = true;\n self.v.push(crt);\n self.vc[crt] = self.c;\n self.u[crt] = self.v.len()-1;\n for i in 0..self.e[crt].len() {\n self.dfs(self.e[crt][i]);\n }\n //debug!(crt, self.c, self.vc[crt]);\n self.vc[crt] = self.c - self.vc[crt];\n }\n}\n\nfn binary_search(s: &Vec<i64>, v:i64) -> usize {\n let mut left = 0;\n let mut right = s.len();\n\n while right-left > 1 {\n let mid = (right+left)/2;\n //debug!(left,mid,right,s[mid]);\n if s[mid] < v { left = mid; }\n else { right = mid; }\n }\n left\n}\n\nfn main() {\n //let t:usize = read();\n\n //'outer: for _ in 0..t {\n let n:usize = read();\n let k:usize = read();\n let mut a:Vec<i64> = (0..n).map(|_| read()).collect();\n\n a.sort();\n if k == 0 {\n println!(\"0\");\n return;\n }\n if k == n {\n println!(\"{}\", a[k-1]);\n return;\n }\n\n if a[k-1] == a[k] {\n println!(\"-1\");\n } else {\n println!(\"{}\", a[k-1]);\n }\n\n //}\n}\n\n/*\n\n\n*/\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "c70ba88514f51b3f143e4ac643e82d1f", "src_uid": "55297e2a65144323af4d6abd6a6ef050", "difficulty": 1200}
- {"lang": "Rust", "source_code": "#![allow(unused_imports)]\n#![allow(unused_macros)]\n#![allow(dead_code)]\n#![allow(unused_labels)]\n\nuse std::char::*;\nuse std::cmp::*;\nuse std::collections::*;\nuse std::io::*;\nuse std::str::FromStr;\n\nmacro_rules! debug {($($a:expr),*) => {eprintln!(concat!($(stringify!($a), \" = {:?}, \"),*), $($a),*);}}\nmacro_rules! input { ( source = $ s : expr , $ ( $ r : tt ) * ) => { let mut iter = $ s . split_whitespace ( ) ; let mut next = || { iter . next ( ) . unwrap ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; ( $ ( $ r : tt ) * ) => { let stdin = std :: io :: stdin ( ) ; let mut bytes = std :: io :: Read :: bytes ( std :: io :: BufReader :: new ( stdin . lock ( ) ) ) ; let mut next = move || -> String { bytes . by_ref ( ) . map ( | r | r . unwrap ( ) as char ) . skip_while ( | c | c . is_whitespace ( ) ) . take_while ( | c |! c . is_whitespace ( ) ) . collect ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; }\nmacro_rules! input_inner { ( $ next : expr ) => { } ; ( $ next : expr , ) => { } ; ( $ next : expr , $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let $ var = read_value ! ( $ next , $ t ) ; input_inner ! { $ next $ ( $ r ) * } } ; }\nmacro_rules! read_value { ( $ next : expr , ( $ ( $ t : tt ) ,* ) ) => { ( $ ( read_value ! ( $ next , $ t ) ) ,* ) } ; ( $ next : expr , [ $ t : tt ; $ len : expr ] ) => { ( 0 ..$ len ) . map ( | _ | read_value ! ( $ next , $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ next : expr , chars ) => { read_value ! ( $ next , String ) . chars ( ) . collect ::< Vec < char >> ( ) } ; ( $ next : expr , usize1 ) => { read_value ! ( $ next , usize ) - 1 } ; ( $ next : expr , $ t : ty ) => { $ next ( ) . parse ::<$ t > ( ) . expect ( \"Parse error\" ) } ; }\n\n\nfn read<T: FromStr>() -> T {\n let stdin = stdin();\n let stdin = stdin.lock();\n let token: String = stdin\n .bytes()\n .map(|c| c.expect(\"failed to read char\") as char)\n .skip_while(|c| c.is_whitespace())\n .take_while(|c| !c.is_whitespace())\n .collect();\n token.parse().ok().expect(\"failed to parse token\")\n}\n\nuse std::f64;\n\nfn min<T: PartialOrd>(a:T, b:T) -> T {\n if a < b { a }\n else { b }\n}\n\nfn max<T: PartialOrd>(a:T, b:T) -> T {\n if a < b { b }\n else { a }\n}\n\nconst MAX:usize = 30;\nconst INF:i64 = std::i64::MAX;\nconst MOD:i64 = 1e9 as i64 + 7;\n\nstruct Graph {\n e: Vec<Vec<usize>>,\n v: Vec<usize>,\n u: Vec<usize>,\n f: Vec<bool>,\n c: i64,\n vc: Vec<i64>,\n}\n\nimpl Graph {\n fn new(n:usize) -> Self {\n Graph {\n e: vec![vec![];n],\n v: vec![],\n u: vec![n;n],\n f: vec![false;n],\n c: 0,\n vc: vec![0;n],\n }\n }\n\n fn dfs(&mut self, crt: usize) {\n if self.f[crt] { return; }\n self.c += 1;\n self.f[crt] = true;\n self.v.push(crt);\n self.vc[crt] = self.c;\n self.u[crt] = self.v.len()-1;\n for i in 0..self.e[crt].len() {\n self.dfs(self.e[crt][i]);\n }\n //debug!(crt, self.c, self.vc[crt]);\n self.vc[crt] = self.c - self.vc[crt];\n }\n}\n\nfn binary_search(s: &Vec<i64>, v:i64) -> usize {\n let mut left = 0;\n let mut right = s.len();\n\n while right-left > 1 {\n let mid = (right+left)/2;\n //debug!(left,mid,right,s[mid]);\n if s[mid] < v { left = mid; }\n else { right = mid; }\n }\n left\n}\n\nfn main() {\n //let t:usize = read();\n\n //'outer: for _ in 0..t {\n let n:usize = read();\n let k:usize = read();\n let mut a:Vec<i64> = (0..n).map(|_| read()).collect();\n\n a.sort();\n if k == n {\n println!(\"{}\", a[k-1]);\n return;\n }\n\n if a[k-1] == a[k] {\n println!(\"-1\");\n } else {\n println!(\"{}\", a[k-1]);\n }\n\n //}\n}\n\n/*\n\n\n*/\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "5052963af4c57db30abac8de2b25ff20", "src_uid": "55297e2a65144323af4d6abd6a6ef050", "difficulty": 1200}
- {"lang": "Rust", "source_code": "#[allow(dead_code)]\nuse std::cmp::min;\nuse std::collections::HashMap;\nuse std::io;\nuse std::str::FromStr;\nuse std::io::Read;\n\nstruct Input {\n tokens: <std::vec::Vec<std::string::String> as IntoIterator>::IntoIter,\n read_all: bool,\n}\n\nimpl Input {\n pub fn new(read_all: bool) -> Input {\n if read_all {\n let mut all = String::new();\n io::stdin().read_to_string(&mut all).unwrap();\n let tokens: Vec<String> = all.split_whitespace().map(|s| s.to_string()).collect();\n Input {\n tokens: tokens.into_iter(),\n read_all: true,\n }\n } else {\n Input {\n tokens: vec!().into_iter(),\n read_all: false,\n }\n }\n }\n\n fn refresh_next_line(&mut self) {\n if self.read_all {\n panic!();\n }\n let mut buf = String::new();\n io::stdin().read_line(&mut buf).unwrap();\n let tokens: Vec<String> = buf.split_whitespace().map(|s| s.to_string()).collect();\n self.tokens = tokens.into_iter();\n }\n\n fn next_impl(&mut self) -> String {\n loop {\n if let Some(next) = self.tokens.next() {\n return next.to_string();\n }\n self.refresh_next_line();\n }\n }\n\n pub fn next<T: FromStr>(&mut self) -> T where <T as std::str::FromStr>::Err: std::fmt::Debug {\n let next_str = self.next_impl();\n next_str.parse().unwrap()\n }\n\n pub fn next_vec<T: FromStr>(&mut self, len: usize) -> Vec<T> where <T as std::str::FromStr>::Err: std::fmt::Debug {\n (0..len).map(|_i| self.next()).collect()\n }\n\n pub fn next_vec_read_len<T: FromStr>(&mut self) -> Vec<T> where <T as std::str::FromStr>::Err: std::fmt::Debug {\n let len = self.next();\n self.next_vec(len)\n }\n}\n\nfn main() {\n let mut input = Input::new(false);\n let n: usize = input.next();\n let k: usize = input.next();\n let mut a: Vec<i32> = input.next_vec(n);\n a.sort();\n let answer;\n if k == 0 {\n answer = if a[0] == 1 { -1 } else { 1 };\n } else if k == n {\n answer = a[n - 1];\n } else {\n answer = if a[k - 1] == a[k] { -1 } else { a[k - 1] };\n }\n println!(\"{}\", answer);\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "11a816026e4c4e6807e9312cfceb08ab", "src_uid": "55297e2a65144323af4d6abd6a6ef050", "difficulty": 1200}
- {"lang": "Rust", "source_code": "struct Scan {\n buffer: std::collections::VecDeque<String>,\n}\n\nimpl Scan {\n fn new() -> Scan {\n Scan {\n buffer: std::collections::VecDeque::new(),\n }\n }\n\n fn next<T: std::str::FromStr>(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop_front() {\n break token.parse::<T>().ok().unwrap();\n }\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).expect(\"Fail to read\");\n self.buffer = line.split_whitespace().map(String::from).collect();\n }\n }\n\n fn next_n<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {\n (0..n).map(|_| self.next::<T>()).collect()\n }\n}\n\nfn _main() {\n let mut scan = Scan::new();\n let n: usize = scan.next();\n let k: usize = scan.next();\n let mut arr: Vec<usize> = scan.next_n(n);\n arr.sort();\n if k == n {\n println!(\"{}\", arr[n - 1]);\n return;\n }\n if k == 0 {\n if arr[0] == 1 {\n println!(\"-1\");\n } else {\n println!(\"{}\", arr[0] - 1);\n }\n return;\n }\n if arr[k - 1] != arr[k] {\n println!(\"{}\", arr[k - 1]);\n } else {\n println!(\"-1\");\n }\n}\n\nfn main() {\n std::thread::Builder::new()\n .stack_size(1 << 23)\n .spawn(_main)\n .unwrap()\n .join()\n .unwrap();\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "a2ef8b0dcfd6c938d91621dc8e15c48f", "src_uid": "55297e2a65144323af4d6abd6a6ef050", "difficulty": 1200}
- {"lang": "Rust", "source_code": "macro_rules! parse_line {\n ($t: ty) => ({\n let mut a_str = String::new();\n std::io::stdin().read_line(&mut a_str).expect(\"read error\");\n let a_str = a_str.trim();\n a_str.parse::<$t>().expect(\"parse error\")\n });\n ($($t: ty),+) => ({\n let mut a_str = String::new();\n std::io::stdin().read_line(&mut a_str).expect(\"read error\");\n let mut a_iter = a_str.split_whitespace();\n (\n $(\n a_iter.next().unwrap().parse::<$t>().expect(\"parse error\"),\n )+\n )\n })\n}\n\n#[allow(unused_macros)]\nmacro_rules! parse_line_to_vec {\n ($t: ty) => {{\n let mut a_str = String::new();\n std::io::stdin().read_line(&mut a_str).expect(\"read error\");\n (a_str\n .split_whitespace()\n .map(|x| x.parse::<$t>().unwrap())\n .collect::<Vec<$t>>())\n }};\n}\n\nuse std::io::Write;\n\nfn solve(writer: &mut std::io::BufWriter<std::io::Stdout>) {\n let (n, k) = parse_line!(usize, usize);\n let mut a = parse_line_to_vec!(u32);\n a.sort_unstable();\n if k == 0 {\n if a[0] == 1 {\n writeln!(writer, \"-1\").unwrap();\n }else{\n writeln!(writer, \"1\").unwrap();\n }\n return;\n }\n if k == n {\n writeln!(writer, \"{}\", a[n - 1]).unwrap();\n return;\n }\n if a[k] == a[k - 1] {\n writeln!(writer, \"-1\").unwrap();\n }else{\n writeln!(writer, \"{}\", a[k - 1]).unwrap();\n }\n}\n\nfn main() {\n let mut writer = std::io::BufWriter::new(std::io::stdout());\n let tests = 1; // parse_line!(usize);\n for _ in 0..tests {\n solve(&mut writer);\n }\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "3b6020650f103927fa767c410c92cc5b", "src_uid": "55297e2a65144323af4d6abd6a6ef050", "difficulty": 1200}
- {"lang": "Rust", "source_code": "use std::io::Read;\n\nfn input(read_file: bool) -> String {\n if read_file {\n let mut file = std::fs::File::open(\"sample.txt\").unwrap();\n let mut buf = String::new();\n file.read_to_string(&mut buf).unwrap();\n buf\n } else {\n let mut buf = String::new();\n std::io::stdin().read_to_string(&mut buf).unwrap();\n buf.trim_end().to_owned()\n }\n}\n\nfn solve(ws: &mut std::str::SplitWhitespace) {\n let n: usize = ws.next().unwrap().parse().unwrap();\n let k: usize = ws.next().unwrap().parse().unwrap();\n let mut a = vec![0; n];\n for i in 0..n {\n a[i] = ws.next().unwrap().parse().unwrap();\n }\n\n a.sort();\n\n let mut ans = -1;\n if k == 0 {\n if a[0] != 1 {\n ans = 1;\n }\n } else {\n ans = a[k - 1];\n if k < n && a[k] == ans {\n ans = -1;\n }\n }\n\n println!(\"{}\", ans);\n}\n\nfn main() {\n const READ_FROM_FILE: bool = false;\n\n let s = input(READ_FROM_FILE);\n let mut ws = s.split_whitespace();\n\n solve(&mut ws);\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "256cf10a9bbbc3a17a5a8d550b3347e8", "src_uid": "55297e2a65144323af4d6abd6a6ef050", "difficulty": 1200}
- {"lang": "Rust", "source_code": "use std::io::*;\nuse std::str::FromStr;\n\nfn main() {\n let stdin = stdin();\n let mut sc = Scanner::new(stdin.lock());\n\n let n = sc.next::<usize>();\n let k = sc.next::<usize>();\n let mut a = vec![0; n];\n for i in 0..n {\n a[i] = sc.next::<usize>();\n }\n a.sort();\n if k != 0 && (k == n || a[k - 1] != a[k]) {\n println!(\"{}\", a[k - 1]);\n } else {\n println!(\"-1\");\n }\n}\n\npub struct Scanner<B> {\n reader: B,\n buffer: Vec<String>,\n}\n\nimpl<B: BufRead> Scanner<B> {\n pub fn new(reader: B) -> Self {\n Self {\n reader,\n buffer: Vec::new(),\n }\n }\n\n pub fn next<T: FromStr>(&mut self) -> T\n where\n T::Err: ::std::fmt::Debug,\n {\n if let Some(front) = self.buffer.pop() {\n front.parse::<T>().expect(&front)\n } else {\n let mut input = String::new();\n self.reader.read_line(&mut input).expect(\"Line not read\");\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\n self.next()\n }\n }\n}\n\n// pub trait BinarySearch<T> {\n// fn lower_bound(&self, &T) -> usize;\n// fn upper_bound(&self, &T) -> usize;\n// }\n\n// impl<T: Ord> BinarySearch<T> for [T] {\n// fn lower_bound(&self, x: &T) -> usize {\n// let mut low = 0;\n// let mut high = self.len();\n\n// while low != high {\n// let mid = (low + high) / 2;\n// match self[mid].cmp(x) {\n// std::cmp::Ordering::Less => {\n// low = mid + 1;\n// }\n// std::cmp::Ordering::Equal | std::cmp::Ordering::Greater => {\n// high = mid;\n// }\n// }\n// }\n// low\n// }\n\n// fn upper_bound(&self, x: &T) -> usize {\n// let mut low = 0;\n// let mut high = self.len();\n\n// while low != high {\n// let mid = (low + high) / 2;\n// match self[mid].cmp(x) {\n// std::cmp::Ordering::Less | std::cmp::Ordering::Equal => {\n// low = mid + 1;\n// }\n// std::cmp::Ordering::Greater => {\n// high = mid;\n// }\n// }\n// }\n// low\n// }\n// }\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "f66bb326c1ae519b1a043a4888e5ebd1", "src_uid": "55297e2a65144323af4d6abd6a6ef050", "difficulty": 1200}
- {"lang": "Rust", "source_code": "use std::io::*;\nuse std::str::FromStr;\n\nfn main() {\n let stdin = stdin();\n let mut sc = Scanner::new(stdin.lock());\n\n let n = sc.next::<usize>();\n let k = sc.next::<usize>();\n let mut a = vec![0; n];\n for i in 0..n {\n a[i] = sc.next::<usize>();\n }\n a.sort();\n if k == n || a[k - 1] != a[k] {\n println!(\"{}\", a[k - 1]);\n } else {\n println!(\"-1\");\n }\n}\n\npub struct Scanner<B> {\n reader: B,\n buffer: Vec<String>,\n}\n\nimpl<B: BufRead> Scanner<B> {\n pub fn new(reader: B) -> Self {\n Self {\n reader,\n buffer: Vec::new(),\n }\n }\n\n pub fn next<T: FromStr>(&mut self) -> T\n where\n T::Err: ::std::fmt::Debug,\n {\n if let Some(front) = self.buffer.pop() {\n front.parse::<T>().expect(&front)\n } else {\n let mut input = String::new();\n self.reader.read_line(&mut input).expect(\"Line not read\");\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\n self.next()\n }\n }\n}\n\n// pub trait BinarySearch<T> {\n// fn lower_bound(&self, &T) -> usize;\n// fn upper_bound(&self, &T) -> usize;\n// }\n\n// impl<T: Ord> BinarySearch<T> for [T] {\n// fn lower_bound(&self, x: &T) -> usize {\n// let mut low = 0;\n// let mut high = self.len();\n\n// while low != high {\n// let mid = (low + high) / 2;\n// match self[mid].cmp(x) {\n// std::cmp::Ordering::Less => {\n// low = mid + 1;\n// }\n// std::cmp::Ordering::Equal | std::cmp::Ordering::Greater => {\n// high = mid;\n// }\n// }\n// }\n// low\n// }\n\n// fn upper_bound(&self, x: &T) -> usize {\n// let mut low = 0;\n// let mut high = self.len();\n\n// while low != high {\n// let mid = (low + high) / 2;\n// match self[mid].cmp(x) {\n// std::cmp::Ordering::Less | std::cmp::Ordering::Equal => {\n// low = mid + 1;\n// }\n// std::cmp::Ordering::Greater => {\n// high = mid;\n// }\n// }\n// }\n// low\n// }\n// }\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "876834ab1c2fd5d6bcbf04c4024bb98f", "src_uid": "55297e2a65144323af4d6abd6a6ef050", "difficulty": 1200}
- {"lang": "Rust", "source_code": "use std::io::*;\nuse std::str::FromStr;\n\nfn main() {\n let stdin = stdin();\n let mut sc = Scanner::new(stdin.lock());\n\n let n = sc.next::<usize>();\n let k = sc.next::<usize>();\n let mut a = vec![0; n];\n for i in 0..n {\n a[i] = sc.next::<usize>();\n }\n a.sort();\n if k == 0 && 1 < a[0] {\n println!(\"1\");\n } else if k != 0 && (k == n || a[k - 1] != a[k]) {\n println!(\"{}\", a[k - 1]);\n } else {\n println!(\"-1\");\n }\n}\n\npub struct Scanner<B> {\n reader: B,\n buffer: Vec<String>,\n}\n\nimpl<B: BufRead> Scanner<B> {\n pub fn new(reader: B) -> Self {\n Self {\n reader,\n buffer: Vec::new(),\n }\n }\n\n pub fn next<T: FromStr>(&mut self) -> T\n where\n T::Err: ::std::fmt::Debug,\n {\n if let Some(front) = self.buffer.pop() {\n front.parse::<T>().expect(&front)\n } else {\n let mut input = String::new();\n self.reader.read_line(&mut input).expect(\"Line not read\");\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\n self.next()\n }\n }\n}\n\n// pub trait BinarySearch<T> {\n// fn lower_bound(&self, &T) -> usize;\n// fn upper_bound(&self, &T) -> usize;\n// }\n\n// impl<T: Ord> BinarySearch<T> for [T] {\n// fn lower_bound(&self, x: &T) -> usize {\n// let mut low = 0;\n// let mut high = self.len();\n\n// while low != high {\n// let mid = (low + high) / 2;\n// match self[mid].cmp(x) {\n// std::cmp::Ordering::Less => {\n// low = mid + 1;\n// }\n// std::cmp::Ordering::Equal | std::cmp::Ordering::Greater => {\n// high = mid;\n// }\n// }\n// }\n// low\n// }\n\n// fn upper_bound(&self, x: &T) -> usize {\n// let mut low = 0;\n// let mut high = self.len();\n\n// while low != high {\n// let mid = (low + high) / 2;\n// match self[mid].cmp(x) {\n// std::cmp::Ordering::Less | std::cmp::Ordering::Equal => {\n// low = mid + 1;\n// }\n// std::cmp::Ordering::Greater => {\n// high = mid;\n// }\n// }\n// }\n// low\n// }\n// }\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "08ecef2e461891ab2233d05d6921cc71", "src_uid": "55297e2a65144323af4d6abd6a6ef050", "difficulty": 1200}
- {"lang": "Rust", "source_code": "use std::collections::BinaryHeap;\nuse std::io;\nuse std::mem;\n\nconst DBG: bool = cfg!(mydebug);\n\nfn to_nums(line: &str) -> Vec<i64> {\n\tline.trim().split_whitespace()\n\t\t.map(|s| s.parse().unwrap())\n\t\t.collect()\n}\n\nconst M: i64 = 1000;\n\nfn doable(pwr: &[i64], num: &[i64], lim: i64) -> bool {\n\tif DBG { println!(\"======== lim {}\", lim); }\n\tlet n = pwr.len();\n\tlet quota: Vec<i64> = (0..n).map(|i| pwr[i] * M - num[i] * lim)\n\t\t.collect();\n\tif DBG {\n\t\tprint!(\"quota\");\n\t\tfor x in quota.iter() { print!(\" {}\", x); }\n\t\tprintln!();\n\t}\n\n\tlet mut total_quota = 0;\n\tlet mut free_pwr = BinaryHeap::new();\n\tlet mut candidates = Vec::new();\n\tfor i in 0..n {\n\t\tif quota[i] <= 0 {\n\t\t\ttotal_quota -= quota[i];\n\t\t\tfree_pwr.push(pwr[i]);\n\t\t\tif DBG { println!(\"free: quota {} pwr {}\",\n\t\t\t -quota[i], pwr[i]); }\n\t\t} else {\n\t\t\tcandidates.push((pwr[i], quota[i]));\n\t\t}\n\t}\n\tcandidates.sort();\n\n\tlet mut f0 = Vec::new();\n\tlet mut f1 = Vec::new();\n\tf1.push(total_quota);\n\twhile !candidates.is_empty() {\n\t\tif f1.is_empty() { return false }\n\t\tlet cur_pwr = candidates.last().unwrap().0;\n\t\tlet mut cur_quota = Vec::new();\n\t\twhile let Some(&(a_pwr, a_quota)) = candidates.last() {\n\t\t\tif a_pwr != cur_pwr { break }\n\t\t\tcandidates.pop();\n\t\t\tcur_quota.push(a_quota);\n\t\t}\n\t\tif DBG { println!(\"cur pwr {}, quota {:?}\", cur_pwr, cur_quota); }\n\t\tcur_quota.sort();\n\t\tlet mut prefixsum = vec![0];\n\t\tfor &cq in &cur_quota {\n\t\t\tlet s = prefixsum.last().unwrap() + cq;\n\t\t\tprefixsum.push(s);\n\t\t}\n\n\t\twhile let Some(&free) = free_pwr.peek() {\n\t\t\tif free <= cur_pwr { break }\n\t\t\tfree_pwr.pop();\n\t\t\tlet f10 = f1[0];\n\t\t\tf1.insert(0, f10);\n\t\t}\n\t\tif DBG { println!(\"prev config {:?}\", f1); }\n\t\tmem::swap(&mut f0, &mut f1);\n\t\tf1.clear();\n\t\tfor (k, &v0) in f0.iter().enumerate() {\n\t\t\tfor i in 0..prefixsum.len() {\n\t\t\t\tif v0 < 0 { continue }\n\t\t\t\tlet j = cur_quota.len() - i;\n\t\t\t\tif j > k { continue }\n\t\t\t\tlet t = k - j + i;\n\t\t\t\tif t >= f1.len() { f1.resize(t + 1, -1); }\n\t\t\t\tf1[t] = f1[t].max(v0 - prefixsum[i]);\n\t\t\t}\n\t\t}\n\t\twhile f1.last() == Some(&(-1)) { f1.pop(); }\n\t\tfor i in (1..f1.len()).rev() {\n\t\t\tf1[i - 1] = f1[i - 1].max(f1[i]);\n\t\t}\n\t\tif DBG { println!(\"cur config {:?}\", f1); }\n\t}\n\n\treturn true\n}\n\nfn main() -> io::Result<()> {\n\tlet f = io::stdin();\n\tlet mut line = String::new();\n\tf.read_line(&mut line)?;\n\tlet n: usize = line.trim().parse().unwrap();\n\tline.clear();\n\tf.read_line(&mut line)?;\n\tlet pwr = to_nums(&line);\n\tline.clear();\n\tf.read_line(&mut line)?;\n\tlet num = to_nums(&line);\n\tlet mut hi = 0;\n\tfor i in 0..n {\n\t\thi = hi.max((pwr[i] * M + num[i] - 1) / num[i]);\n\t}\n\tlet mut lo = 0;\n\twhile lo + 1 < hi {\n\t\tlet mid = (lo + hi) / 2;\n\t\tif doable(&pwr, &num, mid) {\n\t\t\thi = mid;\n\t\t} else {\n\t\t\tlo = mid;\n\t\t}\n\t}\n\tprintln!(\"{}\", hi);\n\n\tOk(())\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "7bba301b80eaba10fdbd43449c572ad8", "src_uid": "8883f8124092ace99ce0309fb8a511aa", "difficulty": 2500}
- {"lang": "Rust", "source_code": "use std::collections::BinaryHeap;\nuse std::io;\n\nconst DBG: bool = cfg!(mydebug);\n\nfn to_nums(line: &str) -> Vec<i64> {\n\tline.trim().split_whitespace()\n\t\t.map(|s| s.parse().unwrap())\n\t\t.collect()\n}\n\nconst M: i64 = 1000;\n\nfn doable(pwr: &[i64], num: &[i64], lim: i64) -> bool {\n\tif DBG { println!(\"======== lim {}\", lim); }\n\tlet n = pwr.len();\n\tlet quota: Vec<i64> = (0..n).map(|i| pwr[i] * M - num[i] * lim)\n\t\t.collect();\n\tif DBG {\n\t\tprint!(\"quota\");\n\t\tfor x in quota.iter() { print!(\" {}\", x); }\n\t\tprintln!();\n\t}\n\n\tlet mut total_quota = 0;\n\tlet mut free_pwr = BinaryHeap::new();\n\tlet mut candidates = Vec::new();\n\tfor i in 0..n {\n\t\tif quota[i] <= 0 {\n\t\t\ttotal_quota -= quota[i];\n\t\t\tfree_pwr.push(pwr[i]);\n\t\t\tif DBG { println!(\"free: quota {} pwr {}\",\n\t\t\t -quota[i], pwr[i]); }\n\t\t} else {\n\t\t\tcandidates.push((pwr[i], quota[i]));\n\t\t}\n\t}\n\tcandidates.sort();\n\n\tlet mut second_by_quota = BinaryHeap::new();\n\twhile let Some((a_pwr, a_quota)) = candidates.pop() {\n\t\tif DBG { println!(\"handling pwr {} quota {}\", a_pwr, a_quota); }\n\t\tif let Some(&free) = free_pwr.peek() {\n\t\t\tif free > a_pwr {\n\t\t\t\tif DBG { println!(\"as secondary of {}\", free); }\n\t\t\t\tfree_pwr.pop();\n\t\t\t\tsecond_by_quota.push((-a_quota, a_pwr));\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t}\n\t\tsecond_by_quota.push((-a_quota, a_pwr));\n\t\tlet (neg_b_quota, b_pwr) = second_by_quota.pop().unwrap();\n\t\tlet b_quota = -neg_b_quota;\n\t\tif DBG { println!(\"instead, pwr {} quota {}\", b_pwr, b_quota); }\n\t\tif b_quota > total_quota { return false; }\n\t\ttotal_quota -= b_quota;\n\t\tfree_pwr.push(b_pwr);\n\t}\n\n\treturn true;\n}\n\nfn main() -> io::Result<()> {\n\tlet f = io::stdin();\n\tlet mut line = String::new();\n\tf.read_line(&mut line)?;\n\tlet n: usize = line.trim().parse().unwrap();\n\tline.clear();\n\tf.read_line(&mut line)?;\n\tlet pwr = to_nums(&line);\n\tline.clear();\n\tf.read_line(&mut line)?;\n\tlet num = to_nums(&line);\n\tlet mut hi = 0;\n\tfor i in 0..n {\n\t\thi = hi.max((pwr[i] * M + num[i] - 1) / num[i]);\n\t}\n\tlet mut lo = 0;\n\twhile lo + 1 < hi {\n\t\tlet mid = (lo + hi) / 2;\n\t\tif doable(&pwr, &num, mid) {\n\t\t\thi = mid;\n\t\t} else {\n\t\t\tlo = mid;\n\t\t}\n\t}\n\tprintln!(\"{}\", hi);\n\n\tOk(())\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "5ded5348d7a01f1f6193b10a563ab0bb", "src_uid": "8883f8124092ace99ce0309fb8a511aa", "difficulty": 2500}
- {"lang": "Rust", "source_code": "use std::collections::BinaryHeap;\nuse std::io;\nuse std::mem;\n\nconst DBG: bool = cfg!(mydebug);\n\nfn to_nums(line: &str) -> Vec<i64> {\n\tline.trim().split_whitespace()\n\t\t.map(|s| s.parse().unwrap())\n\t\t.collect()\n}\n\nconst M: i64 = 1000;\n\nfn doable(pwr: &[i64], num: &[i64], lim: i64) -> bool {\n\tif DBG { println!(\"======== lim {}\", lim); }\n\tlet n = pwr.len();\n\tlet quota: Vec<i64> = (0..n).map(|i| pwr[i] * M - num[i] * lim)\n\t\t.collect();\n\tif DBG {\n\t\tprint!(\"quota\");\n\t\tfor x in quota.iter() { print!(\" {}\", x); }\n\t\tprintln!();\n\t}\n\n\tlet mut total_quota = 0;\n\tlet mut free_pwr = BinaryHeap::new();\n\tlet mut candidates = Vec::new();\n\tfor i in 0..n {\n\t\tif quota[i] <= 0 {\n\t\t\ttotal_quota -= quota[i];\n\t\t\tfree_pwr.push(pwr[i]);\n\t\t\tif DBG { println!(\"free: quota {} pwr {}\",\n\t\t\t -quota[i], pwr[i]); }\n\t\t} else {\n\t\t\tcandidates.push((pwr[i], quota[i]));\n\t\t}\n\t}\n\tcandidates.sort();\n\n\tlet mut f0 = Vec::new();\n\tlet mut f1 = Vec::new();\n\tlet mut cur_quota = Vec::new();\n\tf1.push(total_quota);\n\twhile !candidates.is_empty() {\n\t\tlet cur_pwr = candidates.last().unwrap().0;\n\t\tcur_quota.clear();\n\t\twhile let Some(&(a_pwr, a_quota)) = candidates.last() {\n\t\t\tif a_pwr != cur_pwr { break }\n\t\t\tcandidates.pop();\n\t\t\tcur_quota.push(a_quota);\n\t\t}\n\t\tcur_quota.sort();\n\t\twhile let Some(&free) = free_pwr.peek() {\n\t\t\tif free <= cur_pwr { break }\n\t\t\tfree_pwr.pop();\n\t\t\tlet f10 = f1[0];\n\t\t\tf1.insert(0, f10);\n\t\t}\n\t\tmem::swap(&mut f0, &mut f1);\n\t\tf1.clear();\n\t\tf1.resize(f0.len() + cur_quota.len(), -1);\n\t\tfor (k, &v0) in f0.iter().enumerate() {\n\t\t\tlet mut prefixsum = 0;\n\t\t\tfor i in 0..(cur_quota.len() + 1) {\n\t\t\t\tif i != 0 { prefixsum += cur_quota[i - 1]; }\n\t\t\t\tif prefixsum > v0 { break }\n\t\t\t\tlet j = cur_quota.len() - i;\n\t\t\t\tif j > k { continue }\n\t\t\t\tlet t = k - j + i;\n\t\t\t\tf1[t] = f1[t].max(v0 - prefixsum);\n\t\t\t}\n\t\t}\n\t\twhile f1.last() == Some(&(-1)) { f1.pop(); }\n\t}\n\n\treturn !f1.is_empty();\n}\n\nfn main() -> io::Result<()> {\n\tlet f = io::stdin();\n\tlet mut line = String::new();\n\tf.read_line(&mut line)?;\n\tlet n: usize = line.trim().parse().unwrap();\n\tline.clear();\n\tf.read_line(&mut line)?;\n\tlet pwr = to_nums(&line);\n\tline.clear();\n\tf.read_line(&mut line)?;\n\tlet num = to_nums(&line);\n\tlet mut hi = 0;\n\tfor i in 0..n {\n\t\thi = hi.max((pwr[i] * M + num[i] - 1) / num[i]);\n\t}\n\tlet mut lo = 0;\n\twhile lo + 1 < hi {\n\t\tlet mid = (lo + hi) / 2;\n\t\tif doable(&pwr, &num, mid) {\n\t\t\thi = mid;\n\t\t} else {\n\t\t\tlo = mid;\n\t\t}\n\t}\n\tprintln!(\"{}\", hi);\n\n\tOk(())\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "0cd93444fe37d06aa6d712b575d4b769", "src_uid": "8883f8124092ace99ce0309fb8a511aa", "difficulty": 2500}
- {"lang": "Rust", "source_code": "use std::collections::BinaryHeap;\nuse std::io;\nuse std::mem;\n\nconst DBG: bool = cfg!(mydebug);\n\nfn to_nums(line: &str) -> Vec<i64> {\n\tline.trim().split_whitespace()\n\t\t.map(|s| s.parse().unwrap())\n\t\t.collect()\n}\n\nconst M: i64 = 1000;\n\nfn doable(pwr: &[i64], num: &[i64], lim: i64) -> bool {\n\tif DBG { println!(\"======== lim {}\", lim); }\n\tlet n = pwr.len();\n\tlet quota: Vec<i64> = (0..n).map(|i| pwr[i] * M - num[i] * lim)\n\t\t.collect();\n\tif DBG {\n\t\tprint!(\"quota\");\n\t\tfor x in quota.iter() { print!(\" {}\", x); }\n\t\tprintln!();\n\t}\n\n\tlet mut total_quota = 0;\n\tlet mut free_pwr = BinaryHeap::new();\n\tlet mut candidates = Vec::new();\n\tfor i in 0..n {\n\t\tif quota[i] <= 0 {\n\t\t\ttotal_quota -= quota[i];\n\t\t\tfree_pwr.push(pwr[i]);\n\t\t\tif DBG { println!(\"free: quota {} pwr {}\",\n\t\t\t -quota[i], pwr[i]); }\n\t\t} else {\n\t\t\tcandidates.push((pwr[i], quota[i]));\n\t\t}\n\t}\n\tcandidates.sort();\n\n\tlet mut f0 = Vec::new();\n\tlet mut f1 = Vec::new();\n\tf1.push(total_quota);\n\twhile !candidates.is_empty() {\n\t\tlet cur_pwr = candidates.last().unwrap().0;\n\t\tlet mut cur_quota = Vec::new();\n\t\twhile let Some(&(a_pwr, a_quota)) = candidates.last() {\n\t\t\tif a_pwr != cur_pwr { break }\n\t\t\tcandidates.pop();\n\t\t\tcur_quota.push(a_quota);\n\t\t}\n\t\tif DBG { println!(\"cur pwr {}, quota {:?}\", cur_pwr, cur_quota); }\n\t\tcur_quota.sort();\n\t\tlet mut prefixsum = vec![0];\n\t\tfor &cq in &cur_quota {\n\t\t\tlet s = prefixsum.last().unwrap() + cq;\n\t\t\tprefixsum.push(s);\n\t\t}\n\n\t\twhile let Some(&free) = free_pwr.peek() {\n\t\t\tif free <= cur_pwr { break }\n\t\t\tfree_pwr.pop();\n\t\t\tlet f10 = f1[0];\n\t\t\tf1.insert(0, f10);\n\t\t}\n\t\tif DBG { println!(\"prev config {:?}\", f1); }\n\t\tmem::swap(&mut f0, &mut f1);\n\t\tf1.clear();\n\t\tfor (k, &v0) in f0.iter().enumerate() {\n\t\t\tfor i in 0..prefixsum.len() {\n\t\t\t\tif v0 < 0 { continue }\n\t\t\t\tlet j = cur_quota.len() - i;\n\t\t\t\tif j > k { continue }\n\t\t\t\tlet t = k - j + i;\n\t\t\t\tif t >= f1.len() { f1.resize(t + 1, -1); }\n\t\t\t\tf1[t] = f1[t].max(v0 - prefixsum[i]);\n\t\t\t}\n\t\t}\n\t\twhile f1.last() == Some(&(-1)) { f1.pop(); }\n\t\tfor i in (1..f1.len()).rev() {\n\t\t\tf1[i - 1] = f1[i - 1].max(f1[i]);\n\t\t}\n\t\tif DBG { println!(\"cur config {:?}\", f1); }\n\t\tif f1.is_empty() { return false }\n\t}\n\n\treturn true\n}\n\nfn main() -> io::Result<()> {\n\tlet f = io::stdin();\n\tlet mut line = String::new();\n\tf.read_line(&mut line)?;\n\tlet n: usize = line.trim().parse().unwrap();\n\tline.clear();\n\tf.read_line(&mut line)?;\n\tlet pwr = to_nums(&line);\n\tline.clear();\n\tf.read_line(&mut line)?;\n\tlet num = to_nums(&line);\n\tlet mut hi = 0;\n\tfor i in 0..n {\n\t\thi = hi.max((pwr[i] * M + num[i] - 1) / num[i]);\n\t}\n\tlet mut lo = 0;\n\twhile lo + 1 < hi {\n\t\tlet mid = (lo + hi) / 2;\n\t\tif doable(&pwr, &num, mid) {\n\t\t\thi = mid;\n\t\t} else {\n\t\t\tlo = mid;\n\t\t}\n\t}\n\tprintln!(\"{}\", hi);\n\n\tOk(())\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "f375ad2b1360e3a6e611361d300ef545", "src_uid": "8883f8124092ace99ce0309fb8a511aa", "difficulty": 2500}
- {"lang": "Rust", "source_code": "// https://codeforces.com/contest/1137/problem/A\n//\n#![allow(unused_imports)]\nuse std::io::*;\nuse std::io::Write;\nuse std::fmt::*;\nuse std::str::*;\nuse std::cmp::*;\nuse std::collections::*;\n\n#[allow(unused_macros)]\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n ($($r:tt)*) => {\n let s = {\n use std::io::Read;\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n };\n let mut iter = s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! input_inner {\n ($iter:expr) => {};\n ($iter:expr, ) => {};\n\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n\n ($iter:expr, mut $var:ident : $t:tt $($r:tt)*) => {\n let mut $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! read_value {\n ($iter:expr, ( $($t:tt),* )) => {\n ( $(read_value!($iter, $t)),* )\n };\n\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()\n };\n\n ($iter:expr, [ next / $t:tt ]) => {\n {\n let len = read_value!($iter, usize);\n (0..len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()\n }\n };\n\n ($iter:expr, switch) => {\n {\n let ty = read_value!($iter, i32);\n if ty == 1 {\n vec![ty, read_value!($iter, i32), read_value!($iter, i32)]\n } else if ty == 2 {\n vec![ty, read_value!($iter, i32)]\n } else {\n vec![ty, read_value!($iter, i32)]\n }\n }\n };\n\n ($iter:expr, chars) => {\n read_value!($iter, String).chars().collect::<Vec<char>>()\n };\n\n ($iter:expr, usize1) => {\n read_value!($iter, usize) - 1\n };\n\n ($iter:expr, $t:ty) => {\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! dvec {\n ($t:expr ; $len:expr) => {\n vec![$t; $len]\n };\n\n ($t:expr ; $len:expr, $($rest:expr),*) => {\n vec![dvec!($t; $($rest),*); $len]\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! ifv {\n ($t:expr, $a:expr, $b: expr) => {\n if $t { $a } else { $b }\n }\n}\n\n#[allow(unused_macros)]\nmacro_rules! fill {\n ($t:expr, $v:expr) => {\n for i in 0..$t.len() {\n $t[i] = $v;\n }\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! join {\n ($t:expr, $glue:expr) => {\n $t.into_iter().map(|w| w.to_string()).collect::<Vec<_>>().join($glue)\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! debug {\n ($($a:expr),*) => {\n println!(concat!($(stringify!($a), \" = {:?}, \"),*), $($a),*);\n }\n}\n\n\n\nfn process(a: Vec<i32>) -> (Vec<i32>, i32) {\n let mut ua = a.clone();\n ua.sort();\n ua.dedup();\n\n let n = a.len();\n let mut r = vec![0; n];\n for i in 0..n {\n r[i] = ua.binary_search(&a[i]).unwrap() as i32;\n }\n (r, ua.len() as i32)\n}\n\nfn main() {\n input! {\n n: usize, m: usize,\n a: [[i32; m]; n]\n };\n\n let mut rows = vec![];\n for i in 0..n {\n rows.push(process(a[i].clone()));\n }\n let mut cols = vec![];\n for j in 0..m {\n let mut ca = vec![0; n];\n for i in 0..n {\n ca[i] = a[i][j];\n }\n cols.push(process(ca));\n }\n\n let mut ans = vec![vec![0; m]; n];\n for i in 0..n {\n for j in 0..m {\n let mut best = (n+m) as i32;\n\n let mut myc = cols[j].0[i];\n let mut myr = rows[i].0[j];\n let mut col_count = cols[j].1;\n let mut row_count = rows[i].1;\n ans[i][j] = 1 + max(myc, myr) + max(col_count-myc-1, row_count-myr-1);\n }\n }\n\n let out = stdout();\n let mut out = BufWriter::new(out.lock());\n for i in 0..n {\n writeln!(out, \"{}\", join!(ans[i].clone(), \" \"));\n }\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "96dd108760a1d4073bc7e8bbc909fabe", "src_uid": "206861107f0c06d3c8e358a85b9ddd7f", "difficulty": 1600}
- {"lang": "Rust", "source_code": "#![allow(unused_imports)]\n\nuse std::cmp::*;\nuse std::collections::*;\nuse std::fmt::Debug;\nuse std::str::FromStr;\n\nfn main() {\n let nn = read_vec::<usize>();\n let (n, m) = (nn[0], nn[1]);\n\n #[derive(Copy, Clone, Debug)]\n struct Point {\n i: usize,\n h: i64,\n fh: i64,\n }\n\n let mut rows = vec![Vec::with_capacity(m); n];\n let mut columns = vec![Vec::with_capacity(n); m];\n let mut r_maxes = vec![0; n];\n let mut c_maxes = vec![0; m];\n\n for i in 0..n {\n let p = read_vec::<i64>();\n for j in 0..m {\n rows[i].push(Point {\n i: j,\n h: p[j],\n fh: 0,\n });\n columns[j].push(Point {\n i: i,\n h: p[j],\n fh: 0,\n });\n }\n }\n\n for i in 0..n {\n let row = &mut rows[i];\n row.sort_unstable_by(\n |a, b| a.h.cmp(&b.h)\n );\n row[0].fh = 1;\n for i in 1..m {\n if row[i].h == row[i - 1].h {\n row[i].fh = row[i - 1].fh;\n } else {\n row[i].fh = row[i - 1].fh + 1;\n }\n }\n r_maxes[i] = row[m - 1].fh;\n row.sort_unstable_by(\n |a, b| a.i.cmp(&b.i)\n );\n }\n\n for i in 0..m {\n let row = &mut columns[i];\n row.sort_unstable_by(\n |a, b| a.h.cmp(&b.h)\n );\n row[0].fh = 1;\n for i in 1..n {\n if row[i].h == row[i - 1].h {\n row[i].fh = row[i - 1].fh;\n } else {\n row[i].fh = row[i - 1].fh + 1;\n }\n }\n c_maxes[i] = row[n - 1].fh;\n row.sort_unstable_by(\n |a, b| a.i.cmp(&b.i)\n );\n }\n\n// for i in 0..n { print_vec(&rows[i]) }\n// for i in 0..m { print_vec(&columns[i]) }\n\n for i in 0..n {\n for j in 0..m {\n print!(\"{}\", max(\n r_maxes[i] + max(0, columns[j][i].fh - rows[i][j].fh),\n c_maxes[j] + max(0, -columns[j][i].fh + rows[i][j].fh),\n ));\n if j < m - 1 {\n print! {\" \"};\n }\n }\n println!()\n }\n}\n\n#[allow(dead_code)]\nconst DIV: i64 = 1_000_000_007;\n#[allow(dead_code)]\nconst N: usize = 200000;\n#[allow(dead_code)]\nconst CHARS: usize = 'z' as usize - 'a' as usize + 1;\n\n#[allow(dead_code)]\nfn print_vec<T: Debug>(a: &Vec<T>) {\n for i in 0..a.len() {\n if i != 0 {\n print!(\" \");\n }\n print!(\"{:?}\", a[i]);\n }\n println!();\n}\n\n#[allow(dead_code)]\nfn read_line() -> String {\n let mut s = String::with_capacity(N);\n std::io::stdin().read_line(&mut s).unwrap();\n s\n}\n\n#[allow(dead_code)]\nfn read_vec<T: FromStr>() -> Vec<T>\n where T::Err: Debug\n{\n return read_line()\n .split_whitespace()\n .map(|x| x.parse().unwrap())\n .collect();\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "0bb5a08528b3b09ea20bc5a60b176c6b", "src_uid": "206861107f0c06d3c8e358a85b9ddd7f", "difficulty": 1600}
- {"lang": "Rust", "source_code": "#![allow(unused_imports)]\n\nuse std::cmp::*;\nuse std::collections::*;\nuse std::fmt::Debug;\nuse std::str::FromStr;\n\nfn main() {\n let nn = read_vec::<usize>();\n let (n, m) = (nn[0], nn[1]);\n\n #[derive(Copy, Clone)]\n struct Point {\n i: usize,\n h: i64,\n }\n\n let mut rows = vec![Vec::with_capacity(m); n];\n let mut columns = vec![Vec::with_capacity(n); m];\n let mut r_maxes = vec![0; n];\n let mut c_maxes = vec![0; m];\n\n for i in 0..n {\n let p = read_vec::<i64>();\n for j in 0..m {\n rows[i].push(Point {\n i: j,\n h: p[j],\n });\n columns[j].push(Point {\n i: i,\n h: p[j],\n });\n }\n }\n\n for i in 0..n {\n let row = &mut rows[i];\n row.sort_unstable_by(\n |a, b| a.h.cmp(&b.h)\n );\n row[0].h = 1;\n for i in 1..n {\n if row[i].h == row[i - 1].h {\n row[i].h = row[i - 1].h;\n } else {\n row[i].h = row[i - 1].h + 1;\n }\n }\n r_maxes[i] = row[m - 1].h;\n row.sort_unstable_by(\n |a, b| a.i.cmp(&b.i)\n );\n }\n\n for i in 0..m {\n let row = &mut columns[i];\n row.sort_unstable_by(\n |a, b| a.h.cmp(&b.h)\n );\n row[0].h = 1;\n for i in 1..n {\n if row[i].h == row[i - 1].h {\n row[i].h = row[i - 1].h;\n } else {\n row[i].h = row[i - 1].h + 1;\n }\n }\n c_maxes[i] = row[n - 1].h;\n row.sort_unstable_by(\n |a, b| a.i.cmp(&b.i)\n );\n }\n\n for i in 0..n {\n for j in 0..m {\n print!(\"{}\", max(\n r_maxes[i] + max(0, columns[j][i].h - rows[i][j].h),\n c_maxes[i] + max(0, -columns[j][i].h + rows[i][j].h),\n ));\n if j < m - 1 {\n print! {\" \"};\n }\n }\n println!()\n }\n}\n\n#[allow(dead_code)]\nconst DIV: i64 = 1_000_000_007;\n#[allow(dead_code)]\nconst N: usize = 200000;\n#[allow(dead_code)]\nconst CHARS: usize = 'z' as usize - 'a' as usize + 1;\n\n#[allow(dead_code)]\nfn print_vec<T: Debug>(a: &Vec<T>) {\n for i in 0..a.len() {\n if i != 0 {\n print!(\" \");\n }\n print!(\"{:?}\", a[i]);\n }\n println!();\n}\n\n#[allow(dead_code)]\nfn read_line() -> String {\n let mut s = String::with_capacity(N);\n std::io::stdin().read_line(&mut s).unwrap();\n s\n}\n\n#[allow(dead_code)]\nfn read_vec<T: FromStr>() -> Vec<T>\n where T::Err: Debug\n{\n return read_line()\n .split_whitespace()\n .map(|x| x.parse().unwrap())\n .collect();\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "fe5f20b1f3c53f4ff40179bdf846a1e6", "src_uid": "206861107f0c06d3c8e358a85b9ddd7f", "difficulty": 1600}
- {"lang": "Rust", "source_code": "#![allow(unused_imports)]\n\nuse std::cmp::*;\nuse std::collections::*;\nuse std::fmt::Debug;\nuse std::str::FromStr;\n\nfn main() {\n let nn = read_vec::<usize>();\n let (n, m) = (nn[0], nn[1]);\n\n #[derive(Copy, Clone, Debug)]\n struct Point {\n i: usize,\n h: i64,\n fh: i64,\n }\n\n let mut rows = vec![Vec::with_capacity(m); n];\n let mut columns = vec![Vec::with_capacity(n); m];\n let mut r_maxes = vec![0; n];\n let mut c_maxes = vec![0; m];\n\n for i in 0..n {\n let p = read_vec::<i64>();\n for j in 0..m {\n rows[i].push(Point {\n i: j,\n h: p[j],\n fh: 0,\n });\n columns[j].push(Point {\n i: i,\n h: p[j],\n fh: 0,\n });\n }\n }\n\n for i in 0..n {\n let row = &mut rows[i];\n row.sort_unstable_by(\n |a, b| a.h.cmp(&b.h)\n );\n row[0].fh = 1;\n for i in 1..m {\n if row[i].h == row[i - 1].h {\n row[i].fh = row[i - 1].fh;\n } else {\n row[i].fh = row[i - 1].fh + 1;\n }\n }\n r_maxes[i] = row[m - 1].h;\n row.sort_unstable_by(\n |a, b| a.i.cmp(&b.i)\n );\n }\n\n for i in 0..m {\n let row = &mut columns[i];\n row.sort_unstable_by(\n |a, b| a.h.cmp(&b.h)\n );\n row[0].fh = 1;\n for i in 1..n {\n if row[i].h == row[i - 1].h {\n row[i].fh = row[i - 1].fh;\n } else {\n row[i].fh = row[i - 1].fh + 1;\n }\n }\n c_maxes[i] = row[n - 1].h;\n row.sort_unstable_by(\n |a, b| a.i.cmp(&b.i)\n );\n }\n\n// for i in 0..n { print_vec(&rows[i]) }\n// for i in 0..m { print_vec(&columns[i]) }\n\n for i in 0..n {\n for j in 0..m {\n print!(\"{}\", max(\n r_maxes[i] + max(0, columns[j][i].h - rows[i][j].h),\n c_maxes[j] + max(0, -columns[j][i].h + rows[i][j].h),\n ));\n if j < m - 1 {\n print! {\" \"};\n }\n }\n println!()\n }\n}\n\n#[allow(dead_code)]\nconst DIV: i64 = 1_000_000_007;\n#[allow(dead_code)]\nconst N: usize = 200000;\n#[allow(dead_code)]\nconst CHARS: usize = 'z' as usize - 'a' as usize + 1;\n\n#[allow(dead_code)]\nfn print_vec<T: Debug>(a: &Vec<T>) {\n for i in 0..a.len() {\n if i != 0 {\n print!(\" \");\n }\n print!(\"{:?}\", a[i]);\n }\n println!();\n}\n\n#[allow(dead_code)]\nfn read_line() -> String {\n let mut s = String::with_capacity(N);\n std::io::stdin().read_line(&mut s).unwrap();\n s\n}\n\n#[allow(dead_code)]\nfn read_vec<T: FromStr>() -> Vec<T>\n where T::Err: Debug\n{\n return read_line()\n .split_whitespace()\n .map(|x| x.parse().unwrap())\n .collect();\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "a712d3e9b760a08959b7a829b60ecc14", "src_uid": "206861107f0c06d3c8e358a85b9ddd7f", "difficulty": 1600}
- {"lang": "Rust", "source_code": "#![allow(unused_imports)]\n\nuse std::cmp::*;\nuse std::collections::*;\nuse std::fmt::Debug;\nuse std::str::FromStr;\n\nfn main() {\n let nn = read_vec::<usize>();\n let (n, m) = (nn[0], nn[1]);\n\n #[derive(Copy, Clone)]\n struct Point {\n i: usize,\n h: i64,\n }\n\n let mut rows = vec![Vec::with_capacity(m); n];\n let mut columns = vec![Vec::with_capacity(n); m];\n let mut r_maxes = vec![0; n];\n let mut c_maxes = vec![0; m];\n\n for i in 0..n {\n let p = read_vec::<i64>();\n for j in 0..m {\n rows[i].push(Point {\n i: j,\n h: p[j],\n });\n columns[j].push(Point {\n i: i,\n h: p[j],\n });\n }\n }\n\n for i in 0..n {\n let row = &mut rows[i];\n row.sort_unstable_by(\n |a, b| a.h.cmp(&b.h)\n );\n row[0].h = 1;\n for i in 1..m {\n if row[i].h == row[i - 1].h {\n row[i].h = row[i - 1].h;\n } else {\n row[i].h = row[i - 1].h + 1;\n }\n }\n r_maxes[i] = row[m - 1].h;\n row.sort_unstable_by(\n |a, b| a.i.cmp(&b.i)\n );\n }\n\n for i in 0..m {\n let row = &mut columns[i];\n row.sort_unstable_by(\n |a, b| a.h.cmp(&b.h)\n );\n row[0].h = 1;\n for i in 1..n {\n if row[i].h == row[i - 1].h {\n row[i].h = row[i - 1].h;\n } else {\n row[i].h = row[i - 1].h + 1;\n }\n }\n c_maxes[i] = row[n - 1].h;\n row.sort_unstable_by(\n |a, b| a.i.cmp(&b.i)\n );\n }\n\n for i in 0..n {\n for j in 0..m {\n print!(\"{}\", max(\n r_maxes[i] + max(0, columns[j][i].h - rows[i][j].h),\n c_maxes[j] + max(0, -columns[j][i].h + rows[i][j].h),\n ));\n if j < m - 1 {\n print! {\" \"};\n }\n }\n println!()\n }\n}\n\n#[allow(dead_code)]\nconst DIV: i64 = 1_000_000_007;\n#[allow(dead_code)]\nconst N: usize = 200000;\n#[allow(dead_code)]\nconst CHARS: usize = 'z' as usize - 'a' as usize + 1;\n\n#[allow(dead_code)]\nfn print_vec<T: Debug>(a: &Vec<T>) {\n for i in 0..a.len() {\n if i != 0 {\n print!(\" \");\n }\n print!(\"{:?}\", a[i]);\n }\n println!();\n}\n\n#[allow(dead_code)]\nfn read_line() -> String {\n let mut s = String::with_capacity(N);\n std::io::stdin().read_line(&mut s).unwrap();\n s\n}\n\n#[allow(dead_code)]\nfn read_vec<T: FromStr>() -> Vec<T>\n where T::Err: Debug\n{\n return read_line()\n .split_whitespace()\n .map(|x| x.parse().unwrap())\n .collect();\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "6797d6df9bed2fe804ad57b31aa3410b", "src_uid": "206861107f0c06d3c8e358a85b9ddd7f", "difficulty": 1600}
- {"lang": "Rust", "source_code": "use std::io::BufRead;\n\n#[derive(Clone,Debug)]\nstruct Problem {\n input: Vec<u32>,\n}\n\nfn read_problem<R: BufRead>(br: R) -> Problem {\n let mut lines = br.lines().map(Result::unwrap);\n\n let ct = str::parse(&lines.next().unwrap()).unwrap();\n let input = lines.next().unwrap().split_whitespace()\n .map(|w| str::parse::<u32>(w).unwrap())\n .map(|n| n - 1)\n .collect::<Vec<_>>();\n assert!(lines.next().is_none());\n assert!(input.len() == ct);\n Problem { input: input }\n}\n\nfn solve(problem: Problem) -> Vec<u32> {\n let mut best = problem.input.iter().map(|_| u32::max_value()).collect::<Vec<_>>();\n let mut next = vec![0];\n let mut cost = 0;\n while !next.is_empty() {\n for n in std::mem::replace(&mut next, Vec::new()) {\n if cost < best[n] {\n best[n] = cost;\n if n > 0 {\n next.push(n-1);\n }\n if n+1 < best.len() {\n next.push(n+1);\n }\n next.push(problem.input[n] as usize);\n }\n }\n cost += 1;\n }\n best\n}\n\nfn main() {\n let stdin = std::io::stdin();\n let p = read_problem(stdin.lock());\n for k in solve(p) {\n print!(\"{} \", k);\n }\n println!(\"\");\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "579057b098ba75c0b97d8e8eb337f332", "src_uid": "d465aec304757dff34a770f7877dd940", "difficulty": 1600}
- {"lang": "Rust", "source_code": "use std::io::BufRead;\n\n#[derive(Clone,Debug)]\nstruct Problem {\n input: Vec<u32>,\n}\n\nfn read_problem<R: BufRead>(br: R) -> Problem {\n let mut lines = br.lines().map(Result::unwrap);\n\n let ct = str::parse(&lines.next().unwrap()).unwrap();\n let input = lines.next().unwrap().split_whitespace()\n .map(|w| str::parse::<u32>(w).unwrap())\n .map(|n| n - 1)\n .collect::<Vec<_>>();\n assert!(lines.next().is_none());\n assert!(input.len() == ct);\n Problem { input: input }\n}\n\nfn solve(problem: Problem) -> Vec<u32> {\n let mut best = problem.input.iter().map(|_| u32::max_value()).collect::<Vec<_>>();\n let mut next = 0;\n for (i, ai) in problem.input.into_iter().enumerate() {\n if next < best[i] {\n best[i] = next;\n }\n next = best[i] + 1;\n if next < best[ai as usize] {\n best[ai as usize] = next;\n }\n }\n best\n}\n\nfn main() {\n let stdin = std::io::stdin();\n let p = read_problem(stdin.lock());\n for k in solve(p) {\n print!(\"{} \", k);\n }\n println!(\"\");\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "a3c0a4532d6a2ccd612ec071dc470718", "src_uid": "d465aec304757dff34a770f7877dd940", "difficulty": 1600}
- {"lang": "Rust", "source_code": "use std::io;\nuse std::io::Read;\nuse std::collections::VecDeque;\n\n\nfn main() {\n let mut text = String::new();\n io::stdin().read_to_string(&mut text).unwrap();\n let mut iter = text.split_whitespace().map(|x| x.parse::<usize>().unwrap());\n let n = iter.next().unwrap();\n let a = iter.map(|x| x - 1).collect::<Vec<usize>>();\n let mut energy = vec![-1; n];\n energy[0] = 0;\n let mut queue = VecDeque::new();\n queue.push_back(0);\n while let Some(cur) = queue.pop_front() {\n if cur > 0 && energy[cur - 1] == -1 {\n energy[cur - 1] = energy[cur] + 1;\n queue.push_back(cur - 1);\n }\n if cur < n - 1 && energy[cur + 1] == -1 {\n energy[cur + 1] = energy[cur] + 1;\n queue.push_back(cur + 1);\n }\n if energy[a[cur]] == -1 {\n energy[a[cur]] = energy[cur] + 1;\n queue.push_back(a[cur]);\n }\n }\n for item in energy {\n print!(\"{} \", item);\n }\n println!(\"\");\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "d6d94c995e414ed45df1b742512f6d2b", "src_uid": "d465aec304757dff34a770f7877dd940", "difficulty": 1600}
- {"lang": "Rust", "source_code": "use std::fmt::Debug;\nuse std::str::FromStr;\n\npub struct TokenReader {\n reader: std::io::Stdin,\n tokens: Vec<String>,\n index: usize,\n}\n\nimpl TokenReader {\n pub fn new() -> Self {\n Self {\n reader: std::io::stdin(),\n tokens: Vec::new(),\n index: 0,\n }\n }\n\n pub fn next<T>(&mut self) -> T\n where\n T: FromStr,\n T::Err: Debug,\n {\n if self.index >= self.tokens.len() {\n self.load_next_line();\n }\n self.index += 1;\n self.tokens[self.index - 1].parse().unwrap()\n }\n\n pub fn vector<T>(&mut self) -> Vec<T>\n where\n T: FromStr,\n T::Err: Debug,\n {\n if self.index >= self.tokens.len() {\n self.load_next_line();\n }\n self.index = self.tokens.len();\n self.tokens.iter().map(|tok| tok.parse().unwrap()).collect()\n }\n\n pub fn load_next_line(&mut self) {\n let mut line = String::new();\n self.reader.read_line(&mut line).unwrap();\n\n self.tokens = line\n .split_whitespace()\n .map(String::from)\n .collect();\n self.index = 0;\n }\n}\n\nfn eat1(n: &mut i64, v: &mut i64, c: &mut i64) -> i64 {\n let eaten = std::cmp::min(*n, (*v - *c).abs());\n *n -= eaten;\n\n if *v > *c {\n *v -= eaten;\n } else {\n *c -= eaten;\n }\n\n eaten\n}\n\nfn eat2(m: &mut i64, v: &mut i64, c: &mut i64) -> i64 {\n let eaten = std::cmp::min(*m, std::cmp::min(*v, *c));\n *m -= eaten;\n\n if *v > *c {\n *c -= eaten;\n } else {\n *v -= eaten;\n }\n\n eaten\n}\n\nfn possible(mut v: i64, mut c: i64, mut n: i64, mut m: i64) -> bool {\n if n + m > v + c {\n return false;\n }\n\n while v != c && n > 0 {\n if eat1(&mut n, &mut v, &mut c) == 0 {\n return false;\n }\n }\n\n while n > 0 && m > 0 {\n let eaten = std::cmp::min(std::cmp::min(v, m), std::cmp::min(c, n));\n if eaten == 0 {\n break;\n }\n\n v -= eaten;\n c -= eaten;\n n -= eaten;\n m -= eaten;\n }\n\n while n > 0 {\n if eat1(&mut n, &mut v, &mut c) == 0 {\n return false;\n }\n }\n while m > 0 {\n if eat2(&mut m, &mut v, &mut c) == 0 {\n return false;\n }\n }\n\n n == 0 && m == 0\n}\n\nfn main() {\n let mut reader = TokenReader::new();\n let tests = reader.next();\n\n for _ in 0..tests {\n let v = reader.next();\n let c = reader.next();\n let n = reader.next();\n let m = reader.next();\n println!(\"{}\", if possible(v, c, n, m) { \"Yes\" } else { \"No\" });\n }\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "bf9f939c68fa657eda8e1bc83b99770b", "src_uid": "0f960d19e576b7421a7c7a7166a884ea", "difficulty": 1300}
- {"lang": "Rust", "source_code": "#![allow(dead_code)]\n#![allow(unused_imports)]\n\nuse std::cmp::*;\nuse std::collections::*;\nuse std::io;\nuse std::ops;\nuse std::str::FromStr;\n\n#[derive(Clone, Debug, Default)]\nstruct ProblemState {\n}\n\nimpl Problem {\n fn solve(&mut self) {\n let mut a: u64 = self.scan();\n let mut b: u64 = self.scan();\n let mut n: u64 = self.scan();\n let mut m: u64 = self.scan();\n\n if a < b {\n let t = a; a = b; b = t;\n }\n\n let x = 2 * b - min(m, b);\n\n n -= min(n, a - b);\n m -= min(m, b);\n n -= min(n, x);\n\n if n == 0 && m == 0 {\n println!(\"Yes\");\n } else {\n println!(\"No\");\n }\n }\n}\n\nfn main() {\n Problem::new().solve_cases();\n}\n\nstruct Problem {\n input_state: InputState,\n problem_state: ProblemState,\n}\n\nstruct InputState {\n stdin: io::Stdin,\n buffer: String,\n tokens: VecDeque<String>,\n}\n\nimpl Problem {\n fn new() -> Self {\n Self {\n input_state: InputState {\n stdin: io::stdin(),\n buffer: String::new(),\n tokens: VecDeque::new(),\n },\n problem_state: Default::default(),\n }\n }\n\n fn solve_cases(&mut self) {\n for _ in 0usize..self.scan() {\n self.solve()\n }\n }\n\n fn scan<T: FromStr>(&mut self) -> T {\n while self.input_state.tokens.is_empty() {\n self.input_state.stdin.read_line(&mut self.input_state.buffer).unwrap();\n\n for token in self.input_state.buffer.split_ascii_whitespace() {\n self.input_state.tokens.push_back(token.to_string());\n }\n\n self.input_state.buffer.clear();\n }\n\n self.input_state.tokens.pop_front().unwrap().parse().ok().unwrap()\n }\n\n fn scan_vec<T: FromStr>(&mut self, n: usize) -> Vec<T> {\n (0..n).into_iter().map(|_| self.scan()).collect()\n }\n\n fn scan_line(&mut self) -> String {\n let mut line = String::new();\n self.input_state.stdin.read_line(&mut line).unwrap();\n while line.ends_with('\\n') || line.ends_with('\\r') { line.pop(); }\n line\n }\n\n fn scan_line_vec(&mut self, n: usize) -> Vec<String> {\n (0..n).into_iter().map(|_| self.scan_line()).collect()\n }\n}\n\nimpl ops::Deref for Problem {\n type Target = ProblemState;\n\n fn deref(&self) -> &ProblemState {\n &self.problem_state\n }\n}\n\nimpl ops::DerefMut for Problem {\n fn deref_mut(&mut self) -> &mut ProblemState {\n &mut self.problem_state\n }\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "4db868163bed32ad8f6f1cc6e182489e", "src_uid": "0f960d19e576b7421a7c7a7166a884ea", "difficulty": 1300}
- {"lang": "Rust", "source_code": "#![allow(dead_code)]\n#![allow(unused_imports)]\n\nuse std::cmp::*;\nuse std::collections::*;\nuse std::io;\nuse std::ops;\nuse std::str::FromStr;\n\n#[derive(Clone, Debug, Default)]\nstruct ProblemState {\n}\n\nimpl Problem {\n fn solve(&mut self) {\n let mut a: u64 = self.scan();\n let mut b: u64 = self.scan();\n let mut n: u64 = self.scan();\n let mut m: u64 = self.scan();\n\n if a < b {\n let t = a; a = b; b = t;\n }\n\n if a > b {\n n -= min(n, a - b);\n }\n\n m -= min(m, b);\n n -= min(n, b);\n\n if n == 0 && m == 0 {\n println!(\"Yes\");\n } else {\n println!(\"No\");\n }\n }\n}\n\nfn main() {\n Problem::new().solve_cases();\n}\n\nstruct Problem {\n input_state: InputState,\n problem_state: ProblemState,\n}\n\nstruct InputState {\n stdin: io::Stdin,\n buffer: String,\n tokens: VecDeque<String>,\n}\n\nimpl Problem {\n fn new() -> Self {\n Self {\n input_state: InputState {\n stdin: io::stdin(),\n buffer: String::new(),\n tokens: VecDeque::new(),\n },\n problem_state: Default::default(),\n }\n }\n\n fn solve_cases(&mut self) {\n for _ in 0usize..self.scan() {\n self.solve()\n }\n }\n\n fn scan<T: FromStr>(&mut self) -> T {\n while self.input_state.tokens.is_empty() {\n self.input_state.stdin.read_line(&mut self.input_state.buffer).unwrap();\n\n for token in self.input_state.buffer.split_ascii_whitespace() {\n self.input_state.tokens.push_back(token.to_string());\n }\n\n self.input_state.buffer.clear();\n }\n\n self.input_state.tokens.pop_front().unwrap().parse().ok().unwrap()\n }\n\n fn scan_vec<T: FromStr>(&mut self, n: usize) -> Vec<T> {\n (0..n).into_iter().map(|_| self.scan()).collect()\n }\n\n fn scan_line(&mut self) -> String {\n let mut line = String::new();\n self.input_state.stdin.read_line(&mut line).unwrap();\n while line.ends_with('\\n') || line.ends_with('\\r') { line.pop(); }\n line\n }\n\n fn scan_line_vec(&mut self, n: usize) -> Vec<String> {\n (0..n).into_iter().map(|_| self.scan_line()).collect()\n }\n}\n\nimpl ops::Deref for Problem {\n type Target = ProblemState;\n\n fn deref(&self) -> &ProblemState {\n &self.problem_state\n }\n}\n\nimpl ops::DerefMut for Problem {\n fn deref_mut(&mut self) -> &mut ProblemState {\n &mut self.problem_state\n }\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "0444352e17cb62cfe0087aaaa9de7bc4", "src_uid": "0f960d19e576b7421a7c7a7166a884ea", "difficulty": 1300}
- {"lang": "Rust", "source_code": "#![allow(unused_parens)]\n#![allow(unused_imports)]\n#![allow(non_upper_case_globals)]\n#![allow(non_snake_case)]\n#![allow(unused_mut)]\n#![allow(unused_variables)]\n#![allow(dead_code)]\n\n#[allow(unused_macros)]\nmacro_rules! invec {\n ( $ t : ty ) => {{\n let mut s = String::new();\n match std::io::stdin().read_line(&mut s) {\n Ok(0) => Vec::<$t>::new(),\n Ok(n) => s\n .trim()\n .split_whitespace()\n .map(|s| s.parse::<$t>().unwrap())\n .collect::<Vec<$t>>(),\n Err(_) => Vec::<$t>::new(),\n }\n }};\n}\n\n#[allow(unused_macros)]\nmacro_rules! get {\n ($t:ty) => {\n {\n let mut line: String = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n line.trim().parse::<$t>().unwrap()\n }\n };\n ($($t:ty),*) => {\n {\n let mut line: String = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n let mut iter = line.split_whitespace();\n (\n $(iter.next().unwrap().parse::<$t>().unwrap(),)*\n )\n }\n };\n ($t:ty; $n:expr) => {\n (0..$n).map(|_|\n get!($t)\n ).collect::<Vec<_>>()\n };\n ($($t:ty),*; $n:expr) => {\n (0..$n).map(|_|\n get!($($t),*)\n ).collect::<Vec<_>>()\n };\n ($t:ty ;;) => {\n {\n let mut line: String = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n line.split_whitespace()\n .map(|t| t.parse::<$t>().unwrap())\n .collect::<Vec<_>>()\n }\n };\n ($t:ty ;; $n:expr) => {\n (0..$n).map(|_| get!($t ;;)).collect::<Vec<_>>()\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n ($($r:tt)*) => {\n let mut s = {\n use std::io::Read;\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n };\n let mut iter = s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n}\n\nmacro_rules! input_inner {\n ($iter:expr) => {};\n ($iter:expr, ) => {};\n\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n ($iter:expr, mut $var:ident : $t:tt $($r:tt)*) => {\n let mut $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! read_value {\n ($iter:expr, ( $($t:tt),* )) => {\n ( $(read_value!($iter, $t)),* )\n };\n\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()\n };\n\n ($next:expr, [$t:tt]) => {\n {\n let len = read_value!($next, usize);\n (0..len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()\n }\n };\n ($iter:expr, chars) => {\n read_value!($iter, String).chars().collect::<Vec<char>>()\n };\n\n ($iter:expr, usize1) => {\n read_value!($iter, usize) - 1\n };\n\n ($iter:expr, $t:ty) => {\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n#[allow(unused_macros)]\n#[cfg(debug_assertions)]\nmacro_rules! mydbg {\n //($arg:expr) => (dbg!($arg))\n //($arg:expr) => (println!(\"{:?}\",$arg));\n ($($a:expr),*) => {\n eprintln!(concat!($(stringify!($a), \" = {:?}, \"),*), $($a),*);\n }\n}\n#[cfg(not(debug_assertions))]\nmacro_rules! mydbg {\n ($($arg:expr),*) => {};\n}\n\nmacro_rules! echo {\n ($($a:expr),*) => {\n $(println!(\"{}\",$a))*\n }\n}\n\nuse std::cmp::*;\nuse std::collections::*;\nuse std::ops::{Add, Div, Mul, Sub};\n\n#[allow(dead_code)]\nstatic INF_I64: i64 = i64::max_value() / 2;\n#[allow(dead_code)]\nstatic INF_I32: i32 = i32::max_value() / 2;\n#[allow(dead_code)]\nstatic INF_USIZE: usize = usize::max_value() / 2;\n#[allow(dead_code)]\nstatic M_O_D: usize = 1000000007;\n#[allow(dead_code)]\nstatic PAI: f64 = 3.1415926535897932;\n\ntrait IteratorExt: Iterator {\n fn toVec(self) -> Vec<Self::Item>;\n}\n\nimpl<T: Iterator> IteratorExt for T {\n fn toVec(self) -> Vec<Self::Item> {\n self.collect()\n }\n}\n\ntrait CharExt {\n fn toNum(&self) -> usize;\n fn toAlphabetIndex(&self) -> usize;\n fn toNumIndex(&self) -> usize;\n}\nimpl CharExt for char {\n fn toNum(&self) -> usize {\n return *self as usize;\n }\n fn toAlphabetIndex(&self) -> usize {\n return self.toNum() - 'a' as usize;\n }\n fn toNumIndex(&self) -> usize {\n return self.toNum() - '0' as usize;\n }\n}\n\ntrait VectorExt {\n fn joinToString(&self, s: &str) -> String;\n}\nimpl<T: ToString> VectorExt for Vec<T> {\n fn joinToString(&self, s: &str) -> String {\n return self\n .iter()\n .map(|x| x.to_string())\n .collect::<Vec<_>>()\n .join(s);\n }\n}\n\ntrait StringExt {\n fn get_reverse(&self) -> String;\n}\nimpl StringExt for String {\n fn get_reverse(&self) -> String {\n self.chars().rev().collect::<String>()\n }\n}\n\ntrait UsizeExt {\n fn pow(&self, n: usize) -> usize;\n}\nimpl UsizeExt for usize {\n fn pow(&self, n: usize) -> usize {\n return ((*self as u64).pow(n as u32)) as usize;\n }\n}\n\nfn main() {\n let T = get!(usize);\n for testcase in 0..T {\n mydbg!(testcase);\n let mut ans: usize = 0;\n let (mut v, mut c, mut n, mut m) = get!(i64, i64, i64, i64);\n mydbg!(v, c, n, m);\n\n if v > c {\n let x = min(m, c);\n c -= x;\n m -= x;\n } else if v <= c {\n let x = min(m, v);\n v -= x;\n m -= x;\n }\n\n mydbg!(v, c, n, m);\n if v > c {\n let x = min(n, v);\n v -= x;\n n -= x;\n } else if v <= c {\n let x = min(n, c);\n c -= x;\n n -= x;\n }\n mydbg!(v, c, n, m);\n\n if n == 0 && m == 0 {\n echo!(\"Yes\");\n } else {\n echo!(\"No\");\n }\n }\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "72d2fea25f04866e01497803d14b787f", "src_uid": "0f960d19e576b7421a7c7a7166a884ea", "difficulty": 1300}
- {"lang": "Rust", "source_code": "#![allow(unused_parens)]\n#![allow(unused_imports)]\n#![allow(non_upper_case_globals)]\n#![allow(non_snake_case)]\n#![allow(unused_mut)]\n#![allow(unused_variables)]\n#![allow(dead_code)]\n\n#[allow(unused_macros)]\nmacro_rules! invec {\n ( $ t : ty ) => {{\n let mut s = String::new();\n match std::io::stdin().read_line(&mut s) {\n Ok(0) => Vec::<$t>::new(),\n Ok(n) => s\n .trim()\n .split_whitespace()\n .map(|s| s.parse::<$t>().unwrap())\n .collect::<Vec<$t>>(),\n Err(_) => Vec::<$t>::new(),\n }\n }};\n}\n\n#[allow(unused_macros)]\nmacro_rules! get {\n ($t:ty) => {\n {\n let mut line: String = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n line.trim().parse::<$t>().unwrap()\n }\n };\n ($($t:ty),*) => {\n {\n let mut line: String = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n let mut iter = line.split_whitespace();\n (\n $(iter.next().unwrap().parse::<$t>().unwrap(),)*\n )\n }\n };\n ($t:ty; $n:expr) => {\n (0..$n).map(|_|\n get!($t)\n ).collect::<Vec<_>>()\n };\n ($($t:ty),*; $n:expr) => {\n (0..$n).map(|_|\n get!($($t),*)\n ).collect::<Vec<_>>()\n };\n ($t:ty ;;) => {\n {\n let mut line: String = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n line.split_whitespace()\n .map(|t| t.parse::<$t>().unwrap())\n .collect::<Vec<_>>()\n }\n };\n ($t:ty ;; $n:expr) => {\n (0..$n).map(|_| get!($t ;;)).collect::<Vec<_>>()\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n ($($r:tt)*) => {\n let mut s = {\n use std::io::Read;\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n };\n let mut iter = s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n}\n\nmacro_rules! input_inner {\n ($iter:expr) => {};\n ($iter:expr, ) => {};\n\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n ($iter:expr, mut $var:ident : $t:tt $($r:tt)*) => {\n let mut $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! read_value {\n ($iter:expr, ( $($t:tt),* )) => {\n ( $(read_value!($iter, $t)),* )\n };\n\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()\n };\n\n ($next:expr, [$t:tt]) => {\n {\n let len = read_value!($next, usize);\n (0..len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()\n }\n };\n ($iter:expr, chars) => {\n read_value!($iter, String).chars().collect::<Vec<char>>()\n };\n\n ($iter:expr, usize1) => {\n read_value!($iter, usize) - 1\n };\n\n ($iter:expr, $t:ty) => {\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n#[allow(unused_macros)]\n#[cfg(debug_assertions)]\nmacro_rules! mydbg {\n //($arg:expr) => (dbg!($arg))\n //($arg:expr) => (println!(\"{:?}\",$arg));\n ($($a:expr),*) => {\n eprintln!(concat!($(stringify!($a), \" = {:?}, \"),*), $($a),*);\n }\n}\n#[cfg(not(debug_assertions))]\nmacro_rules! mydbg {\n ($($arg:expr),*) => {};\n}\n\nmacro_rules! echo {\n ($($a:expr),*) => {\n $(println!(\"{}\",$a))*\n }\n}\n\nuse std::cmp::*;\nuse std::collections::*;\nuse std::ops::{Add, Div, Mul, Sub};\n\n#[allow(dead_code)]\nstatic INF_I64: i64 = i64::max_value() / 2;\n#[allow(dead_code)]\nstatic INF_I32: i32 = i32::max_value() / 2;\n#[allow(dead_code)]\nstatic INF_USIZE: usize = usize::max_value() / 2;\n#[allow(dead_code)]\nstatic M_O_D: usize = 1000000007;\n#[allow(dead_code)]\nstatic PAI: f64 = 3.1415926535897932;\n\ntrait IteratorExt: Iterator {\n fn toVec(self) -> Vec<Self::Item>;\n}\n\nimpl<T: Iterator> IteratorExt for T {\n fn toVec(self) -> Vec<Self::Item> {\n self.collect()\n }\n}\n\ntrait CharExt {\n fn toNum(&self) -> usize;\n fn toAlphabetIndex(&self) -> usize;\n fn toNumIndex(&self) -> usize;\n}\nimpl CharExt for char {\n fn toNum(&self) -> usize {\n return *self as usize;\n }\n fn toAlphabetIndex(&self) -> usize {\n return self.toNum() - 'a' as usize;\n }\n fn toNumIndex(&self) -> usize {\n return self.toNum() - '0' as usize;\n }\n}\n\ntrait VectorExt {\n fn joinToString(&self, s: &str) -> String;\n}\nimpl<T: ToString> VectorExt for Vec<T> {\n fn joinToString(&self, s: &str) -> String {\n return self\n .iter()\n .map(|x| x.to_string())\n .collect::<Vec<_>>()\n .join(s);\n }\n}\n\ntrait StringExt {\n fn get_reverse(&self) -> String;\n}\nimpl StringExt for String {\n fn get_reverse(&self) -> String {\n self.chars().rev().collect::<String>()\n }\n}\n\ntrait UsizeExt {\n fn pow(&self, n: usize) -> usize;\n}\nimpl UsizeExt for usize {\n fn pow(&self, n: usize) -> usize {\n return ((*self as u64).pow(n as u32)) as usize;\n }\n}\n\nfn main() {\n let T = get!(usize);\n for testcase in 0..T {\n let mut ans: usize = 0;\n let (mut v, mut c, mut n, mut m) = get!(u64, u64, u64, u64);\n if v > c {\n std::mem::swap(&mut v, &mut c);\n }\n if m > v {\n echo!(\"No\");\n } else if v - m + c < n {\n echo!(\"No\");\n } else {\n echo!(\"Yes\");\n }\n }\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "716973821a6a38ea6231a427aeaa54ce", "src_uid": "0f960d19e576b7421a7c7a7166a884ea", "difficulty": 1300}
- {"lang": "Rust", "source_code": "#![allow(unused_parens)]\n#![allow(unused_imports)]\n#![allow(non_upper_case_globals)]\n#![allow(non_snake_case)]\n#![allow(unused_mut)]\n#![allow(unused_variables)]\n#![allow(dead_code)]\n\n#[allow(unused_macros)]\nmacro_rules! invec {\n ( $ t : ty ) => {{\n let mut s = String::new();\n match std::io::stdin().read_line(&mut s) {\n Ok(0) => Vec::<$t>::new(),\n Ok(n) => s\n .trim()\n .split_whitespace()\n .map(|s| s.parse::<$t>().unwrap())\n .collect::<Vec<$t>>(),\n Err(_) => Vec::<$t>::new(),\n }\n }};\n}\n\n#[allow(unused_macros)]\nmacro_rules! get {\n ($t:ty) => {\n {\n let mut line: String = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n line.trim().parse::<$t>().unwrap()\n }\n };\n ($($t:ty),*) => {\n {\n let mut line: String = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n let mut iter = line.split_whitespace();\n (\n $(iter.next().unwrap().parse::<$t>().unwrap(),)*\n )\n }\n };\n ($t:ty; $n:expr) => {\n (0..$n).map(|_|\n get!($t)\n ).collect::<Vec<_>>()\n };\n ($($t:ty),*; $n:expr) => {\n (0..$n).map(|_|\n get!($($t),*)\n ).collect::<Vec<_>>()\n };\n ($t:ty ;;) => {\n {\n let mut line: String = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n line.split_whitespace()\n .map(|t| t.parse::<$t>().unwrap())\n .collect::<Vec<_>>()\n }\n };\n ($t:ty ;; $n:expr) => {\n (0..$n).map(|_| get!($t ;;)).collect::<Vec<_>>()\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n ($($r:tt)*) => {\n let mut s = {\n use std::io::Read;\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n };\n let mut iter = s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n}\n\nmacro_rules! input_inner {\n ($iter:expr) => {};\n ($iter:expr, ) => {};\n\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n ($iter:expr, mut $var:ident : $t:tt $($r:tt)*) => {\n let mut $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! read_value {\n ($iter:expr, ( $($t:tt),* )) => {\n ( $(read_value!($iter, $t)),* )\n };\n\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()\n };\n\n ($next:expr, [$t:tt]) => {\n {\n let len = read_value!($next, usize);\n (0..len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()\n }\n };\n ($iter:expr, chars) => {\n read_value!($iter, String).chars().collect::<Vec<char>>()\n };\n\n ($iter:expr, usize1) => {\n read_value!($iter, usize) - 1\n };\n\n ($iter:expr, $t:ty) => {\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n#[allow(unused_macros)]\n#[cfg(debug_assertions)]\nmacro_rules! mydbg {\n //($arg:expr) => (dbg!($arg))\n //($arg:expr) => (println!(\"{:?}\",$arg));\n ($($a:expr),*) => {\n eprintln!(concat!($(stringify!($a), \" = {:?}, \"),*), $($a),*);\n }\n}\n#[cfg(not(debug_assertions))]\nmacro_rules! mydbg {\n ($($arg:expr),*) => {};\n}\n\nmacro_rules! echo {\n ($($a:expr),*) => {\n $(println!(\"{}\",$a))*\n }\n}\n\nuse std::cmp::*;\nuse std::collections::*;\nuse std::ops::{Add, Div, Mul, Sub};\n\n#[allow(dead_code)]\nstatic INF_I64: i64 = i64::max_value() / 2;\n#[allow(dead_code)]\nstatic INF_I32: i32 = i32::max_value() / 2;\n#[allow(dead_code)]\nstatic INF_USIZE: usize = usize::max_value() / 2;\n#[allow(dead_code)]\nstatic M_O_D: usize = 1000000007;\n#[allow(dead_code)]\nstatic PAI: f64 = 3.1415926535897932;\n\ntrait IteratorExt: Iterator {\n fn toVec(self) -> Vec<Self::Item>;\n}\n\nimpl<T: Iterator> IteratorExt for T {\n fn toVec(self) -> Vec<Self::Item> {\n self.collect()\n }\n}\n\ntrait CharExt {\n fn toNum(&self) -> usize;\n fn toAlphabetIndex(&self) -> usize;\n fn toNumIndex(&self) -> usize;\n}\nimpl CharExt for char {\n fn toNum(&self) -> usize {\n return *self as usize;\n }\n fn toAlphabetIndex(&self) -> usize {\n return self.toNum() - 'a' as usize;\n }\n fn toNumIndex(&self) -> usize {\n return self.toNum() - '0' as usize;\n }\n}\n\ntrait VectorExt {\n fn joinToString(&self, s: &str) -> String;\n}\nimpl<T: ToString> VectorExt for Vec<T> {\n fn joinToString(&self, s: &str) -> String {\n return self\n .iter()\n .map(|x| x.to_string())\n .collect::<Vec<_>>()\n .join(s);\n }\n}\n\ntrait StringExt {\n fn get_reverse(&self) -> String;\n}\nimpl StringExt for String {\n fn get_reverse(&self) -> String {\n self.chars().rev().collect::<String>()\n }\n}\n\ntrait UsizeExt {\n fn pow(&self, n: usize) -> usize;\n}\nimpl UsizeExt for usize {\n fn pow(&self, n: usize) -> usize {\n return ((*self as u64).pow(n as u32)) as usize;\n }\n}\n\nfn main() {\n let T = get!(usize);\n for testcase in 0..T {\n mydbg!(testcase);\n let mut ans: usize = 0;\n let (mut v, mut c, mut n, mut m) = get!(i64, i64, i64, i64);\n mydbg!(v, c, n, m);\n\n if v > c {\n let x = min(m, c);\n c -= x;\n m -= x;\n } else if v <= c {\n let x = min(m, v);\n v -= x;\n m -= x;\n }\n\n mydbg!(v, c, n, m);\n if v > c {\n let x = min(n, v - c);\n v -= x;\n n -= x;\n } else if v <= c {\n let x = min(n, c - v);\n c -= x;\n n -= x;\n }\n mydbg!(v, c, n, m);\n\n if n == 0 && m == 0 {\n echo!(\"Yes\");\n } else {\n echo!(\"No\");\n }\n }\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "becfc1fd55b4f46b642ae54796c1a487", "src_uid": "0f960d19e576b7421a7c7a7166a884ea", "difficulty": 1300}
- {"lang": "Rust", "source_code": "#![allow(unused_imports)]\n#![allow(dead_code)]\n \nuse std::io::Read;\n \n\nstruct State {\n a: i64,\n b: i64,\n n: i64,\n m: i64\n}\n\nfn solve(st: &mut State) {\n let mut a = st.a;\n let mut b = st.b;\n if a < b {\n std::mem::swap(&mut a, &mut b); \n }\n if b < st.m {\n print!(\"No\\n\");\n return;\n }\n b -= st.m;\n if a + b >= st.n {\n print!(\"Yes\\n\");\n }\n else {\n print!(\"No\\n\");\n }\n}\nfn main() {\n let mut buffer = String::new();\n std::io::stdin().read_to_string(&mut buffer).unwrap();\n let mut input = buffer.split_whitespace();\n \n let t: usize = input.next().unwrap().parse().unwrap();\n for _ in 0..t {\n let a: i64 = input.next().unwrap().parse().unwrap();\n let b: i64 = input.next().unwrap().parse().unwrap();\n let n: i64 = input.next().unwrap().parse().unwrap();\n let m: i64 = input.next().unwrap().parse().unwrap();\n //let a: Vec<i64> = (0..n).map(|_| input.next().unwrap().parse().unwrap()).collect();\n solve(&mut State{a: a, b: b, n: n, m: m});\n }\n \n}", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "3816a214151cc20527a319a7cb7fe1e9", "src_uid": "0f960d19e576b7421a7c7a7166a884ea", "difficulty": 1300}
- {"lang": "Rust", "source_code": "// ____ _ _ _ _\n// | _ \\ _ _ ___| |_ ___ _ __ | |_ ___ _ __ ___ _ __ | | __ _| |_ ___\n// | |_) | | | / __| __| / __| '_ \\ | __/ _ \\ '_ ` _ \\| '_ \\| |/ _` | __/ _ \\\n// | _ <| |_| \\__ \\ |_ | (__| |_) | | || __/ | | | | | |_) | | (_| | || __/\n// |_| \\_\\\\__,_|___/\\__| \\___| .__/___\\__\\___|_| |_| |_| .__/|_|\\__,_|\\__\\___|\n// |_| |_____| |_|\n\n//https://github.com/manta1130/Competitive_Programming_Template_Rust\n\n#[macro_use]\nmod input {\n\n use std;\n use std::io;\n\n const SPLIT_DELIMITER: char = ' ';\n\n #[macro_export]\n #[allow(unused_macros)]\n macro_rules! input {\n ( $($x:expr ),*) => {\n {\n let temp_str = input_line_str();\n let mut split_result_iter = temp_str.split_whitespace();\n $(\n let buf_split_result = split_result_iter.next();\n let buf_split_result = buf_split_result.unwrap();\n ($x) = buf_split_result.parse().unwrap();\n )*\n }\n };\n}\n\n #[allow(dead_code)]\n pub fn input_line_str() -> String {\n let mut s = String::new();\n io::stdin().read_line(&mut s).unwrap();\n s.trim().to_string()\n }\n\n #[allow(dead_code)]\n pub fn p<T>(t: T)\n where\n T: std::fmt::Display,\n {\n println!(\"{}\", t);\n }\n\n #[allow(dead_code)]\n pub fn input_vector2d<T>(line: usize) -> Vec<Vec<T>>\n where\n T: std::str::FromStr,\n {\n let mut v: Vec<Vec<T>> = Vec::new();\n\n for _ in 0..line {\n let vec_line = input_vector();\n v.push(vec_line);\n }\n v\n }\n\n #[allow(dead_code)]\n pub fn input_vector<T>() -> Vec<T>\n where\n T: std::str::FromStr,\n {\n let mut v: Vec<T> = Vec::new();\n\n let s = input_line_str();\n let split_result = s.split(SPLIT_DELIMITER);\n for z in split_result {\n let buf = match z.parse() {\n Ok(r) => r,\n Err(_) => panic!(\"Parse Error\"),\n };\n v.push(buf);\n }\n v\n }\n\n #[allow(dead_code)]\n pub fn input_vector_row<T>(n: usize) -> Vec<T>\n where\n T: std::str::FromStr,\n {\n let mut v = Vec::with_capacity(n);\n for _ in 0..n {\n let buf = match input_line_str().parse() {\n Ok(r) => r,\n Err(_) => panic!(\"Parse Error\"),\n };\n v.push(buf);\n }\n v\n }\n\n pub trait ToCharVec {\n fn to_charvec(&self) -> Vec<char>;\n }\n\n impl ToCharVec for String {\n fn to_charvec(&self) -> Vec<char> {\n self.to_string().chars().collect::<Vec<_>>()\n }\n }\n}\n\nuse input::*;\nuse std::io::{stdout, BufWriter, Write};\nfn main() {\n let out = stdout();\n let mut out = BufWriter::new(out.lock());\n let t: usize;\n input!(t);\n for _ in 0..t {\n let (mut a, mut b, mut n, m): (u64, u64, u64, u64);\n input!(a, b, n, m);\n if a + b < n + m {\n writeln!(out, \"No\").unwrap();\n continue;\n }\n let diff = std::cmp::max(a, b) - std::cmp::min(a, b);\n if a > b {\n a -= std::cmp::min(diff, n);\n } else {\n b -= std::cmp::min(diff, n);\n }\n if diff > n {\n n = 0;\n } else {\n n -= diff;\n }\n if std::cmp::min(a, b) < m {\n writeln!(out, \"No\").unwrap();\n continue;\n }\n writeln!(out, \"Yes\").unwrap();\n }\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "41f2121957142a30b2d663820b329042", "src_uid": "0f960d19e576b7421a7c7a7166a884ea", "difficulty": 1300}
- {"lang": "Rust", "source_code": "use std::cmp;\nuse std::io;\n\nstruct Scanner {\n buffer: Vec<String>,\n}\n\nimpl Scanner {\n fn next<T: std::str::FromStr>(&mut self) -> T {\n if self.buffer.is_empty() {\n let mut input = String::new();\n io::stdin().read_line(&mut input).ok();\n self.buffer = input\n .trim()\n .split(' ')\n .map(|x| x.to_string())\n .rev()\n .collect();\n }\n let x = self.buffer.pop().unwrap();\n match x.parse::<T>() {\n Ok(y) => y,\n _ => panic!(\"Parsing error !!!\"),\n }\n }\n}\n\nfn main() {\n let mut scan = Scanner { buffer: Vec::new() };\n let t = scan.next::<u32>();\n for _test in 0..t {\n let v = scan.next::<u64>();\n let c = scan.next::<u64>();\n let n = scan.next::<u64>();\n let m = scan.next::<u64>();\n if n + m <= v + c && cmp::min(v, c) >= m {\n println!(\"Yes\");\n } else {\n println!(\"No\");\n }\n }\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "0bf0249df981052aaeeb489b11382107", "src_uid": "0f960d19e576b7421a7c7a7166a884ea", "difficulty": 1300}
- {"lang": "Rust", "source_code": "// First Rust Submission\n\nuse std::io;\n\nfn mnm(x: u64, y: u64) -> u64 {\n if x < y {\n return x;\n } else {\n return y;\n }\n}\n\nfn main() {\n let mut line = String::new();\n io::stdin().read_line(&mut line).unwrap();\n let case: u32 = line.trim().parse().unwrap();\n for test in 0..case {\n line.clear();\n io::stdin().read_line(&mut line).unwrap();\n let input: Vec<&str> = line.split(' ').collect();\n let v: u64 = input[0].trim().parse().unwrap();\n let c: u64 = input[1].trim().parse().unwrap();\n let n: u64 = input[2].trim().parse().unwrap();\n let m: u64 = input[3].trim().parse().unwrap();\n if v + c >= n + m && mnm(v, c) >= m {\n println!(\"{}\", \"YES\");\n } else {\n println!(\"{}\", \"NO\");\n }\n }\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "ea0a14b308b0177123f9b440fbaf49fe", "src_uid": "0f960d19e576b7421a7c7a7166a884ea", "difficulty": 1300}
- {"lang": "Rust", "source_code": "use std::io::{self, BufRead};\nuse std::cmp::min;\n\nfn main() {\n let stdin = io::stdin();\n let mut lines = stdin.lock().lines();\n let t: usize = lines.next().unwrap().unwrap().parse().unwrap();\n for _ in 0..t {\n let xs: Vec<u64> = lines.next().unwrap().unwrap().split(' ').map(|x| x.parse().unwrap()).collect();\n let (a, b, n, m) = (xs[0], xs[1], xs[2], xs[3]);\n let c = min(a, b);\n let ok = m <= c && m + n <= a + b;\n println!(\"{}\", if ok { \"Yes\" } else { \"No\" });\n }\n}", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "cc5388c57d67f8edd3359905fead33a9", "src_uid": "0f960d19e576b7421a7c7a7166a884ea", "difficulty": 1300}
- {"lang": "Rust", "source_code": "//https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 \u3088\u308a\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n ($($r:tt)*) => {\n let s = {\n use std::io::Read;\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n };\n let mut iter = s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n}\n\nmacro_rules! input_inner {\n ($iter:expr) => {};\n ($iter:expr, ) => {};\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n}\n\nmacro_rules! read_value {\n ($iter:expr, ( $($t:tt),* )) => {\n ( $(read_value!($iter, $t)),* )\n };\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()\n };\n ($iter:expr, chars) => {\n read_value!($iter, String).chars().collect::<Vec<char>>()\n };\n ($iter:expr, bytes) => {\n read_value!($iter, String).bytes().collect::<Vec<u8>>()\n };\n ($iter:expr, usize1) => {\n read_value!($iter, usize) - 1\n };\n ($iter:expr, $t:ty) => {\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n//\n\nuse std::io::Write;\n\nfn run() {\n let out = std::io::stdout();\n let mut out = std::io::BufWriter::new(out.lock());\n input! {\n t: usize,\n ask: [(i64, i64, i64, i64); t],\n }\n for (mut a, mut b, n, m) in ask {\n if a < b {\n std::mem::swap(&mut a, &mut b);\n }\n let ans = if b < m || a + b < n + m {\n \"No\"\n } else {\n \"Yes\"\n };\n writeln!(out, \"{}\", ans).ok();\n }\n}\n\nfn main() {\n run();\n}\n", "lang_cluster": "Rust", "compilation_error": false, "code_uid": "7c2c5be44f85b2c1ac5f8389bcba0518", "src_uid": "0f960d19e576b7421a7c7a7166a884ea", "difficulty": 1300}
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
