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;

int main(){
  int n,K;
  cin >> n >> K;
  int common[n][n],common2[n][n],left[n],under[n];
  for(int i = 0;i < n;i++){
    for(int j = 0;j < n;j++){
      common[i][j] = 0;
      common2[i][j] = 0;
      left[i] = 0;
      under[j] = 0;
    }
  }
  vector<long> x(n),y(n);
  for(int i = 0;i < n;i++){
    cin >> x.at(i) >> y.at(i);
  }
  for(int i = 0;i < n;i++){
    for(int j = 0;j < n;j++){
      for(int k = 0;k < n;k++){
        if(x.at(k) < x.at(i) && y.at(k) < y.at(j)){
          common[i][j] += 1;
        }
      }
    }
  }
  for(int i = 0;i < n;i++){
    for(int j = 0;j < n;j++){
      for(int k = 0;k < n;k++){
        if(x.at(k) <= x.at(i) && y.at(k) <= y.at(j)){
          common2[i][j] += 1;
        }
      }
    }
  }
  for(int i = 0;i < n;i++){
    for(int j = 0;j < n;j++){
      if(x.at(j) < x.at(i)){
        left[i]++;
      }
    }
  }
  for(int i = 0;i < n;i++){
    for(int j = 0;j < n;j++){
      if(y.at(j) < y.at(i)){
        under[i]++;
      }
    }
  }
  long result = 4000000000000000000;
  for(int i = 0;i < n;i++){
    for(int j = 0;j < n;j++){
      for(int k = 0;k < n;k++){
        for(int l = 0;l < n;l++){
          int num = common2[l][i] - left[k] - under[j] + common[k][j];
          if(num >= K && x.at(k) <= x.at(l) && y.at(j) <= y.at(i)){
            long area = (x.at(l) - x.at(k)) * (y.at(i) - y.at(j)); 
            //cout << num << ' ' << area << ' ' << y.at(i) << ' ' << y.at(j) << ' ' << x.at(k) << ' ' << x.at(l) << endl;
            //cout << "info" << common2[l][i] << ' ' << left[k] << ' ' << under[j] << ' ' << common[k][j] << endl;
            result = min(result,area);
          }
        }
      }
    }
  }
  cout << result << endl;
}