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

#include<stdio.h>
#include<stdlib.h>

#define min(a,b) ((a)<(b)?(a):(b))
#define max(a,b) ((a)>(b)?(a):(b))

long long xy[51][2];

int compare_intx(const void *a, const void *b){
    long long A=xy[*(long long*)a][0] - xy[*(long long*)b][0];
	if(A>0)return 1;
	if(A==0)return 0;
	return -1;
}

int compare_inty(const void *a, const void *b){
    long long A=xy[*(long long*)a][1] - xy[*(long long*)b][1];
	if(A>0)return 1;
	if(A==0)return 0;
	return -1;
}

int main(){
		int n,k,i,j;
		scanf("%d%d",&n,&k);
		for(i=0;i<n;i++)scanf("%lld%lld",&xy[i][0],&xy[i][1]);
		long long ans=-1;
		int xx[50],yy[50];
		for(i=0;i<n;i++)xx[i]=i;
		for(i=0;i<n;i++)yy[i]=i;
//		qsort(xx,n,sizeof(int),compare_intx);
//		qsort(yy,n,sizeof(int),compare_inty);
		for(i=0;i<n;i++){
				for(j=0;j<n;j++){
						if(xy[xx[i]][0]<xy[xx[j]][0]){
								int tmp=xx[i];
								xx[i]=xx[j];
								xx[j]=tmp;
						}
				}
		}
		for(i=0;i<n;i++){
				for(j=0;j<n;j++){
						if(xy[yy[i]][1]<xy[yy[j]][1]){
								int tmp=yy[i];
								yy[i]=yy[j];
								yy[j]=tmp;
						}
				}
		}
		for(i=0;i+k<=n;i++){
				long long tmp=xy[xx[i+k-1]][0]-xy[xx[i]][0];
				long long mmin=20000000000000,mmax=-20000000000000;
				for(j=0;j<k;j++){
						mmin=min(mmin,xy[xx[j]][1]);
						mmax=max(mmax,xy[xx[j]][1]);
				}
				if(ans<0)ans=tmp*(mmax-mmin);
				ans=min(ans,tmp*(mmax-mmin));
		}
		for(i=0;i+k<=n;i++){
				long long tmp=xy[yy[i+k-1]][1]-xy[yy[i]][1];
				long long mmin=20000000000000,mmax=-20000000000000;
				for(j=0;j<k;j++){
						mmin=min(mmin,xy[yy[j]][0]);
						mmax=max(mmax,xy[yy[j]][0]);
				}
				ans=min(ans,tmp*(mmax-mmin));
		}
		printf("%lld\n",ans);
		return 0;
}