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 Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Scanner;

public class Main {
	static ArrayList<Integer> cities = new ArrayList<>();
	public static void main(String args[]) {
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		int N = Integer.parseInt(sc.next());
		int K = Integer.parseInt(sc.next());
		int[] x = new int[N];
		int[] y = new int[N];
		HashMap<Integer,Integer> x_y = new HashMap<>();
		HashMap<Integer,Integer> y_x = new HashMap<>();
		
	for(int i=0;i<N;i++) {
		x[i] = Integer.parseInt(sc.next());
		y[i] = Integer.parseInt(sc.next());
		x_y.put(x[i], y[i]);
		y_x.put(y[i],x[i]);
	}
	Arrays.sort(x);
	Arrays.sort(y);
	long result = Long.MAX_VALUE;
	if(N==K) {
		result = (x[N-1]-x[0]) * (y[N-1]-y[0]);
	}
	for(int i=0;i<N-K;i++) {
		long delta_x = x[i+K-1]-x[i];
		int y_max = Integer.MIN_VALUE;
		int y_min = Integer.MAX_VALUE;
		for(int j=i;j<i+K;j++) {
			y_max = Math.max(y_max, x_y.get(x[j]));
			y_min = Math.min(y_min, x_y.get(x[j]));
		}
		long delta_y = y_max-y_min;
		
		if(delta_x*delta_y>0) result = Math.min(result, delta_x*delta_y);
	}
	for(int i=0;i<N-K;i++) {
		long delta_y = y[i+K-1]-y[i];
		int x_max = Integer.MIN_VALUE;
		int x_min = Integer.MAX_VALUE;
		for(int j=i;j<i+K;j++) {
			x_max = Math.max(x_max, y_x.get(y[j]));
			x_min = Math.min(x_min, y_x.get(y[j]));
		}
		long delta_x = x_max-x_min;
		
		if(delta_x*delta_y>0) result = Math.min(result, delta_x*delta_y);
	}
	
	
	out.println(result);

		out.flush();
	}


}