Submission #1338345

---

Source Code Expand

use std::io::stdin;
use std::cmp::{max, min};

fn input_ints() -> Vec<i64> {
    let mut st = String::new();
    match stdin().read_line(&mut st) {
        Ok(_) => {
            st.split_whitespace()
                .map(|s| s.parse().unwrap())
                .collect()
        }
        Err(_) => panic!("err"),
    }
}

fn solve(xy: Vec<(i64, i64)>) -> i64 {
    let mut sort_by_larger = xy.clone();
    sort_by_larger.sort_by_key(|a| max(a.0, a.1));
    sort_by_larger.reverse();
    let mut sort_by_smaller = xy.clone();
    sort_by_smaller.sort_by_key(|a| min(a.0, a.1));

    let x = sort_by_larger[0];
    let pair_of_max = [x.0, x.1];
    let x = sort_by_smaller[0];
    let pair_of_min = [x.0, x.1];

    let x = sort_by_larger[1];
    let pair_of_second_max = [x.0, x.1];
    let x = sort_by_smaller[1];
    let pair_of_second_min = [x.0, x.1];

    let x = sort_by_larger[sort_by_larger.len() - 1];
    let pair_of_smallest_larger = [x.0, x.1];
    let x = sort_by_smaller[sort_by_smaller.len() - 1];
    let pair_of_largest_smaller = [x.0, x.1];

    let mut ret = Vec::new();
    for i in 0..2 {
        for j in 0..2 {
            for k in 0..2 {
                for l in 0..2 {
                    for m in 0..2 {
                        let x = [pair_of_max[0],
                                 pair_of_second_max[i],
                                 pair_of_second_min[j],
                                 pair_of_min[k],
                                 pair_of_smallest_larger[l],
                                 pair_of_largest_smaller[m]];
                        let y = [pair_of_max[1],
                                 pair_of_second_max[(i + 1) % 2],
                                 pair_of_second_min[(j + 1) % 2],
                                 pair_of_min[(k + 1) % 2],
                                 pair_of_smallest_larger[(l + 1) % 2],
                                 pair_of_largest_smaller[(m + 1) % 2]];
                        let r = (x.iter().max().unwrap() - x.iter().min().unwrap()) *
                                (y.iter().max().unwrap() - y.iter().min().unwrap());

                        // for i in 0..x.len() {
                        //     print!("{} ", x[i])
                        // }
                        // println!();

                        // for i in 0..y.len() {
                        //     print!("{} ", y[i])
                        // }
                        // println!();
                        // println!("{}", r);

                        ret.push(r);
                    }
                }
            }
        }
    }

    return ret.into_iter().min().unwrap();
}

fn main() {
    let l = input_ints();
    let n = l[0];

    let mut nums = Vec::new();
    for _ in 0..n {
        let l = input_ints();
        nums.push((l[0], l[1]))
    }

    println!("{}", solve(nums))
}

Submission Info

Judge Result