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)

#[allow(unused_macros)]
macro_rules! parse_line {
    ( $t:ty ) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            iter.next().unwrap().parse::<$t>().unwrap()
        }
    );

    ( $( $t:ty), +) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            ( $(iter.next().unwrap().parse::<$t>().unwrap()),* )
        }
    );
}

#[allow(unused_macros)]
macro_rules! read_line {
    () => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            line.pop();
            line
        }
    )
}

#[allow(unused_macros)]
macro_rules! parse_vec {
    ( $t:ty ) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let iter = line.split_whitespace();
            iter.map(|v| v.parse::<$t>().unwrap()).collect::<Vec<_>>()
        }
    )
}

fn solve(k: usize, xys: Vec<(i64, i64)>) -> i64 {
    use std::cmp::{min, max};

    let xs = xys.iter().map(|&(x,y)| x).collect::<Vec<i64>>();
    let ys = xys.iter().map(|&(x,y)| y).collect::<Vec<i64>>();

    let mut min_area = std::i64::MAX;

    for &x1 in xs.iter() {
        for &x2 in xs.iter() {
            for &y1 in ys.iter() {
                for &y2 in ys.iter() {
                    let xmin = min(x1, x2);
                    let xmax = max(x1, x2);
                    let ymin = min(y1, y2);
                    let ymax = max(y1, y2);

                    let cnt = xys.iter().filter(|&&(x, y)|
                                                xmin <= x && x <= xmax &&
                                                ymin <= y && y <= ymax
                    ).count();

                    if cnt >= k {
                        let area = (xmax - xmin) * (ymax - ymin);
                        if area < min_area {
                            min_area = area;
                        }
                    }
                }
            }
        }
    }

    min_area
}

fn main() {
    let (n, k) = parse_line!(usize, usize);

    let xys = (0..n).map(|_|parse_line!(i64, i64)).collect();

    println!("{}", solve(k, xys));
}

#[test]
fn solve_test() {
    assert_eq!(solve(3, vec![(-1000000000, -1000000000),
                             (1000000000, 1000000000),
                             (-999999999, 999999999),
                             (999999999, -999999999)]), 3999999996000000001);
}