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 C (GCC 9.2.1) (judge verdict: Accepted)

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define max(p,q)((p)>(q)?(p):(q))
#define min(p,q)((p)>(q)?(q):(p))
int i,j,k,l,m;
int xa,xb,ya,yb;
int maxx,minx,maxy,miny;
int x,y;
int cnt;
int N,K;
int point[51][2];
long long int menseki;
long long int answer=5000000000000000000;


int main(){
    scanf("%d%d",&N,&K);
    //printf("%lld\n",answer);
    for (i=0;i<N;i++){
        scanf("%d%d",&x,&y);
        point[i][0]=x;
        point[i][1]=y;
    }
    /*
    for (i=0;i<N;i++){
        //printf("%d %d\n",point[i][0],point[i][1]);
    }
     */
    for (i=0;i<N;i++){
        for (j=i;j<N;j++){
            xa=point[i][0];
            xb=point[j][0];
            minx=min(xa,xb);
            maxx=max(xa,xb);
            for (k=0;k<N;k++){
                for (l=k;l<N;l++){
                    ya=point[k][1];
                    yb=point[l][1];
                    miny=min(ya,yb);
                    maxy=max(ya,yb);
                    cnt=0;
                    menseki=(long long int)(maxx-minx)*(maxy-miny);
                    //printf("%d %d %d %d %lld\n",maxx,minx,maxy,miny,menseki);
                    for (m=0;m<N;m++){
                        x=point[m][0];
                        y=point[m][1];
                        if ((minx<=x)&&(x<=maxx)&&(miny<=y)&&(y<=maxy)) cnt++;
                        
                    }
                    //printf("%d %d\n",cnt,K);
                    if (cnt>=K) answer=min(answer,menseki);
                    //printf("%lld\n",answer);
                }
            }
        }
    }
    printf("%lld",answer);
    return 0;
}