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)

use std::io;
use std::cmp;
use std::collections::BTreeSet;

// read a line(without line feed)
fn read_line() -> String {
    let mut in_str = String::new();
    io::stdin().read_line(&mut in_str).unwrap();
    return in_str.trim().to_string();
}

// read wods on a line
pub fn read_words_in_line() -> Vec<String> {
    let s = read_line();
    return s.split_whitespace().map(|x| x.to_string()).collect::<Vec<String>>()
}

// read type t on a line
pub fn read_t_in_line<T : std::str::FromStr>() -> Vec<T> {
    let mut v : Vec<T> = Vec::new();
    for e in read_words_in_line().iter().map(|x| x.parse::<T>()) {
        if let Ok(r) = e {
            v.push(r);
        }
        else{
            return Vec::new();
        }
    }
    return v;
}

// sort slice
pub fn sort<T : std::cmp::Ord>(slice : &mut [T]) {
    slice.sort();
}
// sort slice by reverse order
pub fn sort_rev<T : std::cmp::Ord>(slice : &mut [T]) {
    slice.sort_by(|x, y| y.cmp(x));
}

pub fn min<T : std::cmp::Ord>(a : T, b : T) -> T{
    return cmp::min(a, b);
}

pub fn max<T : std::cmp::Ord>(a : T, b : T) -> T{
    return cmp::max(a, b);
}


fn contain(minx : i32, miny : i32, maxx : i32, maxy : i32, tx : i32, ty : i32) -> bool {
    return minx <= tx && tx <= maxx && miny <= ty && ty <= maxy;
}

fn main() {

    let n_k = read_t_in_line::<i32>();
    let (n, k) = (n_k[0], n_k[1]);

    let mut xs = vec![];
    let mut ys = vec![];

    let mut x_set : BTreeSet<i32> = BTreeSet::new();
    let mut y_set : BTreeSet<i32> = BTreeSet::new();
    
    for _ in 0..n {
        let x_y = read_t_in_line::<i32>();
        xs.push(x_y[0]);
        ys.push(x_y[1]);
    }
    for i in 0..n {
        x_set.insert(xs[i as usize]);
        y_set.insert(ys[i as usize]);
    }

    let x_vec = x_set.iter().cloned().collect::<Vec<i32>>();
    let y_vec = y_set.iter().cloned().collect::<Vec<i32>>();

    let mut ans = i64::max_value();

    for i1 in 0..(x_vec.len()) {
        for j1 in i1..(x_vec.len()) {
            let minx = x_vec[i1];
            let maxx = x_vec[j1];
            for i2 in 0..(y_vec.len()) {
                for j2 in i2..(y_vec.len()) {
                    let miny = y_vec[i2];
                    let maxy = y_vec[j2];
                    let mut cnt = 0;
                    for m in 0..n {
                        let x = xs[m as usize];
                        let y = ys[m as usize];
                        if contain(minx, miny, maxx, maxy, x, y) {
                            cnt += 1;
                        }
                    }
                    if cnt >= k {
                        ans = min(ans, (maxx - minx) as i64 * (maxy - miny) as i64);
                    }
                }
            }

        }
    }

    println!("{}", ans);

}