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 Scala (2.11.7) (judge verdict: Runtime Error)

import java.util.Scanner

trait ScannerApp extends App {
  val scanner = new Scanner(System.in)
}


case class Coordinate(x: Long, y: Long) {
  def distanceTo(another: Coordinate): Long = Math.sqrt(x * x + y * y).toLong
}

object Main extends ScannerApp {

  final val N = scanner.nextInt()
  final val K = scanner.nextInt()

  val coordinates: Seq[Coordinate] = for {
    _ <- 0 until N
    x = scanner.nextLong()
    y = scanner.nextLong()
  } yield Coordinate(x, y)

  val distanceMap: Seq[((Int, Int), Long)] = (for {
    i <- 0 until N
    j <- 0 until N
    c1 = coordinates(i)
    c2 = coordinates(j)
  } yield (i, j) -> c1.distanceTo(c2)).sortBy(_._2)

  val pair = distanceMap.find { case ((i, j), dist) =>
    val c1 = coordinates(i)
    val c2 = coordinates(j)

    val left = Math.min(c1.x, c2.x)
    val right = Math.max(c1.x, c2.x)
    val top = Math.max(c1.y, c2.y)
    val bottom = Math.min(c1.y, c2.y)

    val k = coordinates.count{ c => left <= c.x && c.x <= right && bottom <= c.y && c.y <= top }
    k >= K
  }.get._1

  val c1 = coordinates(pair._1)
  val c2 = coordinates(pair._2)
  val answer: Long = Math.abs(c1.x - c2.x) * Math.abs(c1.y - c2.y)
  println(answer)

}