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++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include<bits/stdc++.h>
using namespace std;
using ll=long long;
using ull=unsigned long long;
vector<ll> x,y;
ll N,K,px[50],py[50];
ull ans{numeric_limits<ull>::max()};
ull ullabs(ll a){return a<0?-a:a;}
int main(){
    cin>>N>>K;
    for(int i{};i<N;++i){
        cin>>px[i]>>py[i];
        x.push_back(px[i]),y.push_back(py[i]);
//        for(int j{-1};j<=1;++j)
//            x.push_back(px[i]+j),y.push_back(py[i]+j);
    }
    sort(x.begin(),x.end());
    sort(y.begin(),y.end());
    x.erase(unique(x.begin(),x.end()),x.end());
    y.erase(unique(y.begin(),y.end()),y.end());
    for(int i{};i<x.size();++i){
        ll now{},ix{i};
        for(int j{i};j<x.size();++j){
            for(int k{};k<N;++k)
                if(px[k]==x[j])
                    ++now;
            if(now>=K){
                ix=j;
                break;
            }
        }
        //if(i==ix)continue;
        if(now<K)continue;
        for(int j{};j<y.size();++j){
            ll ny{},iy{j};
            for(int k{j};k<y.size();++k){
                for(int l{};l<N;++l)
                    if(py[l]==y[k]&&px[l]>=x[i]&&px[l]<=x[ix])
                        ++ny;
                if(ny>=K){
                    iy=k;
                    break;
                }
            }
            //if(j==iy)continue;
            if(ny<K)continue;
            ans=min(ans,ullabs(x[ix]-x[i])*ullabs(y[iy]-y[j]));
        }
    }
    for(int i{};i<y.size();++i){
        ll now{},iy{i};
        for(int j{i};j<y.size();++j){
            for(int k{};k<N;++k)
                if(py[k]==y[j])
                    ++now;
            if(now>=K){
                iy=j;
                break;
            }
        }
        //if(i==ix)continue;
        if(now<K)continue;
        for(int j{};j<x.size();++j){
            ll nx{},ix{j};
            for(int k{j};k<x.size();++k){
                for(int l{};l<N;++l)
                    if(px[l]==x[k]&&py[l]>=y[i]&&py[l]<=y[iy])
                        ++nx;
                if(nx>=K){
                    ix=k;
                    break;
                }
            }
            //if(j==iy)continue;
            if(nx<K)continue;
            ans=min(ans,ullabs(x[ix]-x[j])*ullabs(y[iy]-y[i]));
        }
    }
    cout<<ans<<endl;
}