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 <math.h>

int main()
{
	int n;
	int k;
	scanf("%d %d",&n,&k);
	int listx[n];
	int listy[n];
	int ct = 0;
	while(scanf("%d %d",&listx[ct],&listy[ct])!=EOF){
		ct++;
	}
	
	long long int s = pow(2,63);
	int px1,py1,px2,py2,px3,py3,xmin,xmax,ymin,ymax;
	
	for(int i=0;i<n;i++){
		px1 = listx[i];
		py1 = listy[i];
		for(int j=0;j<n;j++){
			if(i==j){continue;}
			px2 = listx[j];
			py2 = listy[j];
			int count = 0;
			for(int u=0;u<n;u++){
				if(px1<px2){
					xmin = px1;
					xmax = px2;
				}else{
					xmin = px2;
					xmax = px1;
				}
				if(py1<py2){
					ymin = py1;
					ymax = py2;
				}else{
					ymin = py2;
					ymax = py1;
				}
				px3 = listx[u];
				py3 = listy[u];
				if(xmin<=px3&&px3<=xmax && ymin<=py3&&py3<=ymax){
					count++;
				}
			}
			if(count >= k){
				long long int tmp = (xmax-xmin)*(ymax-ymin);
				if(s > tmp){
					s = tmp;
				}
			}
		}
	}
	printf("%lld\n",s);
	return 0;
}