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 Python (3.4.3) (judge verdict: Wrong Answer)

# -*- coding: utf-8 -*-
"""
https://beta.atcoder.jp/contests/abc075/tasks/abc075_d

"""
import sys
from sys import stdin
from statistics import mean
from math import sqrt
input = stdin.readline


def solve(points, N, K):
    to_remove = N - K

    while to_remove:
        sx = [p[0] for p in points]
        sy = [p[1] for p in points]
        cx = mean(sx)
        cy = mean(sy)

        dist = [0] * len(points)
        for i, p in enumerate(points):
            dist[i] = sqrt((cx - p[0])**2 + (cy - p[1])**2)

        i = dist.index(max(dist))
        points.pop(i)
        to_remove -= 1

    points.sort()
    lx = points[0][0]
    rx = points[-1][0]
    points.sort(key=lambda p: p[1])
    by = points[0][1]
    uy = points[-1][1]

    return (rx - lx) * (uy - by)



def main(args):
    N, K = map(int, input().split())
    points = []
    for _ in range(N):
        points.append([int(x) for x in input().split()])

    result = solve(points, N, K)
    print(result)


if __name__ == '__main__':
    main(sys.argv[1:])