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# (Mono 4.6.2.0) (judge verdict: Accepted)

using System.Collections.Generic;
using System.Linq;
using System;

public class P
{
    public int x { get; set; }
    public int y { get; set; }
}

public class Hello
{
    public static void Main()
    {
        var ps = new List<P>();
        string[] line = Console.ReadLine().Trim().Split(' ');
        var n = int.Parse(line[0]);
        var k = int.Parse(line[1]);
        var ax = new int[n];
        var ay = new int[n];
        for (int i = 0; i < n; i++)
        {
            line = Console.ReadLine().Trim().Split(' ');
            var x = int.Parse(line[0]);
            var y = int.Parse(line[1]);
            ax[i] = x;
            ay[i] = y;
            ps.Add(new P { x = x, y = y });
        }
        Console.WriteLine(getAns(ax, ay, ps, n, k));
    }
    public static long getAns(int[] ax, int[] ay, List<P> ps, int n, int kk)
    {
        int p1; int p2; int p3; int p4;
        var retlist = new List<long>();
        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++)
                    {
                        p1 = ax[i]; p2 = ax[j]; p3 = ay[k]; p4 = ay[L];
                        if ((p1 > p2) && (p3 > p4) && check(p1, p2, p3, p4, kk, ps))
                            retlist.Add((long)(p1 - p2) * (long)(p3 - p4));
                    }
        return retlist.Min();
    }
    public static bool check(int p1, int p2, int p3, int p4, int kk, List<P> ps)
    {
        var count = 0;
        foreach (var x in ps)
            if (x.x <= p1 && x.x >= p2 && x.y <= p3 && x.y >= p4) count++;
        return count >= kk;
    }
}