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>

void sort(long long *num, long long *num2, int sum){
    int interval = sum / 2;
    int start_num = interval, sort_num;
    long long swap;
    while(1){
        for(int i = start_num; i < sum; i += interval){
            sort_num = i;
            while(1){
                if(num[sort_num] > num[sort_num - interval]) break;
                swap = num[sort_num];
                num[sort_num] = num[sort_num - interval];
                num[sort_num - interval] = swap;
                swap = num2[sort_num];
                num2[sort_num] = num2[sort_num - interval];
                num2[sort_num - interval] = swap;
                sort_num -= interval;
                if(sort_num == (i % interval)) break;
            }
        }
        start_num++;
        if(interval == 1) break;
        if(start_num == (interval * 2)){
            interval = interval / 2;
            start_num = interval;
        }
    }
}

long long AbsV(long long n){
    if(n >= 0) return n;
    if(n < 0) return n * -1;
}

int main(){
    int N, K;
    long long *x, *y, y_max, y_min, xy_min;
    
    scanf("%d%d", &N, &K);

    x = malloc(sizeof(long long) * N);
    y = malloc(sizeof(long long) * N);
    
    for(int i = 0; i < N; i++){
        scanf("%lld%lld", &x[i], &y[i]);
    }

    sort(x, y, N);

    xy_min = (AbsV(y[K - 1] - y[0]) * AbsV(x[K - 1] - x[0]));
    for(int i = 0; (i + K - 1) < N; i++){
        y_max = y[i];
        y_min = y[i];
        for(int j = i; j < (i + K); j++){
            if(y_max < y[j]) y_max = y[j];
            if(y_min > y[j]) y_min = y[j];
        }
        if(xy_min > (AbsV(y_max - y_min) * AbsV(x[i + K - 1] - x[i]))){
            xy_min = (AbsV(y_max - y_min) * AbsV(x[i + K - 1] - x[i]));
        }
    }

    printf("%lld\n", xy_min);
    free(x);
    free(y);
    return 0;
}