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.util.*;

// CODEFES_B 2017-C
// http://code-festival-2017-qualb.contest.atcoder.jp/tasks/code_festival_2017_qualb_c	

public class Main {
	
	public static void main (String[] args) throws InterruptedException {
		Scanner in = new Scanner(System.in);

		int N = in.nextInt();
		int K = in.nextInt();
		
		long Min = -1000000000L;
		long Max = 1000000000L;
		long answer = Long.MAX_VALUE;
		
		ArrayList<SortX> x = new ArrayList<SortX>();
		ArrayList<SortY> y = new ArrayList<SortY>();
		
		for (int i = 0; i < N; i++) {
			long xx = in.nextLong();
			long yy = in.nextLong();
			
			x.add(new SortX(xx, yy));
			y.add(new SortY(xx, yy));
		}
		
		x.sort(null);
		y.sort(null);
		
		for (int i = 0; i <= N - K; i++) {
			long smallerY = Max; // Apply min
			long biggerY = Min; // Apply max
			long smallerX = x.get(i).x;
			long biggerX = Min; // 
			
			for (int j = i; j < i + K; j++) {
				smallerY = Math.min(smallerY, x.get(j).y);
				biggerY = Math.max(biggerY, x.get(j).y);
				biggerX = Math.max(biggerX, x.get(j).x);
			}
			
			long area = (biggerX - smallerX) * (biggerY - smallerY);
			if (area == 0) {
				area = 1 * Math.max(biggerX - smallerX, biggerY - smallerY);
			}
			answer = Math.min(answer, area);
		}

		for (int i = 0; i <= N - K; i++) {
			long smallerY = y.get(i).y;
			long biggerY = Min; // Apply max
			long smallerX = Max; // Apply min
			long biggerX = Min; // Apply max
			
			for (int j = i; j < i + K; j++) {
				biggerY = Math.max(biggerY, y.get(j).y);
				smallerX = Math.min(smallerX, y.get(j).x);
				biggerX = Math.max(biggerX, y.get(j).x);
			}
			
			long area = (biggerX - smallerX) * (biggerY - smallerY);
			if (area == 0) {
				area = 1 * Math.max(biggerX - smallerX, biggerY - smallerY);
			}
			answer = Math.min(answer, area);
		}
		
		System.out.println(answer);
	}
}

class SortX implements Comparable<SortX> {
	long x;
	long y;

	public SortX(long x, long y) {
		this.x = x;
		this.y = y;
	}
	
	@Override
	public int compareTo(SortX o) {
		if (this.x < o.x) {
			return -1;
		} else if (this.x > o.x) {
			return 1;
		} else {
			return 0;
		}
	}
}

class SortY implements Comparable<SortY> {
	long x;
	long y;
	
	public SortY(long x, long y) {
		this.x = x;
		this.y = y;
	}

	@Override
	public int compareTo(SortY o) {
		if (this.y < o.y) {
			return -1;
		} else if (this.y > o.y) {
			return 1;
		} else {
			return 0;
		}
	}
}