Problem:
Score : 400 points

Problem Statement

We have N points in a two-dimensional plane.

The coordinates of the i-th point (1 \leq i \leq N) are (x_i,y_i).

Let us consider a rectangle whose sides are parallel to the coordinate axes that contains K or more of the N points in its interior.

Here, points on the sides of the rectangle are considered to be in the interior.

Find the minimum possible area of such a rectangle.

Constraints

2 \leq K \leq N \leq 50

-10^9 \leq x_i,y_i \leq 10^9 (1 \leq i \leq N)

x_i≠x_j (1 \leq i<j \leq N)

y_i≠y_j (1 \leq i<j \leq N)

All input values are integers. (Added at 21:50 JST)

Input

Input is given from Standard Input in the following format:

N K
x_1 y_1
:
x_{N} y_{N}

Output

Print the minimum possible area of a rectangle that satisfies the condition.

Sample Input 1

4 4
1 4
3 3
6 2
8 1

Sample Output 1

21

One rectangle that satisfies the condition with the minimum possible area has the following vertices: (1,1), (8,1), (1,4) and (8,4).

Its area is (8-1) × (4-1) = 21.

Sample Input 2

4 2
0 0
1 1
2 2
3 3

Sample Output 2

1

Sample Input 3

4 3
-1000000000 -1000000000
1000000000 1000000000
-999999999 999999999
999999999 -999999999

Sample Output 3

3999999996000000001

Watch out for integer overflows.

Solution in Rust (1.15.1) (judge verdict: Accepted)

// This code is generated by [cargo-atcoder](https://github.com/tanakh/cargo-atcoder)
// Original source code:
/*
#[allow(unused_imports)]
use itertools::Itertools;
#[allow(unused_imports)]
use num::*;
use proconio::input;
#[allow(unused_imports)]
use proconio::marker::*;
#[allow(unused_imports)]
use std::collections::*;

fn main() {
  input! {
    n: usize, k: usize,
    xyv: [(i64, i64); n]
  };

  let mut res = std::i64::MAX;
  for cv in xyv.clone().into_iter().combinations(std::cmp::min(k, 3)) {
    let xv = cv.iter().map(|&c| c.0).collect::<Vec<_>>();
    let yv = cv.iter().map(|&c| c.1).collect::<Vec<_>>();
    let l = *xv.iter().min().unwrap();
    let r = *xv.iter().max().unwrap();
    let t = *yv.iter().max().unwrap();
    let b = *yv.iter().min().unwrap();
    let mut c = 0;
    for &(x, y) in &xyv {
      if x >= l && x <= r && y <= t && y >= b {
        c += 1;
      }
    }
    if c >= k {
      let area = (l - r).abs() * (t - b).abs();
      if area < res {
        res = area;
      }
    }
  }
  for cv in xyv.clone().into_iter().combinations(4) {
    let xv = cv.iter().map(|&c| c.0).collect::<Vec<_>>();
    let yv = cv.iter().map(|&c| c.1).collect::<Vec<_>>();
    let l = *xv.iter().min().unwrap();
    let r = *xv.iter().max().unwrap();
    let t = *yv.iter().max().unwrap();
    let b = *yv.iter().min().unwrap();
    let mut c = 0;
    for &(x, y) in &xyv {
      if x >= l && x <= r && y <= t && y >= b {
        c += 1;
      }
    }
    if c >= k {
      let area = (l - r).abs() * (t - b).abs();
      if area < res {
        res = area;
      }
    }
  }
  println!("{}", res);
}
*/

fn main() {
    let exe = "/tmp/bin55DFC0AF";
    std::io::Write::write_all(&mut std::fs::File::create(exe).unwrap(), &decode(BIN)).unwrap();
    std::fs::set_permissions(exe, std::os::unix::fs::PermissionsExt::from_mode(0o755)).unwrap();
    std::process::exit(std::process::Command::new(exe).status().unwrap().code().unwrap())
}

fn decode(v: &str) -> Vec<u8> {
    let mut ret = vec![];
    let mut buf = 0;
    let mut tbl = vec![64; 256];
    for i in 0..64 { tbl[TBL[i] as usize] = i as u8; }
    for (i, c) in v.bytes().filter_map(|c| { let c = tbl[c as usize]; if c < 64 { Some(c) } else { None } }).enumerate() {
        match i % 4 {
            0 => buf = c << 2,
            1 => { ret.push(buf | c >> 4); buf = c << 4; }
            2 => { ret.push(buf | c >> 2); buf = c << 6; }
            3 => ret.push(buf | c),
            _ => unreachable!(),
        }
    }
    ret
}

const TBL: &'static [u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const BIN: &'static str = "<base64-encoded ELF executable removed>";