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>
#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;
    scanf("%d%d",&n,&k);
    struct dot {
        long long x;
        long long y;
    };
    dot_t d[n];
    for (int i=0; i<n; i++){
        scanf("%lld%lld",&d[i].x,&d[i].y);
    }
    long long tmp,ans=LONG_MAX;
    qsort (d,n,sizeof(dot_t),sortx);
    for (int i=0; i<n-k+1; i++){
        for (int j=0; j<n-k+1-i; j++){
            long long maxy=d[i].y,miny=d[i].y;
            for (int l=j; l<i+j+k; l++){
                if (maxy<d[l].y){
                    maxy=d[l].y;
                }
                if (miny>d[l].y){
                    miny=d[l].y;
                }
            }
            tmp=llabs(d[i].x-d[i+j+k-1].x)*llabs(maxy-miny);
            if (ans>tmp){
                ans=tmp;
            }
        }
    }
    qsort (d,n,sizeof(dot_t),sorty);
    for (int i=0; i<n-k+1; i++){
        for (int j=0; j<n-k+1-i; j++){
            long long maxx=d[i].x,minx=d[i].x;
            for (int l=j; l<i+j+k; l++){
                if (maxx<d[l].x){
                    maxx=d[l].x;
                }
                if (minx>d[l].x){
                    minx=d[l].x;
                }
            }
            tmp=llabs(d[i].y-d[i+j+k-1].y)*llabs(maxx-minx);
            if (ans>tmp){
                ans=tmp;
            }
        }
    }
    
    printf("%lld\n",ans);
    return 0 ;
}