Submission #8536511
Source Code Expand
#[doc = " https://github.com/hatoo/competitive-rust-snippets"]
#[allow(unused_imports)]
use std::cmp::{max, min, Ordering};
#[allow(unused_imports)]
use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};
#[allow(unused_imports)]
use std::io::{stdin, stdout, BufWriter, Write};
#[allow(unused_imports)]
use std::iter::FromIterator;
#[macro_export]
macro_rules ! chmax { ( $ x : expr , $ ( $ v : expr ) ,+ ) => { $ ( $ x = std :: cmp :: max ( $ x ,$ v ) ; ) + } ; }
#[macro_export]
macro_rules ! chmin { ( $ x : expr , $ ( $ v : expr ) ,+ ) => { $ ( $ x = std :: cmp :: min ( $ x ,$ v ) ; ) + } ; }
#[macro_export]
macro_rules ! max { ( $ x : expr ) => ( $ x ) ; ( $ x : expr , $ ( $ xs : expr ) ,+ ) => { std :: cmp :: max ( $ x , max ! ( $ ( $ xs ) ,+ ) ) } ; }
#[macro_export]
macro_rules ! min { ( $ x : expr ) => ( $ x ) ; ( $ x : expr , $ ( $ xs : expr ) ,+ ) => { std :: cmp :: min ( $ x , min ! ( $ ( $ xs ) ,+ ) ) } ; }
#[macro_export]
macro_rules ! dvec { ( $ t : expr ; $ len : expr ) => { vec ! [ $ t ; $ len ] } ; ( $ t : expr ; $ len : expr , $ ( $ rest : expr ) ,* ) => { vec ! [ dvec ! ( $ t ; $ ( $ rest ) ,* ) ; $ len ] } ; }
#[allow(unused_macros)]
macro_rules ! debug { ( $ ( $ a : expr ) ,* ) => { eprintln ! ( concat ! ( $ ( stringify ! ( $ a ) , " = {:?}, " ) ,* ) , $ ( $ a ) ,* ) ; } }
#[macro_export]
macro_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 ) * } } ; }
#[macro_export]
macro_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 ) * } } ; }
#[macro_export]
macro_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" ) } ; }
use std::io;
use std::io::BufRead;
use std::str;
pub struct Parser<R> {
reader: R,
buf: Vec<u8>,
pos: usize,
}
impl Parser<io::Empty> {
pub fn from_str(s: &str) -> Parser<io::Empty> {
Parser {
reader: io::empty(),
buf: s.as_bytes().to_vec(),
pos: 0,
}
}
}
impl<R: BufRead> Parser<R> {
pub fn new(reader: R) -> Parser<R> {
Parser {
reader: reader,
buf: vec![],
pos: 0,
}
}
pub fn update_buf(&mut self) {
self.buf.clear();
self.pos = 0;
loop {
let (len, complete) = {
let buf2 = self.reader.fill_buf().unwrap();
self.buf.extend_from_slice(buf2);
let len = buf2.len();
if len == 0 {
break;
}
(len, buf2[len - 1] <= 0x20)
};
self.reader.consume(len);
if complete {
break;
}
}
}
pub fn next<T: str::FromStr>(&mut self) -> Result<T, T::Err> {
loop {
let mut begin = self.pos;
while begin < self.buf.len() && (self.buf[begin] <= 0x20) {
begin += 1;
}
let mut end = begin;
while end < self.buf.len() && (self.buf[end] > 0x20) {
end += 1;
}
if begin != self.buf.len() {
self.pos = end;
return str::from_utf8(&self.buf[begin..end]).unwrap().parse::<T>();
} else {
self.update_buf();
}
}
}
}
#[allow(unused_macros)]
macro_rules ! debug { ( $ ( $ a : expr ) ,* ) => { eprintln ! ( concat ! ( $ ( stringify ! ( $ a ) , " = {:?}, " ) ,* ) , $ ( $ a ) ,* ) ; } }
#[doc = " https://github.com/hatoo/competitive-rust-snippets"]
const BIG_STACK_SIZE: bool = true;
#[allow(dead_code)]
fn main() {
use std::thread;
if BIG_STACK_SIZE {
thread::Builder::new()
.stack_size(32 * 1024 * 1024)
.name("solve".into())
.spawn(solve)
.unwrap()
.join()
.unwrap();
} else {
solve();
}
}
fn solve() {
input!{
n:usize,
xy:[(i64,i64);n]
}
let mut z = vec![];
for i in 0..n {
let (x,y) = xy[i];
z.push((x,i));
z.push((y,i));
}
z.sort();
let mut h = HashSet::new();
for i in 0..min(z.len(),10) {
h.insert(z[i].1);
}
z.reverse();
for i in 0..min(z.len(),10) {
h.insert(z[i].1);
}
let mut z: Vec<usize> = h.into_iter().collect();
z.sort();
let m = z.len();
let mut minv = std::i64::MAX;
for bit in 0..(1<<m) {
let mut R = vec![];
let mut B = vec![];
for j in 0..m {
let (x,y) = xy[z[j]];
if (bit & (1<<j)) > 0 {
R.push(x);
B.push(y);
} else {
R.push(y);
B.push(x);
}
}
R.sort();
let rmax = R[m-1];
let rmin = R[0];
B.sort();
let bmax = B[m-1];
let bmin = B[0];
let v = (rmax-rmin) * (bmax-bmin);
chmin!(minv,v);
}
println!("{}", minv);
}
Submission Info
Submission Time
2019-11-20 19:24:39+0900
Task
E - Ball Coloring
User
akiradeveloper
Language
Rust (1.15.1)
Score
0
Code Size
6295 Byte
Status
WA
Exec Time
748 ms
Memory
28400 KB
Compile Error
warning: variable `R` should have a snake case name such as `r`, #[warn(non_snake_case)] on by default
--> ./Main.rs:140:13
|
140 | let mut R = vec![];
| ^^^^^
warning: variable `B` should have a snake case name such as `b`, #[warn(non_snake_case)] on by default
--> ./Main.rs:141:13
|
141 | let mut B = vec![];
| ^^^^^
Judge Result
Set Name
Sample
All
Score / Max Score
0 / 0
0 / 700
Status
Set Name
Test Cases
Sample
example0, example1, example2
All
div20, div21, div22, div23, div24, example0, example1, example2, maxrand0, maxrand1, maxrand2, maxrand20, maxrand21, maxrand210, maxrand211, maxrand22, maxrand23, maxrand24, maxrand25, maxrand26, maxrand27, maxrand28, maxrand29, maxrand3, maxrand4, smallrand0, smallrand1, smallrand2, smallrand3, smallrand4, sparse0, sparse1, sparse2, sparse3, sparse4
Case Name
Status
Exec Time
Memory
div20
WA
711 ms
28400 KB
div21
WA
727 ms
28400 KB
div22
WA
726 ms
23800 KB
div23
WA
731 ms
23800 KB
div24
WA
723 ms
28400 KB
example0
AC
3 ms
8572 KB
example1
AC
3 ms
8572 KB
example2
AC
3 ms
8572 KB
maxrand0
WA
704 ms
23624 KB
maxrand1
WA
720 ms
23800 KB
maxrand2
WA
725 ms
23800 KB
maxrand20
WA
701 ms
23788 KB
maxrand21
WA
714 ms
23788 KB
maxrand210
AC
668 ms
25156 KB
maxrand211
WA
748 ms
23788 KB
maxrand22
WA
707 ms
23788 KB
maxrand23
WA
727 ms
23624 KB
maxrand24
WA
707 ms
23800 KB
maxrand25
AC
695 ms
23800 KB
maxrand26
AC
706 ms
23800 KB
maxrand27
WA
718 ms
23800 KB
maxrand28
WA
725 ms
23800 KB
maxrand29
WA
728 ms
23788 KB
maxrand3
WA
710 ms
23624 KB
maxrand4
WA
745 ms
23800 KB
smallrand0
AC
3 ms
8572 KB
smallrand1
AC
3 ms
8572 KB
smallrand2
AC
4 ms
8572 KB
smallrand3
AC
4 ms
8572 KB
smallrand4
AC
3 ms
8572 KB
sparse0
WA
660 ms
23800 KB
sparse1
WA
653 ms
23800 KB
sparse2
WA
654 ms
23800 KB
sparse3
WA
657 ms
23800 KB
sparse4
WA
656 ms
23788 KB