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)

pub fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

pub fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>()
        .split_whitespace()
        .map(|e| e.parse().ok().unwrap())
        .collect()
}

pub fn read_vec2<T: std::str::FromStr>(n: usize) -> Vec<Vec<T>> {
    (0..n).map(|_| read_vec()).collect()
}

pub fn read_col<T: std::str::FromStr>(n: usize) -> Vec<T> {
    (0..n).map(|_| read()).collect()
}

fn main() {
    let nk: Vec<usize> = read_vec();
    let n = nk[0];
    let k = nk[1] as u32;
    let xyv: Vec<Vec<i64>> = read_vec2(n);
    let mut xy: Vec<(i64, usize, i64, usize)> = vec![];
    for i in 0..n {
        xy.push((xyv[i][0], 0, xyv[i][1], 0));
    }
    xy.sort_by(|a, b| (a.0).partial_cmp(&b.0).unwrap());
    let mut xaxis: Vec<i64> = vec![0; n + 1];
    for i in 0..n {
        xy[i].1 = i + 1;
        xaxis[i + 1] = xy[i].0;
    }
    xy.sort_by(|a, b| (a.2).partial_cmp(&b.2).unwrap());
    let mut yaxis: Vec<i64> = vec![0; n + 1];
    for i in 0..n {
        xy[i].3 = i + 1;
        yaxis[i + 1] = xy[i].2;
    }

    let mut cnt: Vec<Vec<u32>> = vec![vec![0; n + 1]; n + 1];
    let mut map: Vec<Vec<bool>> = vec![vec![false; n + 1]; n + 1];

    for i in 0..n {
        map[xy[i].1][xy[i].3] = true;
    }

    for i in 1..n + 1 {
        for j in 1..n + 1 {
            cnt[i][j] = cnt[i - 1][j] + cnt[i][j - 1] - cnt[i - 1][j - 1];
            if map[i][j] {
                cnt[i][j] += 1;
            }
        }
    }

    let mut ans: u64 = 4000000000000000000;
    for ix0 in 1..n + 1 {
        for iy0 in 1..n + 1 {
            for ix1 in ix0 + 1..n + 1 {
                for iy1 in iy0 + 1..n + 1 {
                    let c = cnt[ix1][iy1] + cnt[ix0 - 1][iy0 - 1]
                        - cnt[ix0 - 1][iy1]
                        - cnt[ix1][iy0 - 1];
                    if c != k {
                        continue;
                    }
                    let x = (xaxis[ix1] - xaxis[ix0]) as u64;
                    let y = (yaxis[iy1] - yaxis[iy0]) as u64;
                    let tmp = x * y;
                    if tmp < ans {
                        ans = tmp;
                    }
                }
            }
        }
    }

    println!("{}", ans);
}