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;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace AtCoder
{
    class Program
    {
        private const int MODULO = 1000000007;
        private static string Read() { return Console.ReadLine(); }
        private static int ReadInt() { return int.Parse(Read()); }
        private static long ReadLong() { return long.Parse(Read()); }
        private static double ReadDouble() { return double.Parse(Read()); }
        private static int[] ReadInts() { return Array.ConvertAll(Read().Split(), int.Parse); }
        private static long[] ReadLongs() { return Array.ConvertAll(Read().Split(), long.Parse); }
        private static double[] ReadDoubles() { return Array.ConvertAll(Read().Split(), double.Parse); }

        class Point
        {
            public readonly long x;
            public readonly long y;
            public Point(long[] v)
            {
                x = v[0];
                y = v[1];
            }
        }
        static long Solve(int N, int K, Point[] points)
        {
            var set1 = new HashSet<long>();
            var set2 = new HashSet<long>();
            foreach (var point in points)
            {
                set1.Add(point.x);
                set2.Add(point.y);
            }
            long min = long.MaxValue;
            var X = set1.OrderBy(x => x).ToArray();
            var Y = set2.OrderBy(y => y).ToArray();
            for (int i = 0; i < X.Length; ++i)
            {
                long x1 = X[i];
                for (int j = i + 1; j < X.Length; ++j)
                {
                    long x2 = X[j];
                    for (int k = 0; k < Y.Length; ++k)
                    {
                        long y1 = Y[k];
                        for (int l = k + 1; l < Y.Length; ++l)
                        {
                            long y2 = Y[l];
                            int count = 0;
                            foreach (var p in points)
                            {
                                if (x1 <= p.x && p.x <= x2 && y1 <= p.y && p.y <= y2)
                                {
                                    if (++count > K) { break; }
                                }
                            }
                            if (count == K) { min = Math.Min((x2 - x1) * (y2 - y1), min); }
                        }
                    }
                }
            }
            return min;
        }
        static void Main(string[] args)
        {
            int[] v = ReadInts();
            int N = v[0];
            int K = v[1];
            var points = new Point[N];
            for (int i = 0; i < N; ++i) { points[i] = new Point(ReadLongs()); }
            Console.WriteLine(Solve(N, K, points));
        }
    }
}