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: Accepted)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <math.h>
#include <limits.h>

typedef struct {
    long long x;
    long long y;
} dot_t;

int sortx(const void *a, const void *b){
    return ((dot_t*)a)->x - ((dot_t*)b)->x ;
}

int sorty(const void *a, const void *b){
    return ((dot_t*)a)->y - ((dot_t*)b)->y ;
}

int main(void){
    int n,k;
    long long tmp=LONG_MAX,ans=LONG_MAX;
    scanf("%d%d",&n,&k);
    dot_t dx[n],dy[n];
    for (int i=0; i<n; i++){
        scanf("%lld%lld",&dx[i].x,&dx[i].y);
        dy[i].x=dx[i].x;
        dy[i].y=dx[i].y;
    }
    qsort (dx,n,sizeof(dot_t),sortx);
    qsort (dy,n,sizeof(dot_t),sorty);
    for (int a=0; a<n; a++){
        for (int b=a+1; b<n; b++){
            for (int c=0; c<n; c++){
                for (int d=c+1; d<n; d++){
                    int count=0;
                    for (int e=0; e<n; e++){
                        if (dx[e].x>=dx[a].x && dx[e].x<=dx[b].x && dx[e].y>=dy[c].y && dx[e].y<=dy[d].y){
                            count++;
                        }
                    }
                    if (count>=k){
                        tmp=(dx[b].x-dx[a].x)*(dy[d].y-dy[c].y);
                    }
                    if (ans>tmp){
                        ans=tmp;
                    }
                }
            }
        }
    }
    printf("%lld\n",ans);
    return 0 ;
}