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.42.0) (judge verdict: Accepted)

use std::cmp::*;
use std::io::*;

fn main() {
    let mut s: String = String::new();
    std::io::stdin().read_to_string(&mut s).ok();
    let mut itr = s.trim().split_whitespace();
    let n: usize = itr.next().unwrap().parse().unwrap();
    let K: usize = itr.next().unwrap().parse().unwrap();
    let xy: Vec<(i64, i64)> = (0..n)
        .map(|_| {
            (
                itr.next().unwrap().parse().unwrap(),
                itr.next().unwrap().parse().unwrap(),
            )
        })
        .collect();

    let mut ans = 1i64 << 62;
    for i in 0..n {
        for j in 0..n {
            for k in 0..n {
                for l in 0..n {
                    let R = max(xy[i].0, max(xy[j].0, max(xy[k].0, xy[l].0)));
                    let L = min(xy[i].0, min(xy[j].0, min(xy[k].0, xy[l].0)));
                    let U = max(xy[i].1, max(xy[j].1, max(xy[k].1, xy[l].1)));
                    let D = min(xy[i].1, min(xy[j].1, min(xy[k].1, xy[l].1)));
                    let mut cnt = 0;

                    for a in 0..n {
                        if L <= xy[a].0 && xy[a].0 <= R && D <= xy[a].1 && xy[a].1 <= U {
                            cnt += 1;
                        }
                    }
                    if cnt >= K {
                        ans = min(ans, (R - L) * (U - D));
                    }
                }
            }
        }
    }
    println!("{}", ans);
}