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>

long long max(long long a,long long b){
		if(a>b)return a;
		return b;
}

long long min(long long a,long long b){
		if(a<b)return a;
		return b;
}

struct xy{
		long long x;
		long long y;
};

int compare_intx(const void *a,const void *b){
		struct xy A=*(struct xy*)a,B=*(struct xy*)b;
		if(A.x>B.x)return 1;
		return -1;
}

int compare_inty(const void *a,const void *b){
		struct xy A=*(struct xy*)a,B=*(struct xy*)b;
		if(A.y>B.y)return 1;
		return -1;
}

int main(){
		struct xy xy[51];
		int n,k,i,j;
		long long ans=-1;
		scanf("%d%d",&n,&k);
		for(i=0;i<n;i++)scanf("%lld%lld",&xy[i].x,&xy[i].y);
		qsort(xy,n,sizeof(struct xy),compare_intx);
		long long h=0,w=0;
		for(i=0;i+k-1<n;i++){
				h=xy[i+k-1].x-xy[i].x;
				long long mn=xy[i].y,mx=xy[i].y;
				for(j=1;j<k;j++){
						mn=min(mn,xy[j+i].y);
						mx=max(mx,xy[j+i].y);
				}
				w=mx-mn;
				if(ans==-1)ans=h*w;
				ans=min(ans,h*w);
		}
		qsort(xy,n,sizeof(struct xy),compare_inty);
		for(i=0;i+k-1<n;i++){
				h=xy[i+k-1].y-xy[i].y;
				long long mn=xy[i].x,mx=xy[i].x;
				for(j=0;j<k;j++){
						mn=min(mn,xy[i+j].x);
						mx=max(mx,xy[i+j].x);
				}
				w=mx-mn;
				ans=min(ans,h*w);
		}
		printf("%lld\n",ans);
		return 0;
}